soulsync/tests/test_acoustid_skip_logic.py

"""Tighten the AcoustID "language/script" skip exemption.

User report (Mr. Morale download): three different track requests
(Rich Interlude, Savior Interlude, Savior) each received the same
WRONG audio file (Kendrick's R.O.T.C Interlude from his 2010 mixtape).
AcoustID flagged the title mismatch but the verification logic
SKIPPED rather than FAILED with the reason "likely same song in
different language/script."

The old condition was:
    best_score >= 0.95 AND (title_sim >= 0.55 OR artist_sim >= match)

That OR-clause fired for English-vs-English titles by the same artist
that share NO actual content — same artist + word "interlude" in both
titles cleared the bar. The skip then trusted the wrong file as
correct.

New condition: only skip when there's positive evidence the mismatch
is a transliteration / language-script case:
- (a) Either side of the comparison contains non-ASCII characters AND
      artist matches strongly. Real cases: Japanese kanji ↔ romaji,
      Korean hangul ↔ romaji, etc.
- (b) BOTH title AND artist similarity are very high (>=0.80, ARTIST
      threshold). Real cases: title differs only by punctuation /
      casing that fell below strict-match thresholds.

For English-vs-English with very different titles by the same artist,
the skip no longer fires — verification correctly returns FAIL,
quarantining the wrong file.
"""

from __future__ import annotations

from unittest.mock import patch

import pytest

from core.acoustid_verification import (
    AcoustIDVerification,
    VerificationResult,
)


@pytest.fixture
def verifier(monkeypatch):
    """A verifier with the network/fingerprint side stubbed so we can
    drive the title/artist comparison logic directly."""
    v = AcoustIDVerification()

    # Stub availability check to avoid touching real chromaprint
    class _StubClient:
        def is_available(self):
            return True, 'available'

        def lookup_with_status(self, path):
            # Each test injects its own desired return value via
            # monkeypatch on this method; default is empty.
            return None

    v.acoustid_client = _StubClient()
    return v


def _stub_lookup(verifier, *, recordings, best_score):
    """Make `lookup_with_status` return a fabricated AcoustID result."""
    verifier.acoustid_client.lookup_with_status = lambda path: {
        'recordings': recordings,
        'best_score': best_score,
        'recording_mbids': [r.get('id') for r in recordings if r.get('id')],
    }


# ---------------------------------------------------------------------------
# The headline regression — Rich Interlude vs R.O.T.C Interlude
# ---------------------------------------------------------------------------


def test_english_titles_same_artist_no_longer_skipped(verifier):
    """User's actual case: requested 'Rich (Interlude)' by Kendrick
    Lamar, AcoustID identified the file as 'R.O.T.C. (interlude)' by
    Kendrick Lamar. Same artist, same word 'interlude', but completely
    different songs. Old skip-logic let it pass; new logic must FAIL
    so the file gets quarantined."""
    _stub_lookup(verifier, recordings=[
        {'title': 'R.O.T.C. (interlude)', 'artist': 'Kendrick Lamar feat. BJ the Chicago Kid'},
    ], best_score=0.96)

    result, msg = verifier.verify_audio_file(
        '/fake/path.flac',
        'Rich (Interlude)',
        'Kendrick Lamar',
    )
    assert result == VerificationResult.FAIL
    # Message should be the wrong-file message, NOT the language/script skip
    assert 'mismatch' in msg.lower()
    assert 'language/script' not in msg.lower()


def test_savior_request_returning_rotc_no_longer_skipped(verifier):
    """Same bug surface, different track. Confirms the fix isn't
    Rich-Interlude-specific."""
    _stub_lookup(verifier, recordings=[
        {'title': 'R.O.T.C. (interlude)', 'artist': 'Kendrick Lamar feat. BJ the Chicago Kid'},
    ], best_score=0.96)

    result, _msg = verifier.verify_audio_file(
        '/fake/path.flac',
        'Savior',
        'Kendrick Lamar',
    )
    assert result == VerificationResult.FAIL


# ---------------------------------------------------------------------------
# The legitimate skip cases — must STILL fire
# ---------------------------------------------------------------------------


def test_japanese_kanji_to_romaji_still_skipped(verifier):
    """Real language/script case: AcoustID's database has the kanji
    title, the user requested the romaji version. Same artist (in
    Latin script), high fingerprint confidence. Skip should still
    fire so a correct file isn't false-quarantined."""
    _stub_lookup(verifier, recordings=[
        {'title': '残酷な天使のテーゼ', 'artist': 'Yoko Takahashi'},
    ], best_score=0.97)

    result, msg = verifier.verify_audio_file(
        '/fake/path.flac',
        'Zankoku na Tenshi no Theze',
        'Yoko Takahashi',
    )
    assert result == VerificationResult.SKIP
    assert 'language/script' in msg.lower()


def test_minor_punctuation_difference_passes_outright(verifier):
    """Punctuation-only difference: both 'MAAD' and 'M.A.A.D' normalize
    similarly enough that the strict TITLE_MATCH_THRESHOLD is met and
    verification PASSES (better outcome than SKIP). Pin this so a
    future tightening of the strict thresholds doesn't accidentally
    push these into the FAIL bucket."""
    _stub_lookup(verifier, recordings=[
        {'title': 'M.A.A.D City', 'artist': 'Kendrick Lamar'},
    ], best_score=0.97)

    result, _msg = verifier.verify_audio_file(
        '/fake/path.flac',
        'MAAD City',
        'Kendrick Lamar',
    )
    # PASS or SKIP both fine — the critical assertion is "not FAIL".
    assert result != VerificationResult.FAIL


def test_low_fingerprint_score_never_skipped(verifier):
    """Below the 0.95 confidence floor, the skip exemption should
    never fire — even for plausibly-real language/script cases. We
    don't have enough signal to be sure the audio matches."""
    _stub_lookup(verifier, recordings=[
        {'title': '残酷な天使のテーゼ', 'artist': 'Yoko Takahashi'},
    ], best_score=0.80)  # below 0.95 floor

    result, _msg = verifier.verify_audio_file(
        '/fake/path.flac',
        'Zankoku na Tenshi no Theze',
        'Yoko Takahashi',
    )
    assert result == VerificationResult.FAIL


def test_high_score_but_artist_mismatch_no_longer_skipped(verifier):
    """Even with high fingerprint AND non-ASCII chars present, if the
    artist DOESN'T match well, we don't have enough signal to skip.
    Could be a cover by a different artist."""
    _stub_lookup(verifier, recordings=[
        {'title': '残酷な天使のテーゼ', 'artist': 'Some Other Singer'},
    ], best_score=0.97)

    result, _msg = verifier.verify_audio_file(
        '/fake/path.flac',
        'Zankoku na Tenshi no Theze',
        'Yoko Takahashi',
    )
    assert result == VerificationResult.FAIL


def test_low_fingerprint_score_never_skipped_same_script_artist(verifier):
    """#797 guard — the #607 protection for a SAME-SCRIPT artist (Latin
    'Yoko Takahashi' on both sides) with only a cross-script TITLE must
    stay FAIL below the 0.95 floor. The #797 relaxation is keyed on the
    ARTIST spanning scripts, which this case is NOT, so nothing changes
    here. (Duplicates test_low_fingerprint_score_never_skipped's intent
    explicitly against the new code path.)"""
    _stub_lookup(verifier, recordings=[
        {'title': '残酷な天使のテーゼ', 'artist': 'Yoko Takahashi'},
    ], best_score=0.85)

    result, _msg = verifier.verify_audio_file(
        '/fake/path.flac',
        'Zankoku na Tenshi no Theze',
        'Yoko Takahashi',
    )
    assert result == VerificationResult.FAIL


# ---------------------------------------------------------------------------
# Issue #797 — non-English ARTIST whose name spans scripts
# ---------------------------------------------------------------------------


def test_cross_script_artist_confirmed_via_alias_skips_below_095(verifier):
    """#797 headline: requested 'Joe Hisaishi' (romanized), AcoustID
    returns the recording with the artist/title in their native kanji
    ('久石譲'). The alias bridge confirms 久石譲 IS Joe Hisaishi, the
    fingerprint is solid (0.85, above the 0.80 trust floor) but below
    the old 0.95 language/script bar. Pre-#797 this FAILed and the
    correct file was quarantined. Now it SKIPs."""
    with patch(
        'core.acoustid_verification._resolve_expected_artist_aliases',
        return_value=['久石譲'],
    ):
        _stub_lookup(verifier, recordings=[
            {'title': '風のとおり道', 'artist': '久石譲'},
        ], best_score=0.85)

        result, msg = verifier.verify_audio_file(
            '/fake/path.flac',
            'The Path of the Wind',
            'Joe Hisaishi',
        )
    assert result == VerificationResult.SKIP
    assert 'language/script' in msg.lower()


def test_cross_script_artist_NOT_confirmed_still_fails(verifier):
    """#797 tight scope: if the alias bridge can't confirm the artist
    (lookup returns nothing), we have no positive evidence the kanji
    artist IS the expected one — so the #797 relaxation must NOT fire.
    The relaxation only rescues a CONFIRMED cross-script artist.

    Constructed so best_rec is set (partial title overlap → non-zero
    combined score) and the title stays under the strict threshold, so
    the flow reaches the same skip-decision point the rescue lives at —
    proving it doesn't fire without a confirmed artist."""
    with patch(
        'core.acoustid_verification._resolve_expected_artist_aliases',
        return_value=[],
    ):
        _stub_lookup(verifier, recordings=[
            {'title': 'Summer Night', 'artist': '久石譲'},
        ], best_score=0.85)

        result, _msg = verifier.verify_audio_file(
            '/fake/path.flac',
            'Summer',
            'Joe Hisaishi',
        )
    assert result == VerificationResult.FAIL


def test_old_loose_threshold_no_longer_fires_for_unrelated_titles(verifier):
    """Pin the negative case for the old loose threshold (title_sim
    >= 0.55). 'Crown' vs 'Crown of Thorns' had similarity around 0.6
    in some normalizations — under old logic with high confidence
    and matching artist that would skip. New logic requires title_sim
    >= 0.80 OR non-ASCII presence."""
    _stub_lookup(verifier, recordings=[
        {'title': 'Crown of Thorns', 'artist': 'Kendrick Lamar'},
    ], best_score=0.96)

    result, _msg = verifier.verify_audio_file(
        '/fake/path.flac',
        'Crown',
        'Kendrick Lamar',
    )
    # User asked for 'Crown', got 'Crown of Thorns' — should FAIL now
    assert result == VerificationResult.FAIL