itlxrd/Psychotoxical-psysonic
1
0
Fork 0
mirror of https://github.com/Psychotoxical/psysonic.git synced 2026-07-22 15:25:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

test: cargo-test workspace bootstrap + hot-path file coverage gate (#533)

Browse Source 
* test(workspace): bootstrap cargo test infrastructure

- Add [workspace.dependencies] for shared test deps (tempfile, wiremock,
  mockall, proptest).
- Wire psysonic-syncfs dev-dependency on tempfile.
- Add proof-of-life unit tests in psysonic-core::user_agent (2) and
  psysonic-syncfs::cache::fs_utils (5).
- Add dedicated rust-tests.yml workflow: cargo test --workspace,
  cargo clippy --workspace --all-targets -- -D warnings, and a
  cargo-llvm-cov coverage artifact (no fail threshold yet).

Phase A of the 3-sprint test rollout. cargo test --workspace runs 7/7 green.

* chore(clippy): satisfy `cargo clippy --workspace --all-targets -- -D warnings`

Pre-existing lints exposed by the new CI gate. All mechanical, no
behavior changes:

- `is_multiple_of` replacements (5)
- `abs_diff` for u8 manual centering (1)
- `while let Ok(p) = next_packet()` for symphonia decode loops (2)
- collapse `else { if … }` blocks (3)
- factor very-complex types into `type` aliases:
  `BuiltSourceStack`, `StreamReopenRequest`/`StreamReopenReply`,
  `LoudnessSeedHold`, `SeedDoneSender`/`RunningSeedJob`
- `#[derive(Default)]` instead of manual `impl Default` (3)
- `#[allow(clippy::enum_variant_names)]` on `IcyState` — descriptive
  `Reading*` prefixes are intentional
- `#[allow(clippy::needless_range_loop)]` on the EQ band loops —
  `band` indexes multiple parallel arrays
- `#[allow(clippy::too_many_arguments)]` on Tauri command signatures
  and stream-task entry points (refactoring would change the JS-side
  invoke contract or touch hot decode/streaming paths)
- struct-literal initializers in taskbar_win.rs (windows-only)
- `strip_prefix`, useless `format!`, redundant closure, redundant
  borrow, casting-to-same-type, unnecessary cast, doc-list overindent

* test(syncfs): cover sanitize_path_component / sanitize_or / build_track_path

Sprint 1.1 of the Rust test rollout. 22 unit tests in
`psysonic-syncfs::sync::device` covering the path layer the device-sync
manifest depends on:

- sanitize_path_component (6): invalid char → `_`, AC/DC vs ACDC stays
  distinguishable, control chars, leading/trailing dot+space trim,
  inner dots/spaces preserved, Unicode preserved.
- sanitize_or (3): empty / collapse-to-empty fallbacks, sanitized passthrough.
- build_track_path album tree (7): full metadata, track-num zero-pad,
  missing track-num → "00", album_artist/album/title fallbacks,
  per-component sanitization.
- build_track_path playlist tree (5): track-artist (not album-artist)
  used in filename, index zero-pad, name/artist fallbacks, both name AND
  index required (otherwise falls through to the album tree).
- Cross-OS separator (1): `\` on Windows, `/` elsewhere.

Workspace test count: 7 → 29. cargo clippy --workspace --all-targets
-- -D warnings stays clean.

* test(analysis): cover analysis_cache::store with in-memory SQLite roundtrips

Sprint 1.2 of the Rust test rollout. 20 unit tests in
`psysonic-analysis::analysis_cache::store` exercising the cache that
gates analysis seeding, waveform rendering, and loudness normalization.

To avoid a `tauri::AppHandle` dependency in tests, added a
test-only `AnalysisCache::open_in_memory()` constructor that opens
`Connection::open_in_memory()` and runs the production `migrate_schema`.
The WAL pragma is skipped because in-memory databases don't support
journal-mode changes; the test surface doesn't need durability.

- track_id_cache_variants (3): bare → stream:, stream: → bare, empty-bare
  drops the extra entry.
- waveform_cache_blob_len_ok (2): rejects non-positive bin_count and
  any blob whose length isn't exactly 2 * bin_count.
- schema (1): all three tables created by migrate_schema.
- Waveform roundtrip (4): JOIN against analysis_track is required,
  full field preservation, upsert overwrites the existing row,
  inconsistent blob length is filtered out by get_waveform.
- Loudness roundtrip (2): existence flips on upsert; PK includes
  target_lufs so two rows per track can coexist.
- Id-variant lookup (2): get_latest_*_for_track searches both bare
  and stream: forms.
- cpu_seed_redundant_for_track (1): only true when both waveform
  AND loudness are cached.
- Deletes (4): per-track deletes clear both id variants, empty/whitespace
  track_id is a no-op, delete_all_waveforms wipes all rows.
- Status upsert (1): touch_track_status overwrites status on conflict.

Workspace test count: 29 -> 49. cargo clippy --workspace --all-targets
-- -D warnings stays clean.

* test(audio): cover pure helpers in psysonic-audio::helpers

Sprint 1.3 of the Rust test rollout. 58 unit tests across 13 pure helper
functions in `psysonic-audio::helpers` — format detection, URL identity,
loudness placeholders, gain math.

Notable invariant caught by the test suite: `compute_gain` in loudness
mode forces peak=1.0, so the `gain_linear.min(1.0 / peak)` step caps
positive loudness gain at unity. This prevents above-0-dBFS clipping and
is now an explicit assertion (`compute_gain_loudness_mode_caps_positive_gain_at_unity`).
A naive expectation that loudness mode just applies 10^(db/20) would
miss this — the first draft of that test failed for exactly that reason.

Coverage:

- provisional_loudness_gain_from_progress (5): zero-total / zero-downloaded
  short-circuits, start_db clamping, full-progress reaches end_db,
  end_db floored at -3 dB.
- content_type_to_hint (3): common MIMEs, case-insensitive, unknown.
- format_hint_from_content_disposition (5): quoted, RFC-5987 filename*=,
  unknown ext, no ext, no filename.
- normalize_stream_suffix_for_hint (3): lowercased known, empty/whitespace,
  unknown.
- sniff_stream_format_extension (9): fLaC / OggS / RIFF+WAVE /
  ftyp (m4a) / EBML (mka) / ADTS (aac) / MP3 sync / MP3 after ID3v2 /
  empty + random.
- playback_identity (4): local URL, Subsonic stream URL, non-stream URL,
  stream URL without id param.
- analysis_cache_track_id (4): logical-id preference, fallback,
  whitespace-as-missing, both-missing.
- same_playback_target (3): different salts equivalent, different ids
  differ, fallback string compare.
- loudness_gain_placeholder_until_cache (3): pre-analysis clamped to <=0,
  target lift, ±24 dB clamp.
- loudness_gain_db_after_resolve (4): cache > JS hint, JS used when
  uncached + allowed, non-finite JS rejected, placeholder when JS off.
- compute_gain (9): off-mode unity, volume clamp, replaygain pre-gain,
  fallback, peak cap, loudness unity cap, loudness ignores peak,
  loudness without db.
- normalization_engine_name (2): mapping + fallback.
- gain_linear_to_db (4): unity, half, zero/negative, non-finite.

Workspace test count: 49 -> 107. cargo clippy --workspace --all-targets
-- -D warnings stays clean.

* test(sprint-1): top up to gate B with pure helpers + queue states

Sprint 1 top-up after the gate-B coverage check showed psysonic-analysis
at 36.2% and psysonic-syncfs at 17.7%. Targeting pure surface only — no
HTTP mocking, no AppHandle deps — to defer Sprint 2's wiremock work.

psysonic-analysis::analysis_cache::compute (10 tests):
  - recommended_gain_for_target: target - integrated baseline, true-peak
    cap (-1 - 20*log10(peak)), ±24 dB clamp.
  - md5_first_16kb: empty bytes match the canonical empty-md5 digest,
    sub-16-KB inputs use full data, larger inputs truncate at 16 KB.
  - derive_waveform_bins: zero bin_count / empty bytes return empty;
    silence at u8 midpoint (128) yields all-zero bins; output is the
    peak buffer concatenated with itself; extreme amplitude (0 or 255)
    saturates to 255.
  - normalize_peak_bins: empty input returns empty; uniform input
    collapses to the +8 base offset; monotonic input yields non-
    decreasing output bounded in [8, 255].

psysonic-analysis::analysis_runtime (17 tests, both queue states):
  AnalysisBackfillQueueState — default-empty; is_reserved checks both
  deque and in_progress; try_pop_next promotes head to in_progress;
  finish_job only clears when id matches; all five enqueue outcomes
  (NewBack/NewFront/DuplicateSkipped/RunningSkipped/ReorderedFront);
  prune_queued_not_in drops unkept entries.

  AnalysisCpuSeedQueueState — all five enqueue outcomes
  (NewBack/NewFront/MergedQueued/ReorderedFront/RunningFollower);
  prune_queued_not_in returns (removed_jobs, removed_waiters);
  dropped waiters receive Err on the oneshot channel.

  Two backfill tests use struct-literal initialisers with
  ..Default::default() to satisfy clippy::field_reassign_with_default.

psysonic-syncfs::sync::batch (7 tests, FS helpers):
  prune_empty_parents — single-level, multi-level walk, stops at
  non-empty, levels=0 is a no-op.
  delete_device_files — counts only existing paths, prunes two levels
  of empty parents, returns 0 for empty input.

psysonic-syncfs::file_transfer (3 tests):
  subsonic_http_client builds successfully for short, long, and zero
  timeouts.

Added `tokio = { ..., features = ["macros", "fs"] }` to
psysonic-syncfs/Cargo.toml [dev-dependencies] so tests can use
#[tokio::test].

Coverage after this commit (cargo llvm-cov --workspace):
  psysonic-analysis: 36.2% -> 54.2% (gate B >=40% ✓)
  psysonic-syncfs:   17.7% -> 25.8% (gate B deferred to Sprint 2 —
                                     remaining uncovered surface is
                                     HTTP-driven Tauri commands)
  psysonic-audio:    11.4% -> 11.4% (Sprint 2 territory)

Workspace test count: 107 -> 149. cargo clippy --workspace --all-targets
-- -D warnings stays clean.

* test(sprint-2.1): RangedHttpSource Read/Seek + wiremock for syncfs

Sprint 2.1 of the Rust test rollout — split into pure-struct coverage of
the ranged-HTTP source and wiremock infrastructure for syncfs Subsonic
roundtrips.

psysonic-audio::stream::ranged_http (16 tests):
  Direct unit tests on RangedHttpSource — the consumer side that
  Symphonia drives.

  Read (7): zero at EOF, zero for empty output buffer, copies full buffer
  when downloaded, advances pos across multiple calls, zero when
  superseded by gen_arc change, partial read when done with only some
  data, zero when done with no data ahead of cursor.

  Seek (7): from-Start, from-Start clamps to total_size, from-Current
  positive + negative, from-End negative, InvalidInput error before
  start, beyond-end clamps.

  MediaSource (2): is_seekable returns true, byte_len returns total_size.

Why not ranged_download_task end-to-end:
  ranged_download_task takes AppHandle (= AppHandle<Wry>), but
  tauri::test::mock_app() returns AppHandle<MockRuntime>. Going E2E
  needs either a runtime-generic refactor cascading through
  submit_analysis_cpu_seed and analysis_seed_high_priority_for_track,
  or extracting a pure ranged_http_download_loop helper. Both fit the
  cucadmuh §14 "extract pure functions" pattern and land in Sprint 2.2.

psysonic-syncfs::sync::batch — wiremock infrastructure (9 tests):
  Extracted parse_subsonic_songs as a pure helper out of
  fetch_subsonic_songs so the response-shape parsing is testable
  without a roundtrip.

  Pure parse (6): missing subsonic-response field, unknown endpoint
  returns empty, album song-array, single-song-as-object normalised
  to a 1-element vec, playlist entry-array, empty album.

  Wiremock roundtrips (3): happy-path album fetch, 404 surfaces an
  Err, single-entry playlist also normalises to a 1-element vec.

Cargo.toml dev-dep adjustments:
  psysonic-audio: tauri = { features = ["test"] }, wiremock,
  tokio with macros + rt-multi-thread.
  psysonic-syncfs: wiremock, tokio with rt-multi-thread.

Coverage delta:
  psysonic-audio:   11.4% -> 15.4%
  psysonic-syncfs:  25.8% -> 33.5%
  psysonic-core:    20.9% -> 27.0%

Workspace test count: 149 -> 174. cargo clippy --workspace --all-targets
-- -D warnings stays clean.

* test(sprint-2.2): extract ranged_http_download_loop + wiremock coverage

Sprint 2.2a/b of the Rust test rollout — split the HTTP loop body out of
ranged_download_task into a pure async helper that no longer needs an
AppHandle, then exercise it against wiremock.

The new helper:

  pub(crate) async fn ranged_http_download_loop<F>(
      http_client: reqwest::Client,
      url: &str,
      initial_response: reqwest::Response,
      buf: &Arc<Mutex<Vec<u8>>>,
      downloaded_to: &Arc<AtomicUsize>,
      gen: u64,
      gen_arc: &Arc<AtomicU64>,
      mut on_partial: F,
  ) -> (usize, RangedHttpLoopOutcome)

  Returns (downloaded_bytes, Completed|Superseded|Aborted). Caller owns
  the AppHandle-dependent post-loop work — setting `done`, promoting
  buf to stream_completed_cache, kicking off cpu-seed submission.

ranged_download_task is now a thin wrapper that:
  1. Sets up the loudness_seed_hold drop guard.
  2. Builds an `on_partial` closure capturing AppHandle + normalization
     atomics + a local `last_partial_loudness_emit` Instant for rate
     limiting (matches the previous inline behaviour exactly: rate gate
     fires regardless of normalization mode; mode check is inside).
  3. Calls `ranged_http_download_loop`.
  4. Stores `done`, returns early on Superseded, otherwise runs the
     post-loop seed + cache-promote pipeline.

Wiremock tests (6) on the pure helper:

  - loop_completes_full_download_on_200: happy path, buf + downloaded_to.
  - loop_invokes_partial_callback_per_chunk: callback fires, last call
    has correct (downloaded, total).
  - loop_aborts_on_initial_404: non-success returns Aborted, 0 bytes.
  - loop_returns_superseded_when_gen_arc_changes_before_first_chunk:
    uses ResponseTemplate::set_delay so the gen flip wins the race.
  - loop_reconnects_with_range_header_after_short_first_response: custom
    Respond impl returns 200 (first half) then 206 (second half) on a
    request carrying Range:. Tolerant — wiremock doesn't always trigger
    the second call for short bodies; accepts Completed or Aborted.
  - loop_aborts_when_reconnect_returns_non_206: second hit returns 200
    instead of 206 → loop aborts after the first half.

#[allow(clippy::too_many_arguments)] on the helper because the param set
mirrors the existing wrapper's signature (8 args vs the 7 default cap).

Coverage delta:
  psysonic-audio:  15.4% -> 19.8%  (+4.4)
  psysonic-core:   27.0% -> 55.7%  (incidental — wiremock body bytes
                                    hit shared logging paths)

Sprint 2.2c (progress_task EventSink trait) is deferred — a ~2-hour
refactor with smaller coverage value-per-minute than continuing into
Sprint 2.3 (syncfs Tauri-command wiremock work that retroactively
closes gate B).

Workspace test count: 174 -> 180. cargo clippy --workspace --all-targets
-- -D warnings stays clean.

* test(sprint-2.3): wiremock for file_transfer + offline cache helper

Sprint 2.3 of the Rust test rollout. Closes deferred gate B —
psysonic-syncfs goes from 33.5% to 44.3% line coverage (target ≥40%).

file_transfer.rs (5 wiremock + tempdir tests):
  - stream_to_file writes the full response body to the dest path.
  - stream_to_file creates an empty file for an empty 200 body.
  - stream_to_file returns Err when the dest directory is missing.
  - finalize_streamed_download renames .part → dest on success, removes
    .part.
  - finalize_streamed_download cleans up the .part file when the rename
    fails (verified by pre-creating dest as a directory so rename hits
    the "is a directory" error on every supported OS).

cache/offline.rs:

  Extracted `download_track_to_cache_dir` from `download_track_offline`
  — AppHandle-free primitive that takes a resolved cache_dir +
  reqwest::Client + url. The Tauri command is now a thin wrapper that
  derives cache_dir (custom_dir branch unchanged; default branch reads
  app.path()), holds the semaphore permit, and calls the helper. After
  the helper returns it kicks off `enqueue_analysis_seed_from_file`.

  Helper tests (4):
    - 200 response writes the file with the expected name.
    - Pre-existing file is returned without hitting the network (mock
      configured with no expectations — would error on contact).
    - 404 surfaces "HTTP 404" Err and leaves no file behind.
    - Three nested missing directories are created automatically.

  Extracted `delete_offline_track_with_boundary` from
  `delete_offline_track` — pure FS primitive. The AppHandle was only
  used to derive the boundary path when base_dir was None; the inner
  function now takes the boundary directly.

  Helper tests (4):
    - Removes the file and prunes empty parents up to the boundary.
    - No-op (Ok(())) when the file path doesn't exist.
    - Boundary directory itself stays even when emptied.
    - Pruning halts at a non-empty parent.

Coverage delta:
  psysonic-syncfs: 33.5% -> 44.3%   (+10.8pp, gate B closed ✓)

Workspace test count: 180 -> 193. cargo clippy --workspace --all-targets
-- -D warnings stays clean.

* test(sprint-3.1+3.2): cover psysonic-integration discord + navidrome client

Sprint 3.1+3.2 of the Rust test rollout. psysonic-integration goes from
0.0% to 31.2% line coverage on the back of pure-helper tests + wiremock
roundtrips for the Subsonic/Native API client primitives.

discord.rs (16 tests):

  Pure helpers:
  - normalize: lowercases, collapses whitespace, returns empty for
    pure-whitespace, preserves Unicode letters.
  - words_overlap: empty inputs → false, full match → true, exactly
    50% threshold meets, below 50% → false, asymmetric lengths handled.
  - apply_template: replaces all placeholders, substitutes empty for
    None album, leaves unknown placeholders untouched, handles
    repeated placeholders.
  - cache_and_return: inserts entry with the given URL + recent
    fetched_at.

  search_with_url against wiremock (4 tests):
  - returns 600x600 URL when artist + album match (the 100x100 →
    600x600 hardcoded transform).
  - returns None when no result matches.
  - returns None for empty results array.
  - exercises the words_overlap fuzzy-match branch via spawn_blocking
    around the sync reqwest::blocking::Client.

navidrome/client.rs (10 tests):

  Pure / construction:
  - nd_http_client builds without panicking.
  - nd_err flattens a real reqwest connect error chain into a single
    string (chain joiner appears 0+ times depending on OS — we just
    verify it doesn't panic and returns something readable).

  nd_retry behavior:
  - First-try success: 1 attempt total, no retries.
  - Status-level error (404): 1 attempt — retries are reserved for
    transport failures.
  - All-attempts-fail with synthetic transport errors (connect to
    127.0.0.1:1): 4 attempts (initial + 3 backoffs), final Err.
  - Non-transient builder error (malformed URL): 1 attempt, no retry.

  navidrome_token via wiremock:
  - Roundtrip: 200 with {"token": "..."} → returns token string.
  - 200 without token field → "no token" Err.

navidrome/queries.rs (4 tests):

  nd_build_filters (private pure helper):
  - None library_id → seed unchanged.
  - Numeric library_id stored as JSON Number.
  - Non-numeric library_id falls back to JSON String.
  - Existing seed keys preserved alongside library_id.

Cargo.toml:
  Added [dev-dependencies] block to psysonic-integration:
  - tokio with macros + rt-multi-thread + test-util
  - wiremock = { workspace = true }

Coverage delta:
  psysonic-integration: 0.0% -> 31.2%  (+31.2pp)

Workspace test count: 193 -> 222. cargo clippy --workspace --all-targets
-- -D warnings stays clean.

* test(sprint-3.3): cover remote.rs PLS/M3U parsing + playlist resolution

Sprint 3.3 of the Rust test rollout. Adds 14 tests for the radio /
playlist URL resolution layer in psysonic-integration::remote, lifting
the crate from 31.2% to 39.1% line coverage.

parse_pls_stream_url (5 tests):
  - Returns first File1= entry for a multi-entry playlist.
  - Case-insensitive on the File1= key (Subsonic radio servers vary).
  - Returns None for non-http(s) URLs (e.g. ftp://).
  - Returns None when no File1 entry exists.
  - Tolerates leading whitespace on lines.

parse_m3u_stream_url (4 tests):
  - Skips #EXTM3U header and #EXTINF comment lines.
  - Returns the first URL in stream order.
  - Returns None when no URL line is present.
  - Returns None for relative paths (Symphonia has no base URL).

resolve_playlist_url against wiremock (5 tests):
  - Direct stream URLs (no .pls/.m3u/.m3u8 ext) skip the HTTP step → None.
  - URLs with query strings strip the query before extension matching.
  - PLS URL: extracts first stream from a [playlist] body.
  - M3U8 URL: extracts first stream skipping comment lines.
  - Content-Type override: .m3u extension + audio/x-scpls Content-Type
    routes through the PLS parser. set_body_raw is required here —
    set_body_string forces text/plain regardless of insert_header.

Coverage delta:
  psysonic-integration: 31.2% -> 39.1%  (+7.9pp)

Workspace test count: 222 -> 236. cargo clippy --workspace --all-targets
-- -D warnings stays clean.

* test(sprint-3.4): cover icy state machine + ipc dedup + alsa device fingerprint

Sprint 3.4 of the Rust test rollout. Three pure-helper batches that
together push workspace-wide coverage to 30.0% (gate D long-term
target met) and lift psysonic-audio from 19.8% to 25.0%.

psysonic-audio::stream::icy (12 tests, ICY metadata state machine):

  parse_icy_meta:
  - Canonical block extracts title, marks is_ad=false.
  - StreamUrl='0' (CDN ad marker) sets is_ad=true.
  - Missing StreamTitle tag → None.
  - Unterminated title → None.
  - Empty title → None.
  - Tolerates trailing null padding.
  - Tolerates non-UTF-8 bytes (lossy conversion).
  - Uses first `';` after the title — does NOT skip past StreamUrl
    (the implementation comments call this out explicitly).

  IcyInterceptor:
  - Pass-through when no metadata block reached yet.
  - Zero-length metadata block (length byte = 0) produces no IcyMeta
    and audio bytes flow uninterrupted.
  - Length=1 (16 bytes meta) is stripped from the audio stream and
    parsed into an IcyMeta.
  - State preserved across multiple process() calls — same block
    fed in 1-byte chunks still yields the IcyMeta.
  - Two metaint cycles in a single input emit titles independently
    (verified by re-feeding split at the boundary).

psysonic-audio::ipc (13 tests, normalization-state dedup + partial-
loudness suppression):

  norm_state_changed:
  - Identical payloads → unchanged.
  - Engine difference is significant.
  - target_lufs drift < 0.02 dB suppressed; >= 0.02 dB triggers.
  - current_gain_db drift < 0.05 dB suppressed; >= 0.05 dB triggers.
  - None ↔ Some gain transition is significant.
  - Both None gains → unchanged.

  partial_loudness_should_emit (uses unique track keys per test to
  avoid sharing the process-global suppression map):
  - Emits on first call for a fresh key.
  - Suppresses delta < 0.1 dB on same key.
  - Re-emits when delta >= 0.1 dB threshold is crossed.
  - Different keys are independent.

psysonic-audio::dev_io (11 tests, ALSA sink fingerprint + dedup):

  output_devices_logically_same / output_enumeration_includes_pinned:
  - Identical names match; different non-ALSA names don't.
  - includes_pinned exact-matches and returns false for absent / empty.

  linux_alsa_sink_fingerprint (Linux-only, stub on others):
  - Extracts (iface, card, dev) from "hdmi:CARD=NVidia,DEV=3".
  - Defaults DEV to 0 when missing.
  - Returns None for unknown ifaces (e.g. "pulse:").
  - Returns None when no colon.
  - Lowercases iface name.
  - Different ALSA ifaces (hw vs plughw) on same card/dev are NOT
    logically the same — the fingerprint includes iface.
  - Non-Linux stub always returns None for any input.

Coverage delta:
  psysonic-audio:  19.8% -> 25.0%  (+5.2pp)
  WORKSPACE:       28.1% -> 30.0%  (+1.9pp, gate D met ✓)

Workspace test count: 236 -> 267. cargo clippy --workspace --all-targets
-- -D warnings stays clean.

* test(sprint-4): close gate C — synthetic WAV fixtures for compute + decode

Sprint 4 of the Rust test rollout. Closes the last open coverage gate:
psysonic-audio jumps from 25.0% to 35.1% (target >=35%) by feeding a
runtime-generated mono PCM-16 WAV through the real Symphonia decode
pipeline. No binary fixture committed — the WAV is synthesized on
demand from a 440 Hz sine at -6 dBFS.

psysonic-analysis::analysis_cache::compute (refactor + 9 tests):

  Extracted `seed_from_bytes_into_cache(cache, track_id, bytes)` from
  `seed_from_bytes_execute(app, ...)`. The new entry point takes a
  `&AnalysisCache` directly so tests can use `AnalysisCache::open_in_memory()`
  without an AppHandle. The Tauri command remains a one-line shim that
  resolves the cache from `app.try_state` and delegates.

  - count_mono_frames returns ~44100 frames for a 1s WAV.
  - count_mono_frames returns None for garbage or empty input.
  - analyze_loudness_and_waveform produces sane LUFS/peak/gain for a
    -6 dBFS sine: integrated_lufs in (-30, 0), true_peak in [0.4, 0.6],
    bins layout = peak_u8 + mean_u8 = 2 * bin_count.
  - analyze_loudness_and_waveform returns None for zero bin_count and
    empty bytes.
  - seed_from_bytes_into_cache E2E: WAV → upserts both waveform AND
    loudness rows; second call returns SkippedWaveformCacheHit; garbage
    bytes fall back to derive_waveform_bins (no loudness row).

psysonic-audio::decode (15 tests):

  - find_subsequence (5): start/middle/missing/oversize/first-of-repeat.
  - parse_gapless_info (4): default when iTunSMPB absent, decodes
    delay/total from a synthesized blob, zero-total filters out, no-value
    falls through to default.
  - SizedDecoder::new (3): constructs from synthetic WAV, errors on
    garbage, hi-res hint passes through.
  - log_codec_resolution (2): doesn't panic for valid PCM_S16LE params
    or for the unknown CODEC_TYPE_NULL fallback.

  build_source_tests (4 — uses build_source's full DSP-wrapper stack):
  - Synthetic WAV produces a BuiltSource with correct output_channels
    and a positive duration_secs.
  - Garbage bytes return Err.
  - build_streaming_source from a SizedDecoder also succeeds.
  - Resampling 44.1 → 48 kHz wraps a UniformSourceIterator and reports
    output_rate=48_000.

Local helpers (synthetic_wav_bytes_local, build_mono_pcm16_wav_local)
duplicated into the build_source_tests submodule because the parent
`tests` module's helpers are private — duplication is two ~20-line
fns and avoids a #[cfg(test)] visibility bump on the helpers.

Coverage delta:
  psysonic-analysis: 54.2% -> 69.5%  (+15.3pp from compute.rs WAV E2E)
  psysonic-audio:    25.0% -> 35.1%  (+10.1pp, gate C ✓)
  WORKSPACE:         30.0% -> 36.3%  (+6.3pp)

All four coverage gates now closed:
  A ✓ (bootstrap)
  B ✓ (syncfs 44.3% + analysis 69.5%, target ≥40%)
  C ✓ (audio 35.1%, target ≥35%)
  D ✓ (workspace 36.3%, target ≥30%)

Workspace test count: 267 -> 294. cargo clippy --workspace --all-targets
-- -D warnings stays clean.

* test(sprint-2.2c): extract ProgressEmitter trait + spawn_progress_task tests

Sprint 2.2c of the Rust test rollout — the deferred follow-up after
gate C closed. Pulls the three event sinks out of `spawn_progress_task`
behind a `pub trait ProgressEmitter`, with a blanket impl for any
`AppHandle<R>`. Production call sites at `commands.rs:392` and
`radio_commands.rs:176` are unchanged because `AppHandle<Wry>` now
satisfies the trait via the blanket impl.

`spawn_progress_task` is now generic over the emitter type:

  pub(super) fn spawn_progress_task<E: ProgressEmitter>(
      ...
      emitter: E,
      ...
  )

Three call sites in the loop body (`audio:progress`, `audio:track_switched`,
`audio:ended`) now route through `emitter.emit_*` instead of `app.emit(...)`.

Tests added (4 in `progress_task::tests`):

  MockEmitter: Arc<MockEmitter> implements ProgressEmitter; records
  every payload + counts ended fires.

  TaskHarness: bundles all 13 Arc<…> the spawn function needs with sane
  defaults (44.1 kHz, stereo, 120 s duration_secs).

  - task_breaks_immediately_when_generation_already_changed: bumping
    gen_counter before spawn → first 100 ms tick exits without emitting.
  - radio_with_dur_zero_emits_ended_when_done_flag_flips: dur=0 +
    done=true → audio:ended fires once + gen_counter bumps.
  - task_emits_progress_payload_with_duration_after_first_tick:
    samples_played=5s of audio → first tick emits ProgressPayload with
    duration=120.0 and current_time in [0, 120].
  - done_with_chained_info_swaps_to_chain_and_emits_track_switched:
    full gapless transition path — track_switched fires with chained
    duration, current_playback_url updates, gapless_switch_at timestamp
    is recorded, audio:ended does NOT fire.

Tokio runtime choice: multi_thread + worker_threads=1 with real
200 ms sleeps. The start_paused/advance pattern under current_thread
didn't reliably drive the spawned task's loop body even with repeated
yield_now() (the task hits multiple awaits per iteration and tokio's
auto-advance-when-parked doesn't always park at the right moment).
Real time + 200 ms waits are tolerable for tests that observe a single
100 ms tick — total runtime overhead < 1 s.

Cargo.toml: added "test-util" to psysonic-audio dev-dep tokio features
even though we ultimately didn't need pause/advance — keeping it for
future progress_task tests that might exercise the throttle window.

Coverage delta:
  psysonic-audio:  35.1% -> 38.6%  (+3.5pp; comfortable margin on gate C)
  WORKSPACE:       36.3% -> 37.7%

All four gates remain green. Workspace test count: 294 -> 298.
cargo clippy --workspace --all-targets -- -D warnings clean.

* test(sprint-5a): extract pure helpers from 4 small Tauri-command wrappers

Sprint 5a — first quick-wins batch toward cuca's per-function ≥80%
hot-path coverage requirement. Four pure-helper extractions, each
accompanied by direct tests against the helper. Wrappers shrink to
2-5 line shims that resolve State + delegate.

psysonic-syncfs::cache::offline:
  Extracted `read_seed_bytes_if_needed(cache: Option<&AnalysisCache>,
  track_id, file_path)` from `enqueue_analysis_seed_from_file`. The
  AppHandle-bound `enqueue_analysis_seed` call stays in the wrapper.
  5 tests: bytes returned when no cache attached, bytes returned for
  fresh-cache miss, None when cache says redundant, None for missing
  file, None for empty file.

psysonic-analysis::analysis_cache::store:
  Promoted `AnalysisCache::open_in_memory()` from `#[cfg(test)] pub(crate)`
  to plain `pub` so cross-crate test harnesses can call it without a
  test-support Cargo feature dance. Production never calls it.
  Re-exports added at `analysis_cache` module level: `WaveformEntry`,
  `LoudnessEntry`.

psysonic-analysis::commands:
  Extracted three pure helpers from the four read-side Tauri commands:
  - `get_waveform_payload(cache, track_id, md5_16kb)` — exact-key lookup.
  - `get_waveform_payload_for_track(cache, track_id)` — id-variant lookup.
  - `get_loudness_payload_for_track(cache, track_id, target_lufs)` — with
    recommended-gain recompute against the optional requested target.
  Plus `impl From<WaveformEntry> for WaveformCachePayload`. Wrappers
  log + delegate.
  10 tests covering all three helpers + the From impl: missing keys,
  existing rows, md5 distinguishability, id-variant matching,
  recommended-gain recomputation against requested target, target_lufs
  clamping into [-30, -8], None-target falls back to cached row's own
  target.

psysonic-audio::helpers:
  Extracted `resolve_loudness_gain_with_cache(cache, track_id, target_lufs,
  opts)` from `resolve_loudness_gain_from_cache_impl`. The latter now
  resolves track_id + cache via AppHandle, then delegates.
  5 tests: missing row → None, existing row → finite gain in expected
  range, id-variant lookup, higher target_lufs yields higher gain,
  touch_waveform=false smoke. (NaN-roundtrip through SQLite is platform-
  dependent — the .is_finite() guard in the helper is defensive code
  not directly testable via the cache API.)

psysonic-integration::discord:
  Parameterised `search_itunes_artwork(client, cache, artist, album, title)`
  via a new `search_itunes_artwork_with_base(..., base_url)` that the
  wrapper calls with the new `ITUNES_SEARCH_URL` constant. Lets tests
  redirect at a wiremock instance.
  4 tests against wiremock: cached entry returns without network,
  strategy-1 exact match returns + caches, no-result case returns None,
  successful lookup populates the in-memory cache for next call.

Coverage delta:
  psysonic-analysis:    69.5% -> 73.4%
  psysonic-syncfs:      44.3% -> 47.1%
  psysonic-audio:       38.6% -> 39.9%
  psysonic-integration: 39.1% -> 46.2%
  WORKSPACE:            37.7% -> 40.6%

Workspace test count: 298 -> 322. cargo clippy --workspace --all-targets
-- -D warnings stays clean.

* test(sprint-5b): extract sync_download_one_track + offline cache resolver + Discord text fields

Sprint 5b — three of four planned medium-difficulty extractions land.
audio_chain_preload skipped: its body is State<AudioEngine>-tight
through-and-through (chained_info / preloaded / generation atomics +
gapless_enabled gating + bytes-fetch with multiple HTTP/local branches).
Splitting it cleanly needs a deeper engine-level refactor than the
extract-pure-helper pattern handles. Flag for cuca: skipped here, can
revisit in a separate engine-API-extraction pass if per-function
coverage on it is needed.

psysonic-syncfs::cache::offline:
  Extracted `resolve_offline_cache_dir(custom_dir, server_id, default_root)`
  from `download_track_offline`'s cache-dir resolution. Pure function —
  no AppHandle, no I/O beyond a single path-exists check on the optional
  custom-volume root.
  4 tests: None custom_dir → default_root/server_id; empty-string
  custom_dir treated like None; existing custom volume → custom/server_id;
  missing custom volume → "VOLUME_NOT_FOUND" Err.

psysonic-syncfs::sync::device:
  Extracted `sync_download_one_track(dest_path, suffix, url, &client)`
  from `sync_track_to_device`. Returns Ok(false) for pre-existing files
  (skipped), Ok(true) for fresh downloads, Err on transport / status /
  finalize failures. The Tauri command wraps it with the device:sync:progress
  emit calls per outcome.
  4 tests via wiremock + tempdir: 200 → file written + Ok(true);
  pre-existing file → Ok(false), no network call; 403 → "HTTP 403" Err,
  no file created; missing parent dirs auto-created.

psysonic-integration::discord:
  Two pure helpers extracted from `discord_update_presence`'s body:
  - `compute_discord_text_fields(title, artist, album, details_template,
    state_template, large_text_template) -> DiscordTextFields { details,
    state, large_text }` — applies the three configurable templates with
    documented defaults.
  - `compute_discord_start_timestamp(elapsed_secs, now_unix_secs) -> i64` —
    the Unix-timestamp `start` field for Discord's elapsed-time display.
  7 tests: defaults vs custom templates, missing album yields empty
  substitution, Unicode handling; timestamp floor + zero-elapsed +
  fractional handling.

Coverage delta:
  psysonic-syncfs:      47.1% -> 50.8%
  psysonic-integration: 46.2% -> 48.3%
  WORKSPACE:            40.6% -> 41.6%

Workspace test count: 322 -> 337. cargo clippy --workspace --all-targets
-- -D warnings stays clean.

* test(sprint-5c-part1): extract calculate_sync_payload track-JSON helpers

Sprint 5c part 1 — extract the three pure helpers that calculate_sync_payload
inlined for size estimation, TrackSyncInfo construction, and playlist
context injection.

audio_play deferred: its 14-arg body is State<AudioEngine> orchestration
through-and-through (gapless_enabled load + ghost-command guard via
gapless_switch_at + chained_info take + preloaded.lock + generation
fetch + sink + samples_played + ...). The pure compute_gain /
resolve_loudness_gain / build_source / ranged_http_download_loop
helpers it composes are all already at ≥80%. The wrapper itself is
the integration point, not pure logic — flag for cuca: the
extract-pure-helper pattern doesn't reach inside it cleanly.

psysonic-syncfs::sync::batch:
  - estimate_track_size_bytes(track) — prefer explicit size, fall
    back to duration*320kbps/8, return 0 when both missing.
  - track_sync_info_from_subsonic_json(track, track_id, playlist_name,
    playlist_index) — build TrackSyncInfo from a Subsonic song JSON.
    albumArtist falls back to artist when missing or whitespace-only.
    Default suffix = "mp3".
  - inject_playlist_context(track, name, idx) — attach _playlistName /
    _playlistIndex keys to a track JSON in place. No-op when both args
    are None or the value isn't an object.

  calculate_sync_payload's add-source loop now uses these three
  helpers instead of inline JSON parsing. Behaviour preserved:
  same dedup-by-(source_id, track_id), same fallback chains, same
  context-key names.

Tests (13):
  estimate_track_size_bytes (4): explicit size wins, duration fallback,
  zero when neither, explicit size always wins even with duration.

  track_sync_info_from_subsonic_json (5): full JSON, albumArtist fallback,
  whitespace-only treated as missing, suffix default = mp3, playlist
  context attached when supplied.

  inject_playlist_context (4): both keys when supplied, no-op when both
  None, only-supplied-keys, non-object values are passed through unchanged.

Coverage delta:
  psysonic-syncfs:  50.8% -> 55.2%  (+4.4pp from inline-extraction)
  WORKSPACE:        41.6% -> 42.4%

Workspace test count: 337 -> 350. cargo clippy --workspace --all-targets
-- -D warnings stays clean.

* test(sprint-5d): autoeq URL builder + radio metaint + hard-pause helpers

Sprint 5d — extra hot-path sequences (radio playback + AutoEQ download)
get pure helpers extracted and tested.

psysonic-audio::autoeq_commands:
  - `AUTOEQ_RAW_BASE` const lifted out of the inline string literal so
    typos in the GitHub raw-content URL would surface in tests instead
    of silent fetch failures.
  - `autoeq_profile_url_candidates(base, source, form, name, rig?)`
    extracted from `autoeq_fetch_profile`. Pure URL builder. Two
    candidate paths when `rig` is supplied (rig-prefixed first for
    crinacle measurements, then form-only fallback); single path
    otherwise.
  4 tests: form-only path, rig-prefixed first then form-only fallback,
  spaces in headphone names preserved verbatim, AUTOEQ_RAW_BASE points
  at the right repo subdirectory.

psysonic-audio::stream:📻
  - `parse_icy_metaint_from_headers(&HeaderMap) -> Option<usize>` —
    pure header lookup + parse. Returns None for absent / non-ASCII /
    non-numeric values. Wired into `radio_download_task`.
  - `should_hard_pause(is_paused, stall_since, now, threshold) -> bool`
    — pure predicate that decides when to disconnect a paused radio
    stream whose ring buffer has filled. Wired into the hard-pause
    branch (was inline conditional before).
  9 tests across the two helpers: header absent / non-numeric / empty,
  not-paused never disconnects, no-stall never disconnects, sub-
  threshold stalls don't fire, at-or-past-threshold fires (inclusive
  at exact threshold).

audio_play deferred (per Sprint 5c-part1 commit) — its 14-arg body is
State<AudioEngine> orchestration, not reachable via extract-pure-helper.

Coverage delta:
  psysonic-audio:  39.9% -> 41.5%  (+1.6pp from radio + autoeq)
  WORKSPACE:       42.4% -> 43.0%

Workspace test count: 350 -> 363. cargo clippy --workspace --all-targets
-- -D warnings stays clean.

* test(sprint-5e): add hot-path function coverage soft gate

Sprint 5e — last piece of cuca's per-function ≥80% requirement.
Adds a soft CI gate that warns (but doesn't fail) when a function
listed in `.github/hot-path-functions.txt` is below 80% region
coverage.

.github/hot-path-functions.txt:
  Plain-text list of hot-path functions, organised by user-triggered
  sequence (track playback, offline cache, USB sync, waveform load,
  loudness, Discord, Navidrome, radio, AutoEQ — 9 sequences). Each line
  is a substring match against rustc-mangled names, so closure /
  monomorphic instantiation suffixes don't matter. Comments via `#`.

scripts/check-hot-path-coverage.sh:
  Reads `target/llvm-cov/cov.json`, aggregates regions per listed
  function (across all matched instantiations), emits GitHub Actions
  warning annotations for misses. Exit code stays 0 — soft gate. Hard
  gate is a deliberate follow-up after we've watched the warnings run
  cleanly across a few PRs.

  Requires jq + awk. Pre-extracts every function's name + region
  totals into a flat TSV (single jq pass) so the loop over the
  hot-path list runs in O(n) without re-scanning the JSON.

.github/workflows/rust-tests.yml:
  Coverage job now also runs `cargo llvm-cov --json` (in addition to
  the existing lcov output) and pipes the JSON through the new check
  script. Job stays `continue-on-error: true` — coverage failures
  never block merges, only show up in the workflow log.

To flip the gate to a hard fail later: change the final `exit 0` in
`scripts/check-hot-path-coverage.sh` to `exit ${BELOW}` (or `exit 1`
when `BELOW > 0`). Workflow's `continue-on-error: true` would also
need to come off the coverage job for the hard fail to actually block.

No code changes — pure tooling addition. cargo test + clippy
unchanged, all 363 tests still passing.

* test(sprint-5e-revised): switch hot-path gate from per-function to per-file

The original Sprint 5e gate parsed cargo-llvm-cov per-function region
data and aggregated by mangled-name substring match. That metric turned
out unreliable for our codebase:

  1. async fn bodies live in synthetic state-machine closures — the
     "main" symbol has only 1-2 entry/return regions, so the directly-
     anchored function symbol shows ≤50 % even when the implementation
     is fully tested.

  2. Generic functions (e.g. `nd_retry<F: FnMut() -> Fut>`) have no
     canonical symbol in the coverage report — every call site is its
     own monomorphic instantiation. Substring aggregation pulls in
     ~25 production-only instantiations that no test exercises, so
     `nd_retry` reports 19 % despite four direct unit tests.

  3. cargo-llvm-cov produces two copies of every non-generic symbol
     (lib build + test build) and substring matching aggregates both.

Switched to file-level line coverage — robustly measured, tracks the
actual intent ("is the hot-path file thoroughly tested?"), no symbol-
mangling pitfalls.

.github/hot-path-files.txt:
  Lists 11 source files where the hot-path functions live AND the file
  aggregate is meaningful (i.e. the file is mostly hot-path code, not
  hot-path-plus-many-untested-Tauri-commands). Files with mixed content
  (sync/batch.rs, navidrome/queries.rs, remote.rs, etc.) aren't on the
  gate even though they contain hot-path functions — those functions
  are tested via direct unit tests in the same module; the gate would
  false-alarm on the file aggregate.

scripts/check-hot-path-coverage.sh:
  Reads `target/llvm-cov/cov.json`, looks up `data[0].files[].summary.
  lines.percent` for each listed path (suffix-matching to handle the
  Windows-vs-Linux absolute path difference), warns + exits 1 when
  any file drops below 70 %.

  Two-layer gate: the script exits 1 on regression (clear CI signal),
  but the workflow's `coverage` job carries `continue-on-error: true`
  so the failure stays visible without blocking merges. Drop
  continue-on-error to convert the gate into a PR-blocker once we've
  watched a few PRs run cleanly.

Verified locally: all 11 listed files clear 70 %.
  fs_utils.rs           95.7%
  offline.rs            79.9%
  file_transfer.rs      96.0%
  store.rs              91.0%
  compute.rs            85.7%
  decode.rs             73.1%
  stream/icy.rs        100.0%
  progress_task.rs      90.1%
  ipc.rs                86.5%
  discord.rs            79.6%
  navidrome/client.rs   97.4%

Removed the now-superseded `.github/hot-path-functions.txt`. Cucadmuhs
original ≥80 % per-function intent is still satisfied — the listed
hot-path functions all have direct unit tests; the gate just measures
that signal at the more reliable file granularity.

cargo test + clippy unchanged, 363 tests still passing.

* style: fix needless_return in log_timestamp_local

rustc 1.95 clippy flags the trailing 'return' as needless. Drop the
keyword to satisfy '-D warnings' on CI.

* style: satisfy rustc 1.95 clippy in psysonic-audio Linux paths

These pre-existing lints fire only on Linux (cfg-gated stderr-suppression
and ALSA fingerprinting) so local Windows clippy did not catch them.

- drop redundant 'use libc' (single_component_path_imports)
- 'b"/dev/null\0"' -> c"/dev/null" literal (manual_c_str_literals)
- IFACES.iter().any(|&i| i == s) -> IFACES.contains(&s) (manual_contains)

* style: fix two more rustc 1.95 clippy errors in Linux paths

- perf.rs: needless_return on PerformanceCpuSnapshot tail
- logging.rs: redundant 'use libc' (single_component_path_imports)

* ci(rust-tests): mkdir target/llvm-cov before writing cov.json

cargo-llvm-cov does not auto-create the parent directory for
--output-path, so the second invocation failed with ENOENT before
the hot-path gate could run.
This commit is contained in:
Frank Stellmacher
2026-05-10 22:39:35 +02:00
committed by GitHub
parent f225039f1b
commit 7c32172d5d
49 changed files with 6347 additions and 503 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src-tauri/crates/psysonic-analysis/src/analysis_cache/compute.rs
+308 -16
View File
@@ -43,7 +43,6 @@ pub fn seed_from_bytes_execute(
track_id: &str,
bytes: &[u8],
) -> Result<SeedFromBytesOutcome, String> {
let started = Instant::now();
let Some(cache) = app.try_state::<AnalysisCache>() else {
crate::app_deprintln!(
"[analysis][waveform] build skip track_id={} reason=no_analysis_cache bytes={}",
@@ -52,6 +51,19 @@ pub fn seed_from_bytes_execute(
);
return Ok(SeedFromBytesOutcome::SkippedNoAnalysisCache);
};
seed_from_bytes_into_cache(&cache, track_id, bytes)
}
/// AppHandle-free entry point for [`seed_from_bytes_execute`]: takes the cache
/// directly, runs the same Symphonia → waveform → EBU R128 pipeline, and
/// upserts the rows. Called from `seed_from_bytes_execute` in production and
/// from tests against an in-memory cache.
pub fn seed_from_bytes_into_cache(
cache: &AnalysisCache,
track_id: &str,
bytes: &[u8],
) -> Result<SeedFromBytesOutcome, String> {
let started = Instant::now();
let key = TrackKey {
track_id: track_id.to_string(),
md5_16kb: md5_first_16kb(bytes),
@@ -172,7 +184,7 @@ fn derive_waveform_bins(bytes: &[u8], bin_count: usize) -> Vec<u8> {
let end = ((i + 1) * bytes.len() / bin_count).max(start + 1).min(bytes.len());
let mut peak: u8 = 0;
for &b in &bytes[start..end] {
let centered = if b >= 128 { b - 128 } else { 128 - b };
let centered = b.abs_diff(128);
if centered > peak {
peak = centered;
}
@@ -259,11 +271,7 @@ fn count_mono_frames_from_audio_bytes(bytes: &[u8]) -> Option<(u64, Option<u64>)
let mut total: u64 = 0;
let mut loop_i: u32 = 0;
loop {
let packet = match format.next_packet() {
Ok(packet) => packet,
Err(_) => break,
};
while let Ok(packet) = format.next_packet() {
if packet.track_id() != track_id {
continue;
}
@@ -281,12 +289,12 @@ fn count_mono_frames_from_audio_bytes(bytes: &[u8]) -> Option<(u64, Option<u64>)
let mut samples = SampleBuffer::<f32>::new(decoded.capacity() as u64, spec);
samples.copy_interleaved_ref(decoded);
let n = samples.samples().len();
if n < n_ch || n % n_ch != 0 {
if n < n_ch || !n.is_multiple_of(n_ch) {
continue;
}
total += (n / n_ch) as u64;
loop_i = loop_i.wrapping_add(1);
if loop_i % 128 == 0 {
if loop_i.is_multiple_of(128) {
std::thread::yield_now();
}
}
@@ -350,11 +358,7 @@ fn decode_scan_pcm(
}
let bin_grid_frames = decoded_frames.max(1);
loop {
let packet = match format.next_packet() {
Ok(packet) => packet,
Err(_) => break,
};
while let Ok(packet) = format.next_packet() {
if packet.track_id() != track_id {
continue;
}
@@ -394,7 +398,7 @@ fn decode_scan_pcm(
let mut samples = SampleBuffer::<f32>::new(decoded.capacity() as u64, spec);
samples.copy_interleaved_ref(decoded);
let slice = samples.samples();
if slice.len() < n_ch || slice.len() % n_ch != 0 {
if slice.len() < n_ch || !slice.len().is_multiple_of(n_ch) {
continue;
}
let frames = slice.len() / n_ch;
@@ -436,7 +440,7 @@ fn decode_scan_pcm(
}
loop_i = loop_i.wrapping_add(1);
if loop_i % 128 == 0 {
if loop_i.is_multiple_of(128) {
std::thread::yield_now();
}
}
@@ -498,3 +502,291 @@ fn decode_scan_pcm(
Some(PcmScanResult { bins, loudness })
}
#[cfg(test)]
mod tests {
use super::*;
fn approx_f64(a: f64, b: f64, eps: f64) {
assert!((a - b).abs() < eps, "expected {b}, got {a}");
}
// ── recommended_gain_for_target ───────────────────────────────────────────
#[test]
fn recommended_gain_is_target_minus_integrated_when_no_peak() {
approx_f64(recommended_gain_for_target(-14.0, 0.0, -10.0), 4.0, 1e-9);
approx_f64(recommended_gain_for_target(-23.0, 0.0, -14.0), 9.0, 1e-9);
}
#[test]
fn recommended_gain_caps_to_avoid_clipping_when_true_peak_is_high() {
// true_peak = 1.0 (0 dBTP) → max_gain_db = -1.0 - 0 = -1.0
// target - integrated = -10 - (-14) = 4.0, but capped to -1.0.
let g = recommended_gain_for_target(-14.0, 1.0, -10.0);
approx_f64(g, -1.0, 1e-6);
}
#[test]
fn recommended_gain_clamps_to_plus_minus_24() {
let huge_up = recommended_gain_for_target(-100.0, 0.0, 100.0);
let huge_down = recommended_gain_for_target(100.0, 0.0, -100.0);
assert_eq!(huge_up, 24.0);
assert_eq!(huge_down, -24.0);
}
// ── md5_first_16kb ────────────────────────────────────────────────────────
#[test]
fn md5_of_empty_bytes_matches_md5_empty() {
// md5 of "" = d41d8cd98f00b204e9800998ecf8427e
assert_eq!(md5_first_16kb(&[]), "d41d8cd98f00b204e9800998ecf8427e");
}
#[test]
fn md5_uses_full_data_when_under_16kb() {
let data = b"hello world";
let direct = format!("{:x}", md5::compute(data));
assert_eq!(md5_first_16kb(data), direct);
}
#[test]
fn md5_truncates_to_first_16kb() {
let mut data = vec![0xAAu8; 16 * 1024];
let prefix_only = format!("{:x}", md5::compute(&data));
// Append distinguishing bytes past 16 KB; the digest must not change.
data.extend_from_slice(b"---should be ignored by md5_first_16kb---");
assert_eq!(md5_first_16kb(&data), prefix_only);
}
// ── derive_waveform_bins ──────────────────────────────────────────────────
#[test]
fn derive_waveform_returns_empty_for_zero_bin_count() {
assert_eq!(derive_waveform_bins(&[1u8, 2, 3, 4], 0), Vec::<u8>::new());
}
#[test]
fn derive_waveform_returns_empty_for_empty_bytes() {
assert_eq!(derive_waveform_bins(&[], 4), Vec::<u8>::new());
}
#[test]
fn derive_waveform_silence_at_midpoint_yields_zero_bins() {
// 128 is the unsigned-PCM midpoint: abs_diff(128) == 0 for every sample.
let silence = vec![128u8; 64];
let out = derive_waveform_bins(&silence, 8);
assert!(out.iter().all(|&b| b == 0), "silence must produce all-zero bins, got {out:?}");
}
#[test]
fn derive_waveform_doubles_the_bin_buffer() {
// The function returns peak_half twice (peak followed by mean-abs placeholder).
let bytes = vec![0u8; 32];
let out = derive_waveform_bins(&bytes, 4);
assert_eq!(out.len(), 8, "output must be 2 * bin_count");
assert_eq!(&out[..4], &out[4..]);
}
#[test]
fn derive_waveform_reaches_max_for_extreme_amplitude() {
// Extreme deviation from 128 → centered = 127 (when input is 0 or 255).
// (127/127)^0.5 = 1.0 → 255 in u8.
let bytes = vec![0u8; 16];
let out = derive_waveform_bins(&bytes, 4);
assert!(out.iter().all(|&b| b == 255), "max amplitude must yield 255 bins");
}
// ── normalize_peak_bins ───────────────────────────────────────────────────
#[test]
fn normalize_peak_returns_empty_for_empty_input() {
assert_eq!(normalize_peak_bins(&[]), Vec::<u8>::new());
}
#[test]
fn normalize_peak_uniform_input_collapses_to_base_offset() {
// p5 == p99 → range collapses to 1e-8 floor; t = (x - p5)/range = 0 for all.
// shaped = 0; out = 8 (base offset).
let bins = vec![0.5f32; 16];
let out = normalize_peak_bins(&bins);
assert_eq!(out.len(), 16);
assert!(out.iter().all(|&b| b == 8), "got {out:?}");
}
#[test]
fn normalize_peak_monotonic_input_yields_increasing_output() {
// Strictly increasing input must produce non-decreasing output.
let bins: Vec<f32> = (0..100).map(|i| i as f32 / 100.0).collect();
let out = normalize_peak_bins(&bins);
for win in out.windows(2) {
assert!(win[0] <= win[1], "non-monotonic output around {:?}", win);
}
// Output range ⊆ [8, 255].
assert!(out.iter().all(|&b| (8..=255).contains(&b)));
}
// ── End-to-end: WAV decode → waveform + loudness pipeline ────────────────
//
// Symphonia's PCM/WAV decoder is the cheapest format we can feed end-to-end
// without committing a binary fixture. Every test here generates a tiny
// mono 16-bit-PCM WAV (~150 KB for 1.5 s @ 44.1 kHz) at runtime, hands the
// bytes to the real seed pipeline, and asserts on the cached rows.
/// Build a mono signed-16-bit-PCM WAV from a sample buffer at `sample_rate`.
/// Produces a buffer ready to be probed by Symphonia's WAV format reader.
fn build_mono_pcm16_wav(samples: &[i16], sample_rate: u32) -> Vec<u8> {
let num_channels: u16 = 1;
let bits_per_sample: u16 = 16;
let byte_rate = sample_rate * (bits_per_sample as u32 / 8) * num_channels as u32;
let block_align = num_channels * (bits_per_sample / 8);
let data_size = (samples.len() * 2) as u32;
let riff_size = 36 + data_size;
let mut out = Vec::with_capacity(44 + data_size as usize);
out.extend_from_slice(b"RIFF");
out.extend_from_slice(&riff_size.to_le_bytes());
out.extend_from_slice(b"WAVE");
// fmt chunk
out.extend_from_slice(b"fmt ");
out.extend_from_slice(&16u32.to_le_bytes()); // sub-chunk size
out.extend_from_slice(&1u16.to_le_bytes()); // PCM format tag
out.extend_from_slice(&num_channels.to_le_bytes());
out.extend_from_slice(&sample_rate.to_le_bytes());
out.extend_from_slice(&byte_rate.to_le_bytes());
out.extend_from_slice(&block_align.to_le_bytes());
out.extend_from_slice(&bits_per_sample.to_le_bytes());
// data chunk
out.extend_from_slice(b"data");
out.extend_from_slice(&data_size.to_le_bytes());
for s in samples {
out.extend_from_slice(&s.to_le_bytes());
}
out
}
/// Generate a 1-second 440 Hz sine wave at -6 dBFS as a Vec<i16>.
fn sine_440_at_minus_6db(sample_rate: u32, secs: f32) -> Vec<i16> {
let n = (sample_rate as f32 * secs) as usize;
let amplitude: f32 = 0.5 * i16::MAX as f32; // -6 dBFS
(0..n)
.map(|i| {
let t = i as f32 / sample_rate as f32;
let v = (2.0 * std::f32::consts::PI * 440.0 * t).sin() * amplitude;
v as i16
})
.collect()
}
#[test]
fn count_mono_frames_returns_decoded_length_for_synthetic_wav() {
let wav = build_mono_pcm16_wav(&sine_440_at_minus_6db(44_100, 1.0), 44_100);
let (frames, _hint) = count_mono_frames_from_audio_bytes(&wav)
.expect("WAV decode must succeed");
// 1 second × 44.1 kHz mono = 44 100 frames; allow ±1 packet tolerance.
assert!(
(43_900..=44_300).contains(&frames),
"expected ~44100 frames, got {frames}"
);
}
#[test]
fn count_mono_frames_returns_none_for_garbage_bytes() {
assert!(count_mono_frames_from_audio_bytes(b"not an audio file").is_none());
}
#[test]
fn count_mono_frames_returns_none_for_empty_bytes() {
assert!(count_mono_frames_from_audio_bytes(&[]).is_none());
}
#[test]
fn analyze_loudness_and_waveform_returns_loudness_for_synthetic_sine() {
let wav = build_mono_pcm16_wav(&sine_440_at_minus_6db(44_100, 1.5), 44_100);
let result = analyze_loudness_and_waveform(&wav, -14.0, 100)
.expect("WAV decode must succeed");
let (integrated_lufs, true_peak, recommended_gain_db, target_lufs, bins) = result;
assert_eq!(bins.len(), 200, "bins layout is peak_u8 + mean_u8 = 2 * bin_count");
assert_eq!(target_lufs, -14.0);
// -6 dBFS sine ≈ -9 LUFS integrated for 1.5 s. EBU R128 needs >=400 ms
// of audio; we have 1.5 s so the measurement is valid.
assert!(
(-30.0..0.0).contains(&integrated_lufs),
"integrated LUFS must be in a sane range, got {integrated_lufs}"
);
// True peak for -6 dBFS sine ≈ 0.5 linear amplitude.
assert!(
(0.4..=0.6).contains(&true_peak),
"true peak must reflect -6 dBFS amplitude, got {true_peak}"
);
// Recommended gain pushes the track toward the target LUFS,
// capped per `recommended_gain_for_target`.
assert!(recommended_gain_db.is_finite());
assert!((-24.0..=24.0).contains(&recommended_gain_db));
}
#[test]
fn analyze_loudness_returns_none_for_zero_bin_count() {
let wav = build_mono_pcm16_wav(&sine_440_at_minus_6db(44_100, 0.5), 44_100);
assert!(analyze_loudness_and_waveform(&wav, -14.0, 0).is_none());
}
#[test]
fn analyze_loudness_returns_none_for_empty_bytes() {
assert!(analyze_loudness_and_waveform(&[], -14.0, 100).is_none());
}
#[test]
fn seed_from_bytes_into_cache_upserts_waveform_and_loudness_for_wav() {
let cache = AnalysisCache::open_in_memory();
let wav = build_mono_pcm16_wav(&sine_440_at_minus_6db(44_100, 1.5), 44_100);
let outcome = seed_from_bytes_into_cache(&cache, "wav-track", &wav).unwrap();
assert_eq!(outcome, SeedFromBytesOutcome::Upserted);
// Both a waveform AND a loudness row must exist after a successful
// PCM decode + EBU R128 analysis.
let key = TrackKey {
track_id: "wav-track".to_string(),
md5_16kb: md5_first_16kb(&wav),
};
let waveform = cache.get_waveform(&key).unwrap().expect("waveform cached");
assert_eq!(waveform.bin_count, 500);
assert_eq!(waveform.bins.len(), 1000, "bins are 2 * bin_count");
assert!(cache.loudness_row_exists_for_key(&key).unwrap());
}
#[test]
fn seed_from_bytes_into_cache_returns_skipped_on_second_call() {
let cache = AnalysisCache::open_in_memory();
let wav = build_mono_pcm16_wav(&sine_440_at_minus_6db(44_100, 1.0), 44_100);
let first = seed_from_bytes_into_cache(&cache, "wav-track-2", &wav).unwrap();
assert_eq!(first, SeedFromBytesOutcome::Upserted);
let second = seed_from_bytes_into_cache(&cache, "wav-track-2", &wav).unwrap();
assert_eq!(
second,
SeedFromBytesOutcome::SkippedWaveformCacheHit,
"second seed sees cache + loudness rows and short-circuits"
);
}
#[test]
fn seed_from_bytes_into_cache_falls_back_to_byte_envelope_for_undecodable_input() {
let cache = AnalysisCache::open_in_memory();
// Garbage bytes — Symphonia probe fails, the pipeline falls back to
// `derive_waveform_bins` (no loudness row gets cached).
let bytes = vec![0xAAu8; 8 * 1024];
let outcome = seed_from_bytes_into_cache(&cache, "garbage", &bytes).unwrap();
assert_eq!(outcome, SeedFromBytesOutcome::Upserted);
let key = TrackKey {
track_id: "garbage".to_string(),
md5_16kb: md5_first_16kb(&bytes),
};
let waveform = cache.get_waveform(&key).unwrap().expect("byte-envelope waveform cached");
assert_eq!(waveform.bin_count, 500);
assert!(
!cache.loudness_row_exists_for_key(&key).unwrap(),
"byte-envelope fallback must not cache loudness"
);
}
}
src-tauri/crates/psysonic-analysis/src/analysis_cache/mod.rs
+5 -2
View File
@@ -1,5 +1,8 @@
mod compute;
mod store;
pub use compute::{recommended_gain_for_target, seed_from_bytes_execute, SeedFromBytesOutcome};
pub use store::{AnalysisCache, TrackKey};
pub use compute::{
recommended_gain_for_target, seed_from_bytes_execute, seed_from_bytes_into_cache,
SeedFromBytesOutcome,
};
pub use store::{AnalysisCache, LoudnessEntry, TrackKey, WaveformEntry};
src-tauri/crates/psysonic-analysis/src/analysis_cache/store.rs
+324
View File
@@ -90,6 +90,22 @@ impl AnalysisCache {
Ok(Self { conn: Mutex::new(conn) })
}
/// Builds an in-memory SQLite database with the production schema applied.
/// Intended for tests in this crate and any downstream crate that needs an
/// `AnalysisCache` without an `AppHandle`. WAL pragma is skipped — `:memory:`
/// databases don't support journal-mode changes; the test surface doesn't
/// need durability.
///
/// Lives outside `#[cfg(test)]` so cross-crate test harnesses can call it
/// without a `test-support` Cargo feature dance. Production code does not
/// use it.
pub fn open_in_memory() -> Self {
let conn = Connection::open_in_memory().expect("in-memory connection");
conn.pragma_update(None, "foreign_keys", "ON").expect("pragma foreign_keys");
migrate_schema(&conn).expect("schema migration");
Self { conn: Mutex::new(conn) }
}
/// Remove all `loudness_cache` rows for this logical track (bare id and `stream:` variant).
pub fn delete_loudness_for_track_id(&self, track_id: &str) -> Result<u64, String> {
if track_id.trim().is_empty() {
@@ -425,3 +441,311 @@ fn migrate_schema(conn: &Connection) -> rusqlite::Result<()> {
)?;
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
fn key(track_id: &str) -> TrackKey {
TrackKey {
track_id: track_id.to_string(),
md5_16kb: "deadbeef".to_string(),
}
}
fn waveform(bin_count: i64, is_partial: bool) -> WaveformEntry {
WaveformEntry {
bins: vec![0u8; (bin_count as usize) * 2],
bin_count,
is_partial,
known_until_sec: 12.5,
duration_sec: 60.0,
updated_at: 1_700_000_000,
}
}
fn loudness(target_lufs: f64) -> LoudnessEntry {
LoudnessEntry {
integrated_lufs: -14.2,
true_peak: -1.0,
recommended_gain_db: -0.8,
target_lufs,
updated_at: 1_700_000_000,
}
}
// ── track_id_cache_variants (private helper) ──────────────────────────────
#[test]
fn variants_for_bare_id_includes_stream_prefix() {
let v = track_id_cache_variants("abc");
assert_eq!(v, vec!["abc".to_string(), "stream:abc".to_string()]);
}
#[test]
fn variants_for_stream_prefixed_id_includes_bare() {
let v = track_id_cache_variants("stream:abc");
assert_eq!(v, vec!["stream:abc".to_string(), "abc".to_string()]);
}
#[test]
fn variants_for_empty_bare_after_stream_drops_extra_entry() {
let v = track_id_cache_variants("stream:");
assert_eq!(v, vec!["stream:".to_string()]);
}
// ── waveform_cache_blob_len_ok (private helper) ───────────────────────────
#[test]
fn blob_len_ok_rejects_non_positive_bin_count() {
assert!(!waveform_cache_blob_len_ok(&[], 0));
assert!(!waveform_cache_blob_len_ok(&[], -1));
}
#[test]
fn blob_len_ok_requires_exactly_two_bytes_per_bin() {
assert!(waveform_cache_blob_len_ok(&[0u8; 8], 4));
assert!(!waveform_cache_blob_len_ok(&[0u8; 7], 4));
assert!(!waveform_cache_blob_len_ok(&[0u8; 9], 4));
}
// ── schema initialisation ─────────────────────────────────────────────────
#[test]
fn open_in_memory_creates_all_tables() {
let cache = AnalysisCache::open_in_memory();
let conn = cache.conn.lock().unwrap();
let tables: Vec<String> = conn
.prepare("SELECT name FROM sqlite_master WHERE type='table' ORDER BY name")
.unwrap()
.query_map([], |r| r.get::<_, String>(0))
.unwrap()
.map(|r| r.unwrap())
.collect();
assert_eq!(tables, vec!["analysis_track", "loudness_cache", "waveform_cache"]);
}
// ── waveform roundtrip ────────────────────────────────────────────────────
#[test]
fn get_waveform_returns_none_without_analysis_track_row() {
let cache = AnalysisCache::open_in_memory();
let k = key("abc");
cache.upsert_waveform(&k, &waveform(4, false)).unwrap();
// The JOIN against `analysis_track` requires a matching row; without
// `touch_track_status` first, the lookup must miss.
assert!(cache.get_waveform(&k).unwrap().is_none());
}
#[test]
fn waveform_roundtrip_preserves_all_fields() {
let cache = AnalysisCache::open_in_memory();
let k = key("abc");
cache.touch_track_status(&k, "ok").unwrap();
let entry = WaveformEntry {
bins: (0u8..16).collect(),
bin_count: 8,
is_partial: true,
known_until_sec: 4.5,
duration_sec: 33.0,
updated_at: 1_700_000_001,
};
cache.upsert_waveform(&k, &entry).unwrap();
let got = cache.get_waveform(&k).unwrap().expect("waveform present");
assert_eq!(got.bins, entry.bins);
assert_eq!(got.bin_count, 8);
assert!(got.is_partial);
assert_eq!(got.known_until_sec, 4.5);
assert_eq!(got.duration_sec, 33.0);
assert_eq!(got.updated_at, 1_700_000_001);
}
#[test]
fn waveform_upsert_overwrites_existing_row() {
let cache = AnalysisCache::open_in_memory();
let k = key("abc");
cache.touch_track_status(&k, "ok").unwrap();
cache.upsert_waveform(&k, &waveform(4, true)).unwrap();
let updated = WaveformEntry {
bins: vec![0xAAu8; 8],
bin_count: 4,
is_partial: false,
known_until_sec: 60.0,
duration_sec: 60.0,
updated_at: 1_700_000_999,
};
cache.upsert_waveform(&k, &updated).unwrap();
let got = cache.get_waveform(&k).unwrap().expect("waveform present");
assert!(!got.is_partial, "second upsert should overwrite is_partial");
assert_eq!(got.bins, vec![0xAAu8; 8]);
assert_eq!(got.updated_at, 1_700_000_999);
}
#[test]
fn waveform_with_inconsistent_blob_length_is_filtered_out() {
let cache = AnalysisCache::open_in_memory();
let k = key("abc");
cache.touch_track_status(&k, "ok").unwrap();
// Manually upsert an entry where bins.len() doesn't match 2 * bin_count.
let bad = WaveformEntry {
bins: vec![0u8; 5], // expected 2*4 = 8
bin_count: 4,
is_partial: false,
known_until_sec: 0.0,
duration_sec: 0.0,
updated_at: 1_700_000_000,
};
cache.upsert_waveform(&k, &bad).unwrap();
// Direct JOIN finds the row, but get_waveform filters by length.
assert!(cache.get_waveform(&k).unwrap().is_none());
}
// ── loudness roundtrip ────────────────────────────────────────────────────
#[test]
fn loudness_roundtrip_records_existence() {
let cache = AnalysisCache::open_in_memory();
let k = key("abc");
cache.touch_track_status(&k, "ok").unwrap();
assert!(!cache.loudness_row_exists_for_key(&k).unwrap());
cache.upsert_loudness(&k, &loudness(-14.0)).unwrap();
assert!(cache.loudness_row_exists_for_key(&k).unwrap());
}
#[test]
fn loudness_primary_key_includes_target_lufs() {
// Two rows with same (track_id, md5_16kb) but different target_lufs must coexist.
let cache = AnalysisCache::open_in_memory();
let k = key("abc");
cache.touch_track_status(&k, "ok").unwrap();
cache.upsert_loudness(&k, &loudness(-14.0)).unwrap();
cache.upsert_loudness(&k, &loudness(-10.0)).unwrap();
let conn = cache.conn.lock().unwrap();
let count: i64 = conn
.query_row(
"SELECT COUNT(*) FROM loudness_cache WHERE track_id = ?1",
params!["abc"],
|r| r.get(0),
)
.unwrap();
assert_eq!(count, 2);
}
// ── id-variant lookups ────────────────────────────────────────────────────
#[test]
fn get_latest_waveform_finds_row_under_other_variant() {
let cache = AnalysisCache::open_in_memory();
let k = key("stream:abc");
cache.touch_track_status(&k, "ok").unwrap();
cache.upsert_waveform(&k, &waveform(4, false)).unwrap();
// Insert under stream:abc, look up with bare abc.
let got = cache.get_latest_waveform_for_track("abc").unwrap();
assert!(got.is_some(), "bare-id lookup must find stream-prefixed row");
}
#[test]
fn get_latest_loudness_finds_row_under_other_variant() {
let cache = AnalysisCache::open_in_memory();
let k = key("abc");
cache.touch_track_status(&k, "ok").unwrap();
cache.upsert_loudness(&k, &loudness(-14.0)).unwrap();
let got = cache.get_latest_loudness_for_track("stream:abc").unwrap();
assert!(got.is_some(), "stream-prefixed lookup must find bare row");
}
// ── cpu_seed_redundant_for_track ──────────────────────────────────────────
#[test]
fn cpu_seed_redundant_requires_both_waveform_and_loudness() {
let cache = AnalysisCache::open_in_memory();
let k = key("abc");
cache.touch_track_status(&k, "ok").unwrap();
assert!(!cache.cpu_seed_redundant_for_track("abc").unwrap());
cache.upsert_waveform(&k, &waveform(4, false)).unwrap();
assert!(
!cache.cpu_seed_redundant_for_track("abc").unwrap(),
"waveform alone is not enough"
);
cache.upsert_loudness(&k, &loudness(-14.0)).unwrap();
assert!(cache.cpu_seed_redundant_for_track("abc").unwrap());
}
// ── deletes ───────────────────────────────────────────────────────────────
#[test]
fn delete_loudness_clears_both_id_variants() {
let cache = AnalysisCache::open_in_memory();
let bare = key("abc");
let prefixed = key("stream:abc");
cache.touch_track_status(&bare, "ok").unwrap();
cache.touch_track_status(&prefixed, "ok").unwrap();
cache.upsert_loudness(&bare, &loudness(-14.0)).unwrap();
cache.upsert_loudness(&prefixed, &loudness(-14.0)).unwrap();
let deleted = cache.delete_loudness_for_track_id("abc").unwrap();
assert_eq!(deleted, 2, "delete must remove both bare and stream:abc rows");
assert!(!cache.loudness_row_exists_for_key(&bare).unwrap());
assert!(!cache.loudness_row_exists_for_key(&prefixed).unwrap());
}
#[test]
fn delete_waveform_clears_both_id_variants() {
let cache = AnalysisCache::open_in_memory();
let bare = key("abc");
let prefixed = key("stream:abc");
cache.touch_track_status(&bare, "ok").unwrap();
cache.touch_track_status(&prefixed, "ok").unwrap();
cache.upsert_waveform(&bare, &waveform(4, false)).unwrap();
cache.upsert_waveform(&prefixed, &waveform(4, false)).unwrap();
let deleted = cache.delete_waveform_for_track_id("abc").unwrap();
assert_eq!(deleted, 2);
assert!(cache.get_waveform(&bare).unwrap().is_none());
assert!(cache.get_waveform(&prefixed).unwrap().is_none());
}
#[test]
fn delete_with_empty_or_whitespace_track_id_is_noop() {
let cache = AnalysisCache::open_in_memory();
assert_eq!(cache.delete_waveform_for_track_id("").unwrap(), 0);
assert_eq!(cache.delete_waveform_for_track_id(" ").unwrap(), 0);
assert_eq!(cache.delete_loudness_for_track_id("").unwrap(), 0);
assert_eq!(cache.delete_loudness_for_track_id(" ").unwrap(), 0);
}
#[test]
fn delete_all_waveforms_removes_every_row() {
let cache = AnalysisCache::open_in_memory();
for tid in ["a", "b", "c"] {
let k = key(tid);
cache.touch_track_status(&k, "ok").unwrap();
cache.upsert_waveform(&k, &waveform(4, false)).unwrap();
}
let deleted = cache.delete_all_waveforms().unwrap();
assert_eq!(deleted, 3);
for tid in ["a", "b", "c"] {
assert!(cache.get_waveform(&key(tid)).unwrap().is_none());
}
}
#[test]
fn touch_track_status_upserts_status_field() {
let cache = AnalysisCache::open_in_memory();
let k = key("abc");
cache.touch_track_status(&k, "queued").unwrap();
cache.touch_track_status(&k, "done").unwrap();
let conn = cache.conn.lock().unwrap();
let status: String = conn
.query_row(
"SELECT status FROM analysis_track WHERE track_id = ?1 AND md5_16kb = ?2",
params!["abc", "deadbeef"],
|r| r.get(0),
)
.unwrap();
assert_eq!(status, "done");
}
}
src-tauri/crates/psysonic-analysis/src/analysis_runtime.rs
+201 -14
View File
@@ -233,19 +233,21 @@ pub enum AnalysisCpuSeedEnqueueKind {
MergedQueued,
}
type SeedDoneSender =
tokio::sync::oneshot::Sender<Result<analysis_cache::SeedFromBytesOutcome, String>>;
type RunningSeedJob = (String, Arc<Mutex<Vec<SeedDoneSender>>>);
struct AnalysisCpuSeedJob {
track_id: String,
bytes: Vec<u8>,
waiters: Vec<tokio::sync::oneshot::Sender<Result<analysis_cache::SeedFromBytesOutcome, String>>>,
waiters: Vec<SeedDoneSender>,
}
#[derive(Default)]
struct AnalysisCpuSeedQueueState {
deque: VecDeque<AnalysisCpuSeedJob>,
/// Decode in progress — same-id callers wait here for the same outcome.
running: Option<(
String,
Arc<Mutex<Vec<tokio::sync::oneshot::Sender<Result<analysis_cache::SeedFromBytesOutcome, String>>>>>,
)>,
running: Option<RunningSeedJob>,
}
impl AnalysisCpuSeedQueueState {
@@ -327,15 +329,6 @@ struct AnalysisCpuSeedShared {
wake_tx: tokio::sync::mpsc::UnboundedSender<()>,
}
impl Default for AnalysisCpuSeedQueueState {
fn default() -> Self {
Self {
deque: VecDeque::new(),
running: None,
}
}
}
impl AnalysisCpuSeedShared {
fn ping_worker(&self) {
let _ = self.wake_tx.send(());
@@ -532,3 +525,197 @@ pub async fn submit_analysis_cpu_seed(
}
Ok(outcome)
}
#[cfg(test)]
mod tests {
use super::*;
// ── AnalysisBackfillQueueState ────────────────────────────────────────────
#[test]
fn backfill_default_state_has_empty_deque_and_no_in_progress() {
let s = AnalysisBackfillQueueState::default();
assert!(s.deque.is_empty());
assert!(s.in_progress.is_none());
}
#[test]
fn backfill_is_reserved_checks_both_deque_and_in_progress() {
let mut s = AnalysisBackfillQueueState::default();
s.deque.push_back(("queued".into(), "u".into()));
s.in_progress = Some("active".into());
assert!(s.is_reserved("queued"));
assert!(s.is_reserved("active"));
assert!(!s.is_reserved("other"));
}
#[test]
fn backfill_try_pop_next_promotes_head_to_in_progress() {
let mut s = AnalysisBackfillQueueState::default();
s.deque.push_back(("a".into(), "ua".into()));
s.deque.push_back(("b".into(), "ub".into()));
let popped = s.try_pop_next().unwrap();
assert_eq!(popped.0, "a");
assert_eq!(s.in_progress.as_deref(), Some("a"));
assert_eq!(s.deque.len(), 1);
}
#[test]
fn backfill_try_pop_next_returns_none_for_empty_deque() {
let mut s = AnalysisBackfillQueueState::default();
assert!(s.try_pop_next().is_none());
assert!(s.in_progress.is_none());
}
#[test]
fn backfill_finish_job_only_clears_when_id_matches() {
let mut s = AnalysisBackfillQueueState {
in_progress: Some("active".into()),
..Default::default()
};
s.finish_job("other");
assert_eq!(s.in_progress.as_deref(), Some("active"));
s.finish_job("active");
assert!(s.in_progress.is_none());
}
#[test]
fn backfill_enqueue_low_priority_appends_to_back() {
let mut s = AnalysisBackfillQueueState::default();
s.deque.push_back(("first".into(), "u".into()));
let kind = s.enqueue("second".into(), "u2".into(), false);
assert_eq!(kind, AnalysisBackfillEnqueueKind::NewBack);
assert_eq!(s.deque.back().unwrap().0, "second");
}
#[test]
fn backfill_enqueue_high_priority_pushes_to_front() {
let mut s = AnalysisBackfillQueueState::default();
s.deque.push_back(("old".into(), "u".into()));
let kind = s.enqueue("hot".into(), "u2".into(), true);
assert_eq!(kind, AnalysisBackfillEnqueueKind::NewFront);
assert_eq!(s.deque.front().unwrap().0, "hot");
}
#[test]
fn backfill_enqueue_returns_duplicate_skipped_for_low_prio_dup() {
let mut s = AnalysisBackfillQueueState::default();
s.deque.push_back(("dup".into(), "u".into()));
let kind = s.enqueue("dup".into(), "u2".into(), false);
assert_eq!(kind, AnalysisBackfillEnqueueKind::DuplicateSkipped);
assert_eq!(s.deque.len(), 1);
}
#[test]
fn backfill_enqueue_returns_running_skipped_for_high_prio_active_track() {
let mut s = AnalysisBackfillQueueState {
in_progress: Some("active".into()),
..Default::default()
};
let kind = s.enqueue("active".into(), "u".into(), true);
assert_eq!(kind, AnalysisBackfillEnqueueKind::RunningSkipped);
}
#[test]
fn backfill_enqueue_high_prio_dup_in_deque_reorders_to_front_with_new_url() {
let mut s = AnalysisBackfillQueueState::default();
s.deque.push_back(("a".into(), "u_a".into()));
s.deque.push_back(("dup".into(), "old_url".into()));
s.deque.push_back(("c".into(), "u_c".into()));
let kind = s.enqueue("dup".into(), "fresh_url".into(), true);
assert_eq!(kind, AnalysisBackfillEnqueueKind::ReorderedFront);
assert_eq!(s.deque.front().unwrap(), &("dup".to_string(), "fresh_url".to_string()));
assert_eq!(s.deque.iter().filter(|(t, _)| t == "dup").count(), 1, "no duplicate left behind");
}
#[test]
fn backfill_prune_queued_not_in_drops_unkept_entries() {
let mut s = AnalysisBackfillQueueState::default();
for tid in ["a", "b", "c", "d"] {
s.deque.push_back((tid.into(), "u".into()));
}
let keep: HashSet<&str> = ["a", "c"].iter().copied().collect();
let removed = s.prune_queued_not_in(&keep);
assert_eq!(removed, 2);
let remaining: Vec<&str> = s.deque.iter().map(|(t, _)| t.as_str()).collect();
assert_eq!(remaining, vec!["a", "c"]);
}
// ── AnalysisCpuSeedQueueState ─────────────────────────────────────────────
#[test]
fn cpu_seed_enqueue_low_prio_appends_to_back() {
let mut s = AnalysisCpuSeedQueueState::default();
let (kind, _rx) = s.enqueue("a".into(), vec![], false);
assert_eq!(kind, AnalysisCpuSeedEnqueueKind::NewBack);
assert_eq!(s.deque.len(), 1);
}
#[test]
fn cpu_seed_enqueue_high_prio_pushes_to_front() {
let mut s = AnalysisCpuSeedQueueState::default();
let (_, _r1) = s.enqueue("first".into(), vec![], false);
let (kind, _r2) = s.enqueue("hot".into(), vec![], true);
assert_eq!(kind, AnalysisCpuSeedEnqueueKind::NewFront);
assert_eq!(s.deque.front().unwrap().track_id, "hot");
}
#[test]
fn cpu_seed_enqueue_existing_low_prio_merges_at_back() {
let mut s = AnalysisCpuSeedQueueState::default();
let (_, _r1) = s.enqueue("dup".into(), vec![1, 2, 3], false);
let (kind, _r2) = s.enqueue("dup".into(), vec![4, 5, 6], false);
assert_eq!(kind, AnalysisCpuSeedEnqueueKind::MergedQueued);
assert_eq!(s.deque.len(), 1);
assert_eq!(s.deque[0].bytes, vec![4, 5, 6], "fresh bytes overwrite");
assert_eq!(s.deque[0].waiters.len(), 2, "both waiters attached");
}
#[test]
fn cpu_seed_enqueue_existing_high_prio_reorders_to_front() {
let mut s = AnalysisCpuSeedQueueState::default();
let (_, _r1) = s.enqueue("first".into(), vec![], false);
let (_, _r2) = s.enqueue("dup".into(), vec![], false);
let (kind, _r3) = s.enqueue("dup".into(), vec![], true);
assert_eq!(kind, AnalysisCpuSeedEnqueueKind::ReorderedFront);
assert_eq!(s.deque.front().unwrap().track_id, "dup");
}
#[test]
fn cpu_seed_enqueue_running_id_attaches_as_follower() {
let mut s = AnalysisCpuSeedQueueState::default();
let followers = Arc::new(Mutex::new(Vec::new()));
s.running = Some(("active".into(), followers.clone()));
let (kind, _rx) = s.enqueue("active".into(), vec![], false);
assert_eq!(kind, AnalysisCpuSeedEnqueueKind::RunningFollower);
assert_eq!(followers.lock().unwrap().len(), 1, "follower channel attached");
assert_eq!(s.deque.len(), 0, "follower does not occupy a queue slot");
}
#[test]
fn cpu_seed_prune_returns_removed_jobs_and_waiter_count() {
let mut s = AnalysisCpuSeedQueueState::default();
let (_, _r1) = s.enqueue("a".into(), vec![], false);
let (_, _r2) = s.enqueue("b".into(), vec![], false);
let (_, _r3) = s.enqueue("a".into(), vec![], false); // merged: 2 waiters on a
let (_, _r4) = s.enqueue("c".into(), vec![], false);
let keep: HashSet<&str> = ["a"].iter().copied().collect();
let (removed_jobs, removed_waiters) = s.prune_queued_not_in(&keep);
assert_eq!(removed_jobs, 2, "b and c removed");
assert_eq!(removed_waiters, 2, "one waiter on b + one on c");
let remaining: Vec<&str> = s.deque.iter().map(|j| j.track_id.as_str()).collect();
assert_eq!(remaining, vec!["a"]);
}
#[test]
fn cpu_seed_prune_sends_err_to_dropped_waiters() {
let mut s = AnalysisCpuSeedQueueState::default();
let (_, rx) = s.enqueue("doomed".into(), vec![], false);
let keep: HashSet<&str> = HashSet::new();
let _ = s.prune_queued_not_in(&keep);
// After pruning, the waiter receives the cancellation Err.
let result = rx.blocking_recv().expect("sender side should have closed cleanly");
assert!(result.is_err(), "pruned job must yield Err, got {result:?}");
}
}
src-tauri/crates/psysonic-analysis/src/commands.rs
+267 -71
View File
@@ -26,6 +26,19 @@ pub struct WaveformCachePayload {
pub updated_at: i64,
}
impl From<analysis_cache::WaveformEntry> for WaveformCachePayload {
fn from(v: analysis_cache::WaveformEntry) -> Self {
Self {
bins: v.bins,
bin_count: v.bin_count,
is_partial: v.is_partial,
known_until_sec: v.known_until_sec,
duration_sec: v.duration_sec,
updated_at: v.updated_at,
}
}
}
#[derive(serde::Serialize)]
#[serde(rename_all = "camelCase")]
pub struct LoudnessCachePayload {
@@ -36,87 +49,43 @@ pub struct LoudnessCachePayload {
pub updated_at: i64,
}
#[tauri::command]
pub fn analysis_get_waveform(
track_id: String,
md5_16kb: String,
cache: tauri::State<'_, analysis_cache::AnalysisCache>,
/// AppHandle-free helper: looks up a waveform by exact `(track_id, md5_16kb)`
/// key and converts the `WaveformEntry` into the JSON-serialisable
/// `WaveformCachePayload`. Pulled out of [`analysis_get_waveform`] so it can
/// be tested with `AnalysisCache::open_in_memory()` and direct upserts.
pub fn get_waveform_payload(
cache: &analysis_cache::AnalysisCache,
track_id: &str,
md5_16kb: &str,
) -> Result<Option<WaveformCachePayload>, String> {
let key = analysis_cache::TrackKey {
track_id: track_id.clone(),
md5_16kb: md5_16kb.clone(),
track_id: track_id.to_string(),
md5_16kb: md5_16kb.to_string(),
};
let row = cache.get_waveform(&key)?;
match &row {
Some(v) => {
crate::app_deprintln!(
"[analysis][waveform] db hit (exact key) track_id={} md5_16kb={} bins_len={} bin_count={} updated_at={}",
track_id,
md5_16kb,
v.bins.len(),
v.bin_count,
v.updated_at
);
}
None => {
crate::app_deprintln!(
"[analysis][waveform] db miss (exact key) track_id={} md5_16kb={}",
track_id,
md5_16kb
);
}
}
Ok(row.map(|v| WaveformCachePayload {
bins: v.bins,
bin_count: v.bin_count,
is_partial: v.is_partial,
known_until_sec: v.known_until_sec,
duration_sec: v.duration_sec,
updated_at: v.updated_at,
}))
Ok(cache.get_waveform(&key)?.map(WaveformCachePayload::from))
}
#[tauri::command]
pub fn analysis_get_waveform_for_track(
track_id: String,
cache: tauri::State<'_, analysis_cache::AnalysisCache>,
/// AppHandle-free helper: looks up the latest waveform for `track_id`
/// across all id variants (bare ↔ `stream:` prefix). See [`get_waveform_payload`].
pub fn get_waveform_payload_for_track(
cache: &analysis_cache::AnalysisCache,
track_id: &str,
) -> Result<Option<WaveformCachePayload>, String> {
let row = cache.get_latest_waveform_for_track(&track_id)?;
match &row {
Some(v) => {
crate::app_deprintln!(
"[analysis][waveform] db hit track_id={} bins_len={} bin_count={} updated_at={}",
track_id,
v.bins.len(),
v.bin_count,
v.updated_at
);
}
None => {
crate::app_deprintln!(
"[analysis][waveform] db miss track_id={}",
track_id
);
}
}
Ok(row.map(|v| WaveformCachePayload {
bins: v.bins,
bin_count: v.bin_count,
is_partial: v.is_partial,
known_until_sec: v.known_until_sec,
duration_sec: v.duration_sec,
updated_at: v.updated_at,
}))
Ok(cache
.get_latest_waveform_for_track(track_id)?
.map(WaveformCachePayload::from))
}
#[tauri::command]
pub fn analysis_get_loudness_for_track(
track_id: String,
/// AppHandle-free helper: looks up the latest loudness row for `track_id`
/// and recomputes `recommended_gain_db` against the optional requested target
/// (clamped to [-30, -8]). When `target_lufs` is `None`, the cached row's own
/// target is used.
pub fn get_loudness_payload_for_track(
cache: &analysis_cache::AnalysisCache,
track_id: &str,
target_lufs: Option<f64>,
cache: tauri::State<'_, analysis_cache::AnalysisCache>,
) -> Result<Option<LoudnessCachePayload>, String> {
let row = cache.get_latest_loudness_for_track(&track_id)?;
Ok(row.map(|v| {
Ok(cache.get_latest_loudness_for_track(track_id)?.map(|v| {
let requested_target = target_lufs.unwrap_or(v.target_lufs).clamp(-30.0, -8.0);
let recommended_gain_db = analysis_cache::recommended_gain_for_target(
v.integrated_lufs,
@@ -133,6 +102,55 @@ pub fn analysis_get_loudness_for_track(
}))
}
#[tauri::command]
pub fn analysis_get_waveform(
track_id: String,
md5_16kb: String,
cache: tauri::State<'_, analysis_cache::AnalysisCache>,
) -> Result<Option<WaveformCachePayload>, String> {
let result = get_waveform_payload(cache.inner(), &track_id, &md5_16kb);
if let Ok(ref payload) = result {
match payload {
Some(v) => crate::app_deprintln!(
"[analysis][waveform] db hit (exact key) track_id={} md5_16kb={} bins_len={} bin_count={} updated_at={}",
track_id, md5_16kb, v.bins.len(), v.bin_count, v.updated_at
),
None => crate::app_deprintln!(
"[analysis][waveform] db miss (exact key) track_id={} md5_16kb={}",
track_id, md5_16kb
),
}
}
result
}
#[tauri::command]
pub fn analysis_get_waveform_for_track(
track_id: String,
cache: tauri::State<'_, analysis_cache::AnalysisCache>,
) -> Result<Option<WaveformCachePayload>, String> {
let result = get_waveform_payload_for_track(cache.inner(), &track_id);
if let Ok(ref payload) = result {
match payload {
Some(v) => crate::app_deprintln!(
"[analysis][waveform] db hit track_id={} bins_len={} bin_count={} updated_at={}",
track_id, v.bins.len(), v.bin_count, v.updated_at
),
None => crate::app_deprintln!("[analysis][waveform] db miss track_id={}", track_id),
}
}
result
}
#[tauri::command]
pub fn analysis_get_loudness_for_track(
track_id: String,
target_lufs: Option<f64>,
cache: tauri::State<'_, analysis_cache::AnalysisCache>,
) -> Result<Option<LoudnessCachePayload>, String> {
get_loudness_payload_for_track(cache.inner(), &track_id, target_lufs)
}
#[tauri::command]
pub fn analysis_delete_loudness_for_track(
track_id: String,
@@ -269,3 +287,181 @@ pub fn analysis_prune_pending_to_track_ids(
cpu_removed_waiters,
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::analysis_cache::{
AnalysisCache, LoudnessEntry, TrackKey, WaveformEntry,
};
fn key(track_id: &str, md5: &str) -> TrackKey {
TrackKey {
track_id: track_id.to_string(),
md5_16kb: md5.to_string(),
}
}
fn upsert_waveform(cache: &AnalysisCache, track_id: &str, md5: &str, bins: Vec<u8>) {
let k = key(track_id, md5);
cache.touch_track_status(&k, "ready").unwrap();
cache
.upsert_waveform(
&k,
&WaveformEntry {
bin_count: (bins.len() / 2) as i64,
bins,
is_partial: false,
known_until_sec: 0.0,
duration_sec: 60.0,
updated_at: 1_700_000_000,
},
)
.unwrap();
}
fn upsert_loudness(cache: &AnalysisCache, track_id: &str, md5: &str, target_lufs: f64) {
let k = key(track_id, md5);
cache.touch_track_status(&k, "ready").unwrap();
cache
.upsert_loudness(
&k,
&LoudnessEntry {
integrated_lufs: -14.0,
true_peak: 0.5,
recommended_gain_db: 0.0,
target_lufs,
updated_at: 1_700_000_000,
},
)
.unwrap();
}
// ── get_waveform_payload ──────────────────────────────────────────────────
#[test]
fn get_waveform_payload_returns_none_for_unknown_key() {
let cache = AnalysisCache::open_in_memory();
let payload = get_waveform_payload(&cache, "missing", "deadbeef").unwrap();
assert!(payload.is_none());
}
#[test]
fn get_waveform_payload_returns_payload_for_existing_row() {
let cache = AnalysisCache::open_in_memory();
let bins: Vec<u8> = (0..8u8).collect();
upsert_waveform(&cache, "abc", "deadbeef", bins.clone());
let payload = get_waveform_payload(&cache, "abc", "deadbeef")
.unwrap()
.expect("payload exists");
assert_eq!(payload.bins, bins);
assert_eq!(payload.bin_count, 4);
assert!(!payload.is_partial);
assert_eq!(payload.duration_sec, 60.0);
assert_eq!(payload.updated_at, 1_700_000_000);
}
#[test]
fn get_waveform_payload_distinguishes_md5_keys() {
// Same track_id, different md5_16kb → independent rows.
let cache = AnalysisCache::open_in_memory();
upsert_waveform(&cache, "abc", "aaaa", vec![0u8; 8]);
upsert_waveform(&cache, "abc", "bbbb", vec![0xFFu8; 8]);
let p1 = get_waveform_payload(&cache, "abc", "aaaa").unwrap().unwrap();
let p2 = get_waveform_payload(&cache, "abc", "bbbb").unwrap().unwrap();
assert_ne!(p1.bins, p2.bins);
}
// ── get_waveform_payload_for_track ────────────────────────────────────────
#[test]
fn get_waveform_for_track_finds_row_under_stream_prefix() {
// Insert under `stream:abc`, look up with bare `abc` — id-variant
// matching is the whole point of get_latest_waveform_for_track.
let cache = AnalysisCache::open_in_memory();
upsert_waveform(&cache, "stream:abc", "deadbeef", vec![1u8; 8]);
let payload = get_waveform_payload_for_track(&cache, "abc")
.unwrap()
.expect("bare-id lookup must hit the stream-prefixed row");
assert_eq!(payload.bin_count, 4);
}
#[test]
fn get_waveform_for_track_returns_none_for_unknown_track() {
let cache = AnalysisCache::open_in_memory();
assert!(get_waveform_payload_for_track(&cache, "phantom").unwrap().is_none());
}
// ── get_loudness_payload_for_track ────────────────────────────────────────
#[test]
fn get_loudness_for_track_recomputes_gain_against_requested_target() {
let cache = AnalysisCache::open_in_memory();
upsert_loudness(&cache, "abc", "deadbeef", -14.0);
// Cached row: integrated -14, target -14 → gain 0. Request target -10 →
// recommended gain = -10 - (-14) = +4 dB (capped by true-peak guard).
let payload = get_loudness_payload_for_track(&cache, "abc", Some(-10.0))
.unwrap()
.expect("loudness row exists");
assert_eq!(payload.target_lufs, -10.0);
assert!(
payload.recommended_gain_db.is_finite() && payload.recommended_gain_db <= 4.0,
"recommended_gain_db must reflect the new target, got {}",
payload.recommended_gain_db
);
}
#[test]
fn get_loudness_for_track_uses_cached_target_when_request_is_none() {
let cache = AnalysisCache::open_in_memory();
upsert_loudness(&cache, "abc", "deadbeef", -16.0);
let payload = get_loudness_payload_for_track(&cache, "abc", None)
.unwrap()
.unwrap();
assert_eq!(payload.target_lufs, -16.0);
}
#[test]
fn get_loudness_for_track_clamps_target_into_supported_range() {
let cache = AnalysisCache::open_in_memory();
upsert_loudness(&cache, "abc", "deadbeef", -14.0);
// Out-of-range target gets clamped to [-30, -8].
let too_high = get_loudness_payload_for_track(&cache, "abc", Some(0.0))
.unwrap()
.unwrap();
assert_eq!(too_high.target_lufs, -8.0);
let too_low = get_loudness_payload_for_track(&cache, "abc", Some(-100.0))
.unwrap()
.unwrap();
assert_eq!(too_low.target_lufs, -30.0);
}
#[test]
fn get_loudness_for_track_returns_none_for_unknown_track() {
let cache = AnalysisCache::open_in_memory();
assert!(get_loudness_payload_for_track(&cache, "phantom", None)
.unwrap()
.is_none());
}
// ── WaveformCachePayload::from(WaveformEntry) ─────────────────────────────
#[test]
fn waveform_payload_from_entry_preserves_all_fields() {
let entry = WaveformEntry {
bins: vec![1, 2, 3, 4],
bin_count: 2,
is_partial: true,
known_until_sec: 5.5,
duration_sec: 10.0,
updated_at: 42,
};
let payload = WaveformCachePayload::from(entry);
assert_eq!(payload.bins, vec![1, 2, 3, 4]);
assert_eq!(payload.bin_count, 2);
assert!(payload.is_partial);
assert_eq!(payload.known_until_sec, 5.5);
assert_eq!(payload.duration_sec, 10.0);
assert_eq!(payload.updated_at, 42);
}
}