These are ballpark figures. Actual costs vary with subtitle density and the length of each line. OpenRouter shows your usage and spending on their dashboard in real time.
+ These are ballpark figures. Actual costs vary with subtitle density, the length of each line, and the provider that serves the request: the same model can cost twice as much from a fast provider as from the cheapest one, so switch Provider Routing to Cheapest when price matters more than speed. OpenRouter shows your usage and spending on their dashboard in real time.
Watch your spending. Batch-translating hundreds of episodes with a premium model can add up. Set a spending limit on your OpenRouter account if you want a safety net. The setting is under Account > Credits on their site.
diff --git a/site/index.html b/site/index.html
index e8b4867c67..fbdf402ed8 100644
--- a/site/index.html
+++ b/site/index.html
@@ -36,7 +36,7 @@
"name": "Bazarr+",
"applicationCategory": "MultimediaApplication",
"operatingSystem": "Docker, Linux, Windows, macOS",
- "softwareVersion": "2.6.1",
+ "softwareVersion": "2.6.2",
"license": "https://www.gnu.org/licenses/gpl-3.0.html",
"url": "https://lavx.github.io/bazarr/",
"codeRepository": "https://github.com/LavX/bazarr",
@@ -597,12 +597,14 @@
Roadmap
Shipped
The v2 line so far
- Eleven releases on the v2 line so far, most recently
- v2.6 “Clockwork”: a correctness pass across the whole surface,
- subtitle downloads including whole-season bundles, sync results held to the offset you
- configured, and databases from upstream Bazarr adopted instead of refused. Before it,
- v2.5 “Murmuration” brought many Sonarr and Radarr instances
- managed as one, per-instance subtitle settings and archive uploads.
+ v2.6.2 “Clockwork” keeps subtitle history and sync outputs
+ with the right media, saves useful partial OpenRouter translations with an incomplete
+ status, lists uploads before background sync finishes, and adds explicit OpenRouter
+ routing choices. Searches continue past unusable archives from catalog providers. The v2.6 line also
+ brought whole-season subtitle downloads, stricter sync validation, and adoption of
+ upstream Bazarr databases. Before it, v2.5 “Murmuration”
+ brought many Sonarr and Radarr instances managed as one, per-instance subtitle settings
+ and archive uploads.
Every release, with full notes
diff --git a/tests/bazarr/fixtures/cryptography49_fernet.json b/tests/bazarr/fixtures/cryptography49_fernet.json
new file mode 100644
index 0000000000..b41f8b8c35
--- /dev/null
+++ b/tests/bazarr/fixtures/cryptography49_fernet.json
@@ -0,0 +1,18 @@
+{
+ "source_version": "49.0.0",
+ "master_key": "synthetic-master-key-for-version-compatibility-only",
+ "cases": [
+ {
+ "plaintext": "synthetic-provider-token",
+ "ciphertext": "enc:v1:gAAAAABqm1uaEus9uqCEc7V5GDwndiAh3HvmiIbEEuVCLpudK4OzvCXIt_jOGT-flGv-rNjFnj06Za8vLGX9SM6UNK9POzfHSc012E_Vd2wA_-zEQqis2PQ="
+ },
+ {
+ "plaintext": "synthetic-translator-token",
+ "ciphertext": "enc:v1:gAAAAABqm1uaHS6Ro_bVCFQEdgdCn2veRLwb7Bj4wcK5cJi1z5VPRpY1A-UO1u1qeddWggCYNKMH743Bw25kNLRStuSrDAv_yW90ktfxZKl7ahXKmJwEkZc="
+ },
+ {
+ "plaintext": "synthetic-unicode-árvÃztűrÅ‘",
+ "ciphertext": "enc:v1:gAAAAABqm1uaQlgBNKC4euTO9bTpCe-MJ0qtKVdFu8O56EwIXx9BtLH-YGq_nQcNZi53xqMy8ft1Cyi2V8SDqqm2SoTgCxLPzcPLW3FZa9uzZXSA2HWlyJk="
+ }
+ ]
+}
diff --git a/tests/bazarr/test_archive_member_matching.py b/tests/bazarr/test_archive_member_matching.py
index ba12c32236..8eddacc1d6 100644
--- a/tests/bazarr/test_archive_member_matching.py
+++ b/tests/bazarr/test_archive_member_matching.py
@@ -26,6 +26,7 @@
import provider_hub.protocol as proto
from subliminal_patch.core import SUBTITLE_EXTENSIONS
+from subliminal_patch.exceptions import SubtitleCandidateRejected
from subliminal_patch.providers import utils
from subliminal_patch.providers.utils import get_archive_from_bytes
@@ -173,8 +174,8 @@ def test_failed_extraction_logs_the_member_names(caplog):
assert "Trailer.mkv" in logged
-def test_archive_without_any_subtitle_member_still_fails_loudly():
- with pytest.raises(proto.WorkerProtocolError):
+def test_archive_without_any_subtitle_member_rejects_candidate():
+ with pytest.raises(SubtitleCandidateRejected, match="No usable subtitle member"):
_download(_zip([("poster.jpg", b"binary")]))
diff --git a/tests/bazarr/test_auto_translation_profile.py b/tests/bazarr/test_auto_translation_profile.py
index 61e731b8cb..46f392af44 100644
--- a/tests/bazarr/test_auto_translation_profile.py
+++ b/tests/bazarr/test_auto_translation_profile.py
@@ -1,14 +1,18 @@
# coding=utf-8
+import logging
from types import SimpleNamespace
from unittest.mock import Mock, patch
+import pytest
+
def _missing_language(alpha3, hi=False, forced=False):
return SimpleNamespace(alpha3=alpha3, hi=hi, forced=forced)
-def test_downloaded_series_subtitle_queues_episode_translation():
+@pytest.mark.parametrize('source_score_percent', [90, 100, None])
+def test_downloaded_series_subtitle_queues_episode_translation(source_score_percent):
from subtitles.processing import _trigger_auto_translation
mock_database = Mock()
@@ -30,7 +34,7 @@ def test_downloaded_series_subtitle_queues_episode_translation():
patch('subtitles.processing.alpha2_from_alpha3', return_value='hu'),
patch('subtitles.tools.translate.main.translate_subtitles_file') as mock_translate,
):
- mock_settings.translator.min_source_score = 0
+ mock_settings.translator.min_source_score = 90
mock_profiles.return_value = {
'items': [
{
@@ -50,13 +54,125 @@ def test_downloaded_series_subtitle_queues_episode_translation():
media_type='series',
series_id=10,
episode_id=20,
- source_score_percent=100,
+ source_score_percent=source_score_percent,
)
mock_translate.assert_called_once()
assert mock_translate.call_args.kwargs['media_type'] == 'episode'
+@pytest.mark.parametrize('profile', [
+ None,
+ {'items': []},
+ {'items': [
+ {'language': 'en', 'translate_from': None},
+ {'language': 'hr', 'translate_from': None},
+ ]},
+ {'items': [{'language': 'hu', 'translate_from': 'fr'}]},
+ {'items': [{'language': 'en', 'translate_from': 'en'}]},
+], ids=['no-profile', 'empty-profile', 'disabled', 'different-source', 'same-language'])
+def test_downloaded_subtitle_without_matching_translation_target_stays_silent(profile, caplog):
+ from subtitles.processing import _trigger_auto_translation
+
+ mock_database = Mock()
+ mock_database.execute.return_value.first.return_value = SimpleNamespace(
+ imdbId='tt2', tmdbId='2', profileId=1,
+ )
+
+ with (
+ caplog.at_level(logging.INFO),
+ patch('subtitles.processing.settings') as mock_settings,
+ patch('app.database.get_profiles_list', return_value=profile),
+ patch('app.database.database', mock_database),
+ patch('subtitles.download.check_missing_languages') as mock_missing,
+ patch('subtitles.tools.translate.main.translate_subtitles_file') as mock_translate,
+ ):
+ mock_settings.translator.min_source_score = 90
+
+ _trigger_auto_translation(
+ downloaded_lang='en',
+ subtitle_path='/subs/source.en.srt',
+ video_path='/video/movie.mkv',
+ media_type='movie',
+ radarr_id=30,
+ source_score_percent=80,
+ )
+
+ assert not [record for record in caplog.records if 'auto-translate' in record.getMessage()]
+ assert not [record for record in caplog.records if record.levelno >= logging.ERROR]
+ mock_missing.assert_not_called()
+ mock_translate.assert_not_called()
+
+
+def test_low_score_subtitle_logs_once_for_multiple_matching_translation_targets(caplog):
+ from subtitles.processing import _trigger_auto_translation
+
+ mock_database = Mock()
+ mock_database.execute.return_value.first.return_value = SimpleNamespace(
+ imdbId='tt2', tmdbId='2', profileId=1,
+ )
+
+ with (
+ caplog.at_level(logging.INFO),
+ patch('subtitles.processing.settings') as mock_settings,
+ patch('app.database.get_profiles_list') as mock_profiles,
+ patch('app.database.database', mock_database),
+ patch('subtitles.download.check_missing_languages') as mock_missing,
+ patch('subtitles.tools.translate.main.translate_subtitles_file') as mock_translate,
+ ):
+ mock_settings.translator.min_source_score = 90
+ mock_profiles.return_value = {
+ 'items': [
+ {'language': 'hu', 'translate_from': 'en'},
+ {'language': 'hr', 'translate_from': 'en'},
+ ]
+ }
+
+ _trigger_auto_translation(
+ downloaded_lang='en',
+ subtitle_path='/subs/source.en.srt',
+ video_path='/video/movie.mkv',
+ media_type='movie',
+ radarr_id=30,
+ source_score_percent=80,
+ )
+
+ score_logs = [record for record in caplog.records if 'below threshold' in record.getMessage()]
+ assert len(score_logs) == 1
+ assert score_logs[0].levelno == logging.INFO
+ assert score_logs[0].args == (80, 90, '/video/movie.mkv')
+ mock_missing.assert_not_called()
+ mock_translate.assert_not_called()
+
+
+@pytest.mark.parametrize('source_score_percent', [80, 100])
+def test_forced_source_subtitle_stays_silent_and_does_not_translate(source_score_percent, caplog):
+ from subtitles.processing import _trigger_auto_translation
+
+ with (
+ caplog.at_level(logging.INFO),
+ patch('subtitles.processing.settings') as mock_settings,
+ patch('app.database.database') as mock_database,
+ patch('subtitles.tools.translate.main.translate_subtitles_file') as mock_translate,
+ ):
+ mock_settings.translator.min_source_score = 90
+
+ _trigger_auto_translation(
+ downloaded_lang='en',
+ subtitle_path='/subs/source.en.forced.srt',
+ video_path='/video/movie.mkv',
+ media_type='movie',
+ radarr_id=30,
+ source_score_percent=source_score_percent,
+ forced=True,
+ )
+
+ assert not [record for record in caplog.records if 'auto-translate' in record.getMessage()]
+ assert not [record for record in caplog.records if record.levelno >= logging.ERROR]
+ mock_database.execute.assert_not_called()
+ mock_translate.assert_not_called()
+
+
def test_downloaded_subtitle_does_not_translate_for_mismatched_target_variant():
from subtitles.processing import _trigger_auto_translation
diff --git a/tests/bazarr/test_combine_main.py b/tests/bazarr/test_combine_main.py
index eb68cdf054..a1ac6007d7 100644
--- a/tests/bazarr/test_combine_main.py
+++ b/tests/bazarr/test_combine_main.py
@@ -153,7 +153,7 @@ def test_failed_compose_returns_failed(
mock_resolve.return_value = make_sources(
tmp_path, "en_hu_sibling_en.srt", "en_hu_sibling_hu.srt"
)
- mock_filename.return_value = str(tmp_path / "out.srt")
+ mock_filename.return_value = str(tmp_path / "Movie.en.combined-hu.srt")
mock_compose.side_effect = ValueError("bad SRT")
result = try_combine_for_video(
diff --git a/tests/bazarr/test_dependency_loading.py b/tests/bazarr/test_dependency_loading.py
index 9522696563..f5457bd969 100644
--- a/tests/bazarr/test_dependency_loading.py
+++ b/tests/bazarr/test_dependency_loading.py
@@ -1,9 +1,15 @@
import subprocess
import sys
+import re
+import json
from pathlib import Path
+from packaging.requirements import Requirement
+from packaging.specifiers import SpecifierSet
+from packaging.utils import canonicalize_name
import subliminal
import yaml
+import pytest
def test_pytest_conftest_imports_without_pkg_resources_deprecation_warning():
@@ -234,6 +240,7 @@ def test_startup_requirements_probe_uses_security_patched_dependency_versions():
requirements = (repo_root / "requirements.txt").read_text()
expected_versions = {
+ "cryptography": ("cryptography", ">=50.0.1"),
"dynaconf": ("dynaconf", "==3.3.5"),
"urllib3": ("urllib3", "==2.7.0"),
}
@@ -243,6 +250,102 @@ def test_startup_requirements_probe_uses_security_patched_dependency_versions():
assert f"{distribution}{spec}" in requirements
+def test_startup_declarations_match_installation_requirements():
+ from app.requirements import RUNTIME_REQUIREMENTS, WINDOWS_RUNTIME_REQUIREMENTS
+
+ repo_root = Path(__file__).resolve().parents[2]
+ installed = {}
+ for raw_line in (repo_root / "requirements.txt").read_text().splitlines():
+ line = raw_line.split("#", 1)[0].strip()
+ if not line:
+ continue
+ # pip's per-requirement options are not part of the version or marker.
+ requirement = Requirement(re.split(r"\s+--", line, maxsplit=1)[0])
+ installed[canonicalize_name(requirement.name)] = requirement
+
+ declarations = {**RUNTIME_REQUIREMENTS, **WINDOWS_RUNTIME_REQUIREMENTS}
+ separate_installs = {distribution for distribution, _ in declarations.values()
+ if canonicalize_name(distribution) not in installed}
+ # signalrcore is installed separately with --no-deps to retain safe msgpack.
+ assert separate_installs == {"signalrcore"}
+ mismatches = {}
+ for module, (distribution, spec) in declarations.items():
+ if distribution == "signalrcore":
+ continue
+ requirement = installed[canonicalize_name(distribution)]
+ if SpecifierSet(spec) != requirement.specifier:
+ mismatches[module] = (spec, str(requirement.specifier))
+ if module in WINDOWS_RUNTIME_REQUIREMENTS:
+ assert requirement.marker is not None
+ assert requirement.marker.evaluate({"platform_system": "Windows"})
+ assert not requirement.marker.evaluate({"platform_system": "Linux"})
+ else:
+ assert requirement.marker is None
+ assert mismatches == {}
+
+
+def test_complete_compliant_runtime_does_not_request_install_or_restart(monkeypatch, tmp_path):
+ from app import requirements
+
+ monkeypatch.setenv("PLEXAPI_CONFIG_PATH", str(tmp_path / "plexapi.ini"))
+ monkeypatch.setenv("XDG_CACHE_HOME", str(tmp_path / "cache"))
+ repairs, restarts = [], []
+ monkeypatch.setattr(requirements, "install_requirements", lambda missing: repairs.append(missing) or True)
+ monkeypatch.setattr(requirements, "restart_after_requirements_install", lambda: restarts.append(True))
+
+ assert requirements.missing_runtime_requirements() == []
+ assert requirements.ensure_requirements() is False
+ assert requirements.ensure_requirements() is False
+ assert repairs == restarts == []
+
+
+@pytest.mark.parametrize("module,distribution,unsupported", [
+ ("alembic", "alembic", "1.18.4"),
+ ("cloudscraper", "cloudscraper", "1.2.72"),
+ ("numpy", "numpy", "2.6.0"),
+ ("PIL", "Pillow", "12.2.0"),
+ ("dateutil", "python-dateutil", "2.9.0rc0"),
+ ("dateutil", "python-dateutil", "2.9.0.dev0"),
+ ("dateutil", "python-dateutil", "2.9.0"),
+ ("dateutil", "python-dateutil", "2.9.0.post1"),
+ ("dateutil", "python-dateutil", "invalid"),
+])
+def test_complete_runtime_repairs_an_unsupported_version_once(monkeypatch, tmp_path,
+ module, distribution, unsupported):
+ from app import requirements
+
+ monkeypatch.setenv("PLEXAPI_CONFIG_PATH", str(tmp_path / "plexapi.ini"))
+ monkeypatch.setenv("XDG_CACHE_HOME", str(tmp_path / "cache"))
+ actual_version = requirements.metadata.version
+ installed_version = [unsupported]
+
+ def version(name):
+ if canonicalize_name(name) == canonicalize_name(distribution):
+ return installed_version[0]
+ return actual_version(name)
+
+ monkeypatch.setattr(requirements.metadata, "version", version)
+ repairs, restarts = [], []
+
+ def install(missing):
+ repairs.append(missing)
+ installed_version[0] = actual_version(distribution)
+ return True
+
+ monkeypatch.setattr(requirements, "install_requirements", install)
+ monkeypatch.setattr(requirements, "restart_after_requirements_install", lambda: restarts.append(True))
+
+ assert requirements.missing_runtime_requirements() == [module]
+ assert requirements.ensure_requirements(no_update=True) is False
+ assert repairs == restarts == []
+ assert requirements.ensure_requirements() is True
+ assert repairs == [[module]]
+ assert restarts == [True]
+ assert requirements.missing_runtime_requirements() == []
+ assert requirements.ensure_requirements() is False
+ assert len(repairs) == len(restarts) == 1
+
+
def test_startup_requirements_probe_rejects_wrong_pinned_versions(monkeypatch):
from app import requirements
@@ -263,6 +366,154 @@ def test_startup_requirements_probe_supports_upper_bound_specs():
assert not _satisfies_spec("1.2.59", "<=1.2.58")
+VERSION_BOUNDARIES = [
+ ("2.9.0rc0", "==2.9.0.post0", False),
+ ("2.9.0.dev0", "==2.9.0.post0", False),
+ ("2.9.0", "==2.9.0.post0", False),
+ ("2.9.0.post0", "==2.9.0.post0", True),
+ ("2.9.0.post1", "==2.9.0.post0", False),
+ ("2.9.0.post0+vendor.1", "==2.9.0.post0", True),
+ ("2.9.0.post0", "==2.9.0", False),
+ ("50.0.1rc1", ">=50.0.1", False),
+ ("50.0.1.dev1", ">=50.0.1", False),
+ ("50.0.1", ">=50.0.1", True),
+ ("50.0.1.post0", ">=50.0.1", True),
+ ("50.0.1+vendor.1", ">=50.0.1", True),
+ ("50.0.2rc1", ">=50.0.1", True),
+ ("50.0.2.dev1", ">=50.0.1", True),
+ ("1.0", "==1.0.0", True),
+ ("v1.0.0", "==1.0", True),
+ ("1.0+vendor.1", "==1.0", True),
+ ("1.0+vendor.2", "==1.0+vendor.1", False),
+ ("1.0+vendor.1", "==1.0+vendor.1", True),
+ ("1!1.0", ">=2.0", True),
+ ("2.0", ">=1!1.0", False),
+ ("2.5.1", ">=2.5.2,<2.6.0", False),
+ ("2.5.2", ">=2.5.2,<2.6.0", True),
+ ("2.5.9rc1", ">=2.5.2,<2.6.0", True),
+ ("2.6.0rc1", ">=2.5.2,<2.6.0", False),
+ ("2.6.0.dev1", ">=2.5.2,<2.6.0", False),
+ ("2.6.0", ">=2.5.2,<2.6.0", False),
+ ("1.2.71", "<=1.2.71", True),
+ ("1.2.71.post0", "<=1.2.71", False),
+ ("1.2.71rc1", "<=1.2.71", True),
+ ("1.0rc1", ">=1.0rc1,<1.0", False),
+ ("1.0rc1", "==1.0rc1", True),
+ ("1.0rc2", "==1.0rc1", False),
+ ("unknown", ">=1.0", False),
+ ("unknown", "<2.0", False),
+ ("1.0-broken", "==1.0", False),
+]
+
+
+@pytest.mark.parametrize("installed,spec,expected", VERSION_BOUNDARIES)
+def test_installed_versions_follow_pep440_boundaries(installed, spec, expected):
+ from app.requirements import _satisfies_spec
+
+ assert _satisfies_spec(installed, spec) is expected
+
+
+@pytest.mark.parametrize("backend", ["packaging", "pip_vendored", "unavailable"])
+def test_version_parser_bootstraps_with_available_production_dependencies(backend):
+ repo_root = Path(__file__).resolve().parents[2]
+ script = r'''
+import importlib.abc
+import json
+import sys
+
+backend, cases = sys.argv[1], json.loads(sys.argv[2])
+class ParserBlocker(importlib.abc.MetaPathFinder):
+ def find_spec(self, fullname, path=None, target=None):
+ if backend != "packaging" and (fullname == "packaging" or fullname.startswith("packaging.")):
+ raise ModuleNotFoundError(name=fullname)
+ if backend == "unavailable" and (fullname == "pip" or fullname.startswith("pip.")):
+ raise ModuleNotFoundError(name=fullname)
+
+sys.meta_path.insert(0, ParserBlocker())
+from app import requirements
+assert requirements.ensure_requirements(no_update=True) is False
+assert "packaging.specifiers" not in sys.modules
+assert "pip._vendor.packaging.specifiers" not in sys.modules
+if backend == "unavailable":
+ assert requirements._satisfies_spec("1.0", "==1.0") is False
+ requirements.RUNTIME_IMPORTS = ("types",)
+ requirements.RUNTIME_REQUIREMENTS = {"types": ("fixture", "==1.0")}
+ requirements.metadata.version = lambda distribution: "1.0"
+ requirements.importlib.util.find_spec = lambda name: None
+ def forbidden_restart():
+ raise AssertionError("restart without pip")
+ requirements.restart_after_requirements_install = forbidden_restart
+ assert requirements.ensure_requirements() is True
+else:
+ for installed, spec, expected in cases:
+ assert requirements._satisfies_spec(installed, spec) is expected, (installed, spec)
+ parser = "packaging.specifiers" if backend == "packaging" else "pip._vendor.packaging.specifiers"
+ assert parser in sys.modules
+ if backend == "pip_vendored":
+ assert "packaging" not in sys.modules
+'''
+ result = subprocess.run(
+ [sys.executable, "-B", "-c", "import sys; sys.path.insert(0, "
+ + repr(str(repo_root / "bazarr")) + ");\n" + script, backend, json.dumps(VERSION_BOUNDARIES)],
+ cwd=repo_root, capture_output=True, text=True, check=False,
+ )
+ assert result.returncode == 0, result.stderr
+
+
+@pytest.mark.parametrize("backend", ["packaging", "pip_vendored"])
+def test_parser_import_does_not_hide_unrelated_missing_dependencies(monkeypatch, backend):
+ import builtins
+ from app.requirements import _satisfies_spec
+
+ original_import = builtins.__import__
+
+ def broken_parser(name, *args, **kwargs):
+ if name == "packaging.specifiers":
+ if backend == "pip_vendored":
+ raise ModuleNotFoundError(name="packaging")
+ raise ModuleNotFoundError(name="unrelated_parser_dependency")
+ if name == "pip._vendor.packaging.specifiers":
+ raise ModuleNotFoundError(name="unrelated_parser_dependency")
+ return original_import(name, *args, **kwargs)
+
+ monkeypatch.setattr(builtins, "__import__", broken_parser)
+ with pytest.raises(ModuleNotFoundError) as raised:
+ _satisfies_spec("1.0", "==1.0")
+ assert raised.value.name == "unrelated_parser_dependency"
+
+
+def test_invalid_requirement_declarations_remain_errors():
+ from app.requirements import _satisfies_spec
+
+ with pytest.raises(ValueError):
+ _satisfies_spec("1.0", "not-a-specifier")
+
+
+@pytest.mark.parametrize('installed', ['48.0.0', '49.0.0', '50.0.0', '50.0.1', '50.0.2'])
+def test_cryptography_security_floor_repairs_old_installs_once(monkeypatch, installed):
+ from app import requirements
+
+ monkeypatch.setattr(requirements, 'RUNTIME_IMPORTS', ('cryptography',))
+ installed_version = [installed]
+ monkeypatch.setattr(requirements.metadata, 'version', lambda distribution: installed_version[0])
+ repairs, restarts = [], []
+
+ def install(missing):
+ repairs.append(missing)
+ installed_version[0] = '50.0.1'
+ return True
+
+ monkeypatch.setattr(requirements, 'install_requirements', install)
+ monkeypatch.setattr(requirements, 'restart_after_requirements_install', lambda: restarts.append(True))
+ needs_repair = installed in ['48.0.0', '49.0.0', '50.0.0']
+ assert requirements.missing_runtime_requirements() == (['cryptography'] if needs_repair else [])
+ assert requirements.ensure_requirements() is needs_repair
+ assert repairs == ([['cryptography']] if needs_repair else [])
+ assert restarts == ([True] if needs_repair else [])
+ assert requirements.ensure_requirements() is False
+ assert len(repairs) == len(restarts) == int(needs_repair)
+
+
def test_startup_requirements_probe_rejects_removed_vendor_origins(monkeypatch):
from app import requirements
diff --git a/tests/bazarr/test_gemini_translator.py b/tests/bazarr/test_gemini_translator.py
index b7396fee0f..b6ffbad132 100644
--- a/tests/bazarr/test_gemini_translator.py
+++ b/tests/bazarr/test_gemini_translator.py
@@ -1,4 +1,9 @@
import time
+import json
+import sys
+from pathlib import Path
+from threading import Event, Thread
+from types import ModuleType, SimpleNamespace
import pytest
@@ -160,3 +165,167 @@ def _fail_after_output_file_created(*args, **kwargs):
service._translate_with_gemini()
assert not output_file.exists()
+
+
+@pytest.fixture
+def queued_gemini(tmp_path, monkeypatch):
+ from app import jobs_queue as queue_module
+
+ monkeypatch.setattr(queue_module.JobsQueue, "_flush_progress_loop", lambda self: None)
+ monkeypatch.setattr(queue_module, "event_stream", lambda **kwargs: None)
+ queue = queue_module.JobsQueue()
+ monkeypatch.setattr(gemini_translator, "jobs_queue", queue)
+ source = tmp_path / "Video.en.srt"
+ source.write_text("1\n00:00:01,000 --> 00:00:02,000\nSource text\n", encoding="utf-8")
+ destination = tmp_path / "Video.hu.srt"
+ destination.write_text("Previous destination", encoding="utf-8")
+ video = tmp_path / "Video.mkv"
+ video.touch()
+ service = gemini_translator.GeminiTranslatorService(
+ str(source), str(destination), "hun", "movie", None, None, 7, False, False,
+ str(video), "en", "hu", arr_instance_id=2)
+ monkeypatch.setattr(service, "_get_configured_api_keys", lambda: ["fixture-one", "fixture-two"])
+ monkeypatch.setattr(service, "_get_batch_size", lambda: 1)
+ monkeypatch.setattr(gemini_translator, "get_description", lambda *args, **kwargs: "")
+ monkeypatch.setattr(gemini_translator, "language_from_alpha2", lambda value: "English")
+ monkeypatch.setattr(gemini_translator, "language_from_alpha3", lambda value: "Hungarian")
+ monkeypatch.setattr(gemini_translator, "create_process_result", lambda *args, **kwargs: None)
+ history = []
+ monkeypatch.setattr(gemini_translator, "history_log_movie", lambda **kwargs: history.append(kwargs))
+ dispatch = ModuleType("gemini_cancellation_fixture")
+ dispatch.translate = service.translate
+ monkeypatch.setitem(sys.modules, dispatch.__name__, dispatch)
+ queue.feed_jobs_pending_queue("Translation", dispatch.__name__, "translate", is_progress=True)
+ job = queue.jobs_pending_queue.popleft()
+ queue.jobs_running_queue.append(job)
+ worker = Thread(target=queue._run_job, args=(job,))
+ release = Event()
+ fixture = SimpleNamespace(queue=queue, job=job, service=service, source=source, destination=destination,
+ worker=worker, entered=Event(), release=release, calls=[], history=history)
+ yield fixture
+ release.set()
+ if worker.ident:
+ worker.join(3)
+ assert not worker.is_alive()
+
+
+def _gemini_response(status=200):
+ response = gemini_translator.requests.Response()
+ response.status_code = status
+ response.headers["Retry-After"] = "7"
+ content = ({"candidates": [{"content": {"parts": [{"text": json.dumps([
+ {"index": "0", "content": "Translated text"}])}]}}]} if status == 200 else
+ {"error": {"status": "RESOURCE_EXHAUSTED"}})
+ response._content = json.dumps(content).encode()
+ return response
+
+
+def _record_cancellation_state(fixture, record_property):
+ record_property("transport_calls", len(fixture.calls))
+ record_property("progress_files_remaining", len(list(fixture.source.parent.glob("*.progress"))))
+ record_property("temporary_files_remaining", len(list(fixture.source.parent.glob(".bazarr-write-*"))))
+ record_property("job_cancelled", fixture.job.cancelled)
+ assert fixture.job.cancelled
+ assert fixture.job.status == "completed"
+ assert fixture.job.progress_message == "Cancelled by user"
+ assert fixture.destination.read_text() == "Previous destination"
+ assert "Source text" in fixture.source.read_text()
+ assert not fixture.history
+ assert not list(fixture.source.parent.glob(".bazarr-write-*"))
+ assert not list(fixture.source.parent.glob("*.progress"))
+
+
+@pytest.mark.parametrize("response_kind", ["success", "transient-error", "rate-limit"])
+def test_cancelled_response_does_not_retry_translation(queued_gemini, monkeypatch, record_property, response_kind):
+ fixture = queued_gemini
+
+ def transport(*args, **kwargs):
+ fixture.calls.append(True)
+ fixture.entered.set()
+ assert fixture.release.wait(3)
+ if response_kind == "transient-error":
+ raise gemini_translator.requests.ConnectionError("synthetic transport failure")
+ return _gemini_response(429 if response_kind == "rate-limit" else 200)
+
+ monkeypatch.setattr(gemini_translator.requests, "request", transport)
+ fixture.worker.start()
+ assert fixture.entered.wait(3)
+ assert fixture.queue.cancel_running_job(fixture.job.job_id)
+ fixture.release.set()
+ fixture.worker.join(3)
+ assert not fixture.worker.is_alive()
+ _record_cancellation_state(fixture, record_property)
+ assert len(fixture.calls) == 1
+
+
+@pytest.mark.parametrize("phase", ["initial-progress", "final-progress"])
+def test_cancellation_at_progress_boundary_clears_progress(queued_gemini, monkeypatch, record_property, phase):
+ fixture = queued_gemini
+ original = fixture.queue.update_job_progress
+
+ def progress(*args, **kwargs):
+ if ((phase == "initial-progress" and "progress_max" in kwargs) or
+ (phase == "final-progress" and "progress_value" in kwargs
+ and kwargs.get("progress_message") == str(fixture.source))):
+ assert Path(fixture.service.progress_file).is_file()
+ assert fixture.queue.cancel_running_job(fixture.job.job_id)
+ return original(*args, **kwargs)
+
+ monkeypatch.setattr(fixture.queue, "update_job_progress", progress)
+ monkeypatch.setattr(gemini_translator.requests, "request",
+ lambda *args, **kwargs: fixture.calls.append(True) or _gemini_response())
+ fixture.worker.start()
+ fixture.worker.join(3)
+ assert not fixture.worker.is_alive()
+ _record_cancellation_state(fixture, record_property)
+ assert len(fixture.calls) == (0 if phase == "initial-progress" else 1)
+
+
+def test_already_cancelled_batch_does_not_send_request(queued_gemini, monkeypatch, record_property):
+ from app.jobs_queue import JobCancelled
+
+ fixture = queued_gemini
+ service = fixture.service
+ service.job_id = fixture.job.job_id
+ service.current_api_key = "fixture"
+ service.target_language = "Hungarian"
+ assert fixture.queue.cancel_running_job(fixture.job.job_id)
+ monkeypatch.setattr(gemini_translator.requests, "request",
+ lambda *args, **kwargs: fixture.calls.append(True) or _gemini_response())
+ batch = [{"index": "0", "content": "Source text"}]
+ translated = list(gemini_translator.srt.parse(fixture.source.read_text()))
+ with pytest.raises(JobCancelled):
+ service._process_batch(batch, translated, 1)
+ record_property("transport_calls", len(fixture.calls))
+ assert not fixture.calls
+
+
+@pytest.mark.parametrize("failure", ["transient", "rate-limit", "exhausted"])
+def test_ordinary_request_retries_keep_existing_behavior(queued_gemini, monkeypatch, failure):
+ fixture = queued_gemini
+ keys = []
+
+ def transport(*args, **kwargs):
+ fixture.calls.append(True)
+ keys.append(fixture.service.current_api_key)
+ if failure == "exhausted" or (failure == "transient" and len(fixture.calls) == 1):
+ raise gemini_translator.requests.ConnectionError("synthetic transport failure")
+ return _gemini_response(429 if failure == "rate-limit" and len(fixture.calls) == 1 else 200)
+
+ monkeypatch.setattr(gemini_translator.requests, "request", transport)
+ fixture.worker.start()
+ fixture.worker.join(3)
+ assert not fixture.worker.is_alive()
+ assert len(fixture.calls) == (4 if failure == "exhausted" else 2)
+ assert not fixture.job.cancelled
+ assert fixture.job.status == ("failed" if failure == "exhausted" else "completed")
+ assert len(fixture.history) == (0 if failure == "exhausted" else 1)
+ if failure == "exhausted":
+ assert fixture.destination.read_text() == "Previous destination"
+ else:
+ assert "Translated text" in fixture.destination.read_text()
+ assert "Source text" in fixture.source.read_text()
+ assert not list(fixture.source.parent.glob("*.progress"))
+ assert not list(fixture.source.parent.glob(".bazarr-write-*"))
+ if failure == "rate-limit":
+ assert keys[0] != keys[1]
diff --git a/tests/bazarr/test_history_owner_resolution.py b/tests/bazarr/test_history_owner_resolution.py
new file mode 100644
index 0000000000..9d2ebb10cb
--- /dev/null
+++ b/tests/bazarr/test_history_owner_resolution.py
@@ -0,0 +1,227 @@
+# coding=utf-8
+"""History ownership must survive missing media rows (LavX/bazarr#404)."""
+
+import logging
+from datetime import datetime
+from functools import partial
+from types import SimpleNamespace
+
+import pytest
+from sqlalchemy import MetaData, create_engine, event, select
+from sqlalchemy.orm import sessionmaker
+
+
+@pytest.fixture
+def history_session():
+ from app.database import Base
+
+ # The cutover migration requires an owner, while the ORM still allows NULL.
+ # Clone the metadata so this fixture cannot change other tests' schemas.
+ metadata = MetaData()
+ for table in Base.metadata.sorted_tables:
+ table.to_metadata(metadata)
+ for name in ('table_history', 'table_history_movie'):
+ metadata.tables[name].c.arr_instance_id.nullable = False
+
+ engine = create_engine('sqlite:///:memory:')
+
+ @event.listens_for(engine, 'connect')
+ def enable_foreign_keys(connection, connection_record):
+ connection.execute('PRAGMA foreign_keys=ON')
+
+ metadata.create_all(engine)
+ session = sessionmaker(bind=engine)()
+ try:
+ yield session
+ finally:
+ session.close()
+ engine.dispose()
+
+
+@pytest.fixture(params=['episode', 'movie'])
+def history(request, history_session, monkeypatch):
+ from app.database import TableHistory, TableHistoryMovie
+ from radarr import history as movie_history
+ from sonarr import history as episode_history
+
+ if request.param == 'episode':
+ case = SimpleNamespace(
+ module=episode_history,
+ log=partial(episode_history.history_log, sonarr_series_id=10),
+ table=TableHistory,
+ upstream_arg='sonarr_episode_id',
+ upstream_column='sonarrEpisodeId',
+ local_refs={'episode_id': 601, 'series_id': 501},
+ resolver='_resolve_episode_owner_row',
+ score_out_of=360,
+ instance_kind='sonarr',
+ )
+ else:
+ case = SimpleNamespace(
+ module=movie_history,
+ log=movie_history.history_log_movie,
+ table=TableHistoryMovie,
+ upstream_arg='radarr_id',
+ upstream_column='radarrId',
+ local_refs={'movie_id': 601},
+ resolver='_resolve_movie_owner_row',
+ score_out_of=180,
+ instance_kind='radarr',
+ )
+ case.kind = request.param
+ case.events = []
+ monkeypatch.setattr(case.module, 'database', history_session)
+ monkeypatch.setattr(case.module, 'event_stream', lambda **event: case.events.append(event))
+ return case
+
+
+@pytest.fixture
+def download_result():
+ return SimpleNamespace(
+ message='Subtitle downloaded',
+ path='/media/video.mkv',
+ language_code='en',
+ provider='provider-a',
+ score=75,
+ subs_id='subtitle-123',
+ subs_path='/media/video.en.srt',
+ matched=['title', 'year'],
+ not_matched=['release_group'],
+ )
+
+
+def add_media(history, session, owner, local_id=601):
+ from app.database import TableEpisodes, TableMovies, TableShows
+
+ if history.kind == 'episode':
+ session.add(TableShows(
+ id=local_id - 100, sonarrSeriesId=10, arr_instance_id=owner,
+ path=f'/media/series-{local_id}', title='Series',
+ ))
+ session.flush()
+ session.add(TableEpisodes(
+ id=local_id, series_id=local_id - 100,
+ sonarrSeriesId=10, sonarrEpisodeId=101, arr_instance_id=owner,
+ path=f'/media/video-{local_id}.mkv', title='Episode', season=1, episode=1,
+ ))
+ else:
+ session.add(TableMovies(
+ id=local_id, radarrId=101, arr_instance_id=owner,
+ path=f'/media/video-{local_id}.mkv', title='Movie', tmdbId='123',
+ ))
+ session.flush()
+
+
+def log_history(history, result, media_id=101, **kwargs):
+ return history.log(action=1, result=result, **{history.upstream_arg: media_id}, **kwargs)
+
+
+def test_explicit_owner_survives_missing_media(history, history_session, download_result):
+ # A matching upstream ID in another instance must not supply local refs.
+ add_media(history, history_session, owner=7, local_id=701)
+
+ log_history(history, download_result, arr_instance_id=4)
+ history_session.commit()
+
+ row = history_session.execute(select(history.table)).scalar_one()
+ assert row.arr_instance_id == 4
+ assert getattr(row, history.upstream_column) == 101
+ assert all(getattr(row, ref) is None for ref in history.local_refs)
+ assert history.events == [{'type': f'{history.kind}-history'}]
+
+
+def test_explicit_owner_without_media_id_skips_lookup(history, history_session, download_result, monkeypatch):
+ def unexpected_lookup(*args):
+ pytest.fail('History without an upstream media ID must not query its owner')
+
+ monkeypatch.setattr(history.module, history.resolver, unexpected_lookup)
+
+ log_history(history, download_result, media_id=None, arr_instance_id=4)
+ history_session.commit()
+
+ row = history_session.execute(select(history.table)).scalar_one()
+ assert row.arr_instance_id == 4
+ assert getattr(row, history.upstream_column) is None
+ assert all(getattr(row, ref) is None for ref in history.local_refs)
+ assert history.events == [{'type': f'{history.kind}-history'}]
+
+
+def test_resolved_media_supplies_owner_and_local_refs(history, history_session, download_result):
+ add_media(history, history_session, owner=4)
+
+ log_history(history, download_result)
+ history_session.commit()
+
+ row = history_session.execute(select(history.table)).scalar_one()
+ assert row.arr_instance_id == 4
+ assert {ref: getattr(row, ref) for ref in history.local_refs} == history.local_refs
+ assert row.provider == 'provider-a'
+ assert row.score == 75
+ assert row.score_out_of == history.score_out_of
+ assert history.events == [{'type': f'{history.kind}-history'}]
+
+
+@pytest.mark.parametrize('media_state', ['missing', 'no-upstream-id', 'unowned'])
+def test_missing_owner_skips_history_and_event(history, history_session, download_result, caplog, media_state):
+ from app.database import TableArrInstances
+
+ # Even a configured default cannot establish ownership of missing media.
+ history_session.add(TableArrInstances(
+ id=4, kind=history.instance_kind, stable_key='default', name='Default',
+ port=8989, enabled=1, is_default=1,
+ ))
+ if media_state == 'unowned':
+ add_media(history, history_session, owner=None)
+ history_session.flush()
+ media_id = None if media_state == 'no-upstream-id' else 101
+
+ with caplog.at_level(logging.WARNING):
+ result = log_history(history, download_result, media_id=media_id)
+ history_session.commit()
+
+ assert result is None
+ assert history_session.execute(select(history.table)).scalars().all() == []
+ assert history.events == []
+ assert any(
+ record.levelno == logging.WARNING
+ and history.kind in record.getMessage()
+ and 'owning instance' in record.getMessage()
+ and str(media_id) in record.getMessage()
+ for record in caplog.records
+ )
+
+
+def test_explicit_owner_keeps_history_fields_and_scoped_refs(history, history_session, download_result):
+ add_media(history, history_session, owner=7, local_id=701)
+ add_media(history, history_session, owner=4)
+ history_session.add(history.table(
+ id=9, arr_instance_id=4, action=1, description='Previous download',
+ timestamp=datetime(2026, 9, 1),
+ ))
+ history_session.flush()
+
+ before = datetime.now()
+ log_history(history, download_result, arr_instance_id=4,
+ fake_provider='override-provider', fake_score=80, upgraded_from_id=9)
+ history_session.commit()
+
+ row = history_session.execute(select(history.table).where(history.table.id != 9)).scalar_one()
+ assert row.arr_instance_id == 4
+ assert {ref: getattr(row, ref) for ref in history.local_refs} == history.local_refs
+ assert getattr(row, history.upstream_column) == 101
+ if history.kind == 'episode':
+ assert row.sonarrSeriesId == 10
+ assert row.action == 1
+ assert row.description == 'Subtitle downloaded'
+ assert row.video_path == '/media/video.mkv'
+ assert row.language == 'en'
+ assert row.provider == 'override-provider'
+ assert row.score == 80
+ assert row.score_out_of == history.score_out_of
+ assert row.subs_id == 'subtitle-123'
+ assert row.subtitles_path == '/media/video.en.srt'
+ assert row.matched == "['title', 'year']"
+ assert row.not_matched == "['release_group']"
+ assert row.upgradedFromId == 9
+ assert before <= row.timestamp <= datetime.now()
+ assert history.events == [{'type': f'{history.kind}-history'}]
diff --git a/tests/bazarr/test_indexer_owner_scope.py b/tests/bazarr/test_indexer_owner_scope.py
index 84cf98e7fa..81a310de3f 100644
--- a/tests/bazarr/test_indexer_owner_scope.py
+++ b/tests/bazarr/test_indexer_owner_scope.py
@@ -16,9 +16,12 @@
Callers know the owner. They must be able to say so.
"""
+import ast
+import unicodedata
+
import pytest
-from sqlalchemy import select
+from sqlalchemy import select, update
from app.database import TableEpisodes, TableMovies, TableShows
@@ -35,7 +38,7 @@ def stub_indexing(monkeypatch):
for mod in (se, mv):
monkeypatch.setattr(mod.os.path, 'exists', lambda p: True)
monkeypatch.setattr(mod, 'search_external_subtitles', lambda *a, **kw: {})
- monkeypatch.setattr(mod, 'add_sync_engine_outputs', lambda folder, subs: subs)
+ monkeypatch.setattr(mod, 'add_sync_engine_outputs', lambda folder, subs, **kw: subs)
monkeypatch.setattr(mod, 'add_combined_outputs', lambda folder, subs, **kw: subs)
monkeypatch.setattr(mod, 'guess_external_subtitles', lambda *a, **kw: {})
monkeypatch.setattr(mod, 'event_stream', lambda *a, **kw: None)
@@ -73,6 +76,306 @@ def _subs(session, table, row_id):
return session.execute(select(table.subtitles).where(table.id == row_id)).scalar()
+@pytest.mark.parametrize('media_type', ['series', 'movie'])
+@pytest.mark.parametrize('subfolder', ['current', 'relative', 'absolute'])
+@pytest.mark.parametrize('naming,single_language', [
+ ('original', False), ('case', False), ('unicode', False),
+ ('single-language', True), ('single-language', False),
+ ('legacy-tagged', True), ('legacy-tagged', False),
+ ('legacy-case', True), ('legacy-unicode', True),
+])
+def test_sync_outputs_belong_to_the_indexed_video(schema_session, monkeypatch, tmp_path,
+ media_type, subfolder, naming, single_language):
+ from app import database as database_module
+ from subzero.language import Language
+ from subtitles.tools.subsync_engines import SyncOutputOwnerIndex
+ import subtitles.indexer.movies as mv
+ import subtitles.indexer.series as se
+
+ module = se if media_type == 'series' else mv
+ table = TableEpisodes if media_type == 'series' else TableMovies
+ store = se.store_subtitles if media_type == 'series' else mv.store_subtitles_movie
+ stems = (['Show.S01E01', 'Show.S01E02', 'Show.S01E01.Extended'] if media_type == 'series'
+ else ['Movie (2020)', 'Other (2021)', 'Movie (2020).Extended'])
+ if naming in ['unicode', 'legacy-unicode']:
+ stems = ['\u00c9pisode.S01E01', '\u00c9pisode.S01E02', '\u00c9pisode.S01E01.Extended']
+ elif naming == 'single-language':
+ stems = ['Movie', 'Movie.en', 'Movie.en.Extended', 'Movie.hi', 'Movie.forced']
+ media_folder = tmp_path / 'media'
+ media_folder.mkdir()
+ subtitle_folder = {'current': media_folder, 'relative': media_folder / 'subs',
+ 'absolute': tmp_path / 'shared-subs'}[subfolder]
+ subtitle_folder.mkdir(exist_ok=True)
+ custom_folder = 'subs' if subfolder == 'relative' else str(subtitle_folder)
+ monkeypatch.setattr(module.settings.general, 'use_embedded_subs', False)
+ monkeypatch.setattr(module.settings.general, 'single_language', single_language)
+ monkeypatch.setattr(module.settings.general, 'subfolder', subfolder)
+ monkeypatch.setattr(module.settings.general, 'subfolder_custom', custom_folder)
+ monkeypatch.setattr(module.core, 'CUSTOM_PATHS', [])
+ monkeypatch.setattr(module, 'database', schema_session)
+ monkeypatch.setattr(database_module, 'database', schema_session)
+ monkeypatch.setattr(module, 'get_language_set', lambda: {Language.fromietf('en')})
+ monkeypatch.setattr(module, 'alpha2_from_alpha3', lambda code: Language(code).alpha2)
+ monkeypatch.setattr(module.path_mappings, 'path_replace_instance', lambda p, *a: p)
+ monkeypatch.setattr(module.path_mappings, 'path_replace_reverse_instance', lambda p, *a: p)
+ monkeypatch.setattr(module, 'event_stream', lambda *a, **kw: None)
+ missing = 'list_missing_subtitles' if media_type == 'series' else 'list_missing_subtitles_movies'
+ monkeypatch.setattr(module, missing, lambda *a, **kw: None)
+
+ if media_type == 'series':
+ schema_session.add(TableShows(id=1, arr_instance_id=1, sonarrSeriesId=1, title='Show',
+ path=str(media_folder), profileId=None))
+ schema_session.flush()
+
+ suffixes = {'en.srt': 'en', 'hu.ffsubsync.srt': 'hu:sync-ffsubsync',
+ 'en.hi.alass.ass': 'en:hi:sync-alass',
+ 'fr.forced.autosubsync.vtt': 'fr:forced:sync-autosubsync'}
+ if naming == 'single-language':
+ suffixes = {f'{engine}.srt': f'en:sync-{engine}'
+ for engine in ['ffsubsync', 'alass', 'autosubsync']}
+ suffixes.update({'hu.ffsubsync.srt': 'hu:sync-ffsubsync',
+ 'en.hi.alass.ass': 'en:hi:sync-alass'})
+ elif naming.startswith('legacy-'):
+ suffixes['en.ffsubsync.srt'] = 'en:sync-ffsubsync'
+ expected = {}
+ for row_id, stem in enumerate(stems, 1):
+ video = media_folder / f'{stem}.mkv'
+ video.write_bytes(b'video')
+ if media_type == 'series':
+ row = TableEpisodes(id=row_id, arr_instance_id=1, series_id=1, sonarrSeriesId=1,
+ sonarrEpisodeId=row_id, title=stem, path=str(video), season=1,
+ episode=row_id, subtitles='[]')
+ else:
+ row = TableMovies(id=row_id, arr_instance_id=1, radarrId=row_id, title=stem,
+ path=str(video), tmdbId=str(row_id), subtitles='[]')
+ schema_session.add(row)
+ expected[row_id] = []
+ subtitle_stem = stem.lower() if naming in ['case', 'legacy-case'] else stem
+ if naming in ['unicode', 'legacy-unicode']:
+ subtitle_stem = unicodedata.normalize('NFD', stem.lower())
+ for suffix, language in suffixes.items():
+ subtitle = subtitle_folder / f'{subtitle_stem}.{suffix}'
+ subtitle.write_text('1\n00:00:00,000 --> 00:00:01,000\n'
+ 'This is an English subtitle. We are going to the house together. '
+ 'There is a friend waiting for us in the garden. '
+ 'Please tell everyone that we will arrive before dinner.\n', encoding='utf-8')
+ expected[row_id].append([language, str(subtitle), subtitle.stat().st_size])
+ schema_session.flush()
+ contaminated = [entry for entries in expected.values() for entry in entries]
+ schema_session.execute(update(table).values(subtitles=str(contaminated)))
+ schema_session.commit()
+
+ first_scan = {}
+ for scan in range(3):
+ ownership_index = SyncOutputOwnerIndex()
+ if scan == 2:
+ schema_session.execute(update(table).values(subtitles='[]'))
+ schema_session.commit()
+ for row_id, stem in enumerate(stems, 1):
+ video = str(media_folder / f'{stem}.mkv')
+ actual = store(video, video, arr_instance_id=1, ownership_index=ownership_index)
+ assert len(actual) == len(expected[row_id])
+ assert {path: (set(language.split(':')), size) for language, path, size in actual} == {
+ path: (set(language.split(':')), size) for language, path, size in expected[row_id]}
+ assert ast.literal_eval(_subs(schema_session, table, row_id)) == actual
+ if scan == 0:
+ first_scan[row_id] = sorted(actual)
+ else:
+ assert sorted(actual) == first_scan[row_id]
+
+
+@pytest.mark.parametrize('media_type', ['series', 'movie'])
+@pytest.mark.parametrize('subfolder', ['relative', 'absolute'])
+@pytest.mark.parametrize('library_size', [8, 32])
+def test_full_scan_amortizes_sync_output_ownership(schema_session, monkeypatch, tmp_path,
+ media_type, subfolder, library_size):
+ from app import database as database_module
+ from subzero.language import Language
+ import subtitles.indexer.movies as mv
+ import subtitles.indexer.series as se
+
+ module = se if media_type == 'series' else mv
+ table = TableEpisodes if media_type == 'series' else TableMovies
+ full_scan = se.series_full_scan_subtitles if media_type == 'series' else mv.movies_full_scan_subtitles
+ mapping_calls = []
+ owner_queries = []
+ execute = schema_session.execute
+
+ def counted_execute(statement, *args, **kwargs):
+ if getattr(statement, 'is_select', False):
+ columns = list(statement.selected_columns)
+ if [column.name for column in columns] == ['path', 'arr_instance_id']:
+ owner_queries.append(columns[0].table.name)
+ return execute(statement, *args, **kwargs)
+
+ def mapped(path, instance, kind):
+ mapping_calls.append((instance, kind))
+ assert instance == 7
+ assert kind in ('episode', 'series', 'movie')
+ return str(tmp_path / 'media' / path.removeprefix('/remote/'))
+
+ monkeypatch.setattr(schema_session, 'execute', counted_execute)
+ monkeypatch.setattr(module, 'database', schema_session)
+ monkeypatch.setattr(database_module, 'database', schema_session)
+ monkeypatch.setattr(module.path_mappings, 'path_replace_instance', mapped)
+ monkeypatch.setattr(module.path_mappings, 'path_replace_reverse_instance', lambda path, *a: path)
+ monkeypatch.setattr(module.settings.general, 'use_embedded_subs', False)
+ monkeypatch.setattr(module.settings.general, 'single_language', False)
+ monkeypatch.setattr(module.settings.general, 'subfolder', subfolder)
+ monkeypatch.setattr(module.settings.general, 'subfolder_custom',
+ '../subs' if subfolder == 'relative' else str(tmp_path / 'subs'))
+ monkeypatch.setattr(module.core, 'CUSTOM_PATHS', [])
+ monkeypatch.setattr(module, 'get_language_set', lambda: {Language.fromietf('en')})
+ monkeypatch.setattr(module, 'alpha2_from_alpha3', lambda code: Language(code).alpha2)
+ monkeypatch.setattr(module, 'event_stream', lambda **kw: None)
+ missing = 'list_missing_subtitles' if media_type == 'series' else 'list_missing_subtitles_movies'
+ monkeypatch.setattr(module, missing, lambda **kw: None)
+ monkeypatch.setattr(module.jobs_queue, 'update_job_progress', lambda **kw: None)
+ monkeypatch.setattr(module.jobs_queue, 'update_job_name', lambda **kw: None)
+ if media_type == 'series':
+ schema_session.add(TableShows(id=1, arr_instance_id=7, sonarrSeriesId=10,
+ title='Show', path='/remote', profileId=None))
+ schema_session.flush()
+
+ expected = {}
+ for row_id in range(1, library_size + 1):
+ filename = f'Video{row_id:04}.mkv'
+ remote = f'/remote/{row_id}/{filename}'
+ video = tmp_path / 'media' / str(row_id) / filename
+ video.parent.mkdir(parents=True)
+ video.touch()
+ folder = tmp_path / 'media' / 'subs' if subfolder == 'relative' else tmp_path / 'subs'
+ folder.mkdir(exist_ok=True)
+ output = folder / f'Video{row_id:04}.en.ffsubsync.srt'
+ output.write_text('1\n00:00:00,000 --> 00:00:01,000\nAn English subtitle.\n')
+ indexed_path = video.parent / '..' / 'subs' / output.name if subfolder == 'relative' else output
+ expected[row_id] = [['en:sync-ffsubsync', str(indexed_path), output.stat().st_size]]
+ if media_type == 'series':
+ row = TableEpisodes(id=row_id, arr_instance_id=7, series_id=1, sonarrSeriesId=10,
+ sonarrEpisodeId=row_id, title=filename, path=remote, season=1,
+ episode=row_id, subtitles='[]')
+ else:
+ row = TableMovies(id=row_id, arr_instance_id=7, radarrId=row_id, title=filename,
+ path=remote, tmdbId=str(row_id), subtitles='[]')
+ schema_session.add(row)
+ schema_session.commit()
+
+ full_scan(job_id=1, use_cache=False)
+
+ counts = {'library_size': library_size, 'owner_queries': len(owner_queries),
+ 'path_mappings': len(mapping_calls)}
+ print(f'Ownership scan counts: {counts}')
+ for row_id, subtitles in expected.items():
+ assert ast.literal_eval(_subs(schema_session, table, row_id)) == subtitles
+ assert len(owner_queries) == 2, counts
+ assert len(mapping_calls) <= 8 * library_size, counts
+
+ # A new scan must see another media type claiming the same generated name.
+ conflict = tmp_path / 'media' / 'conflict' / 'Video0001.en.mkv'
+ conflict.parent.mkdir()
+ conflict.touch()
+ if media_type == 'series':
+ row = TableMovies(id=1, arr_instance_id=7, radarrId=1, title='Conflict', tmdbId='1',
+ path='/remote/conflict/Video0001.en.mkv', subtitles='[]')
+ else:
+ schema_session.add(TableShows(id=1, arr_instance_id=7, sonarrSeriesId=10,
+ title='Show', path='/remote', profileId=None))
+ schema_session.flush()
+ row = TableEpisodes(id=1, arr_instance_id=7, series_id=1, sonarrSeriesId=10,
+ sonarrEpisodeId=1, title='Conflict', season=1, episode=1,
+ path='/remote/conflict/Video0001.en.mkv', subtitles='[]')
+ schema_session.add(row)
+ schema_session.commit()
+ owner_queries.clear()
+ full_scan(job_id=2, use_cache=False)
+ assert len(owner_queries) == 2, 'independent scans must rebuild their ownership snapshot'
+ assert ast.literal_eval(_subs(schema_session, table, 1)) == []
+ for row_id in range(2, library_size + 1):
+ assert ast.literal_eval(_subs(schema_session, table, row_id)) == expected[row_id]
+
+
+@pytest.mark.parametrize('subfolder', ['relative', 'absolute'])
+@pytest.mark.parametrize('collision', [False, True])
+def test_scan_owner_index_preserves_instance_mapping_and_normalized_conflicts(
+ schema_session, monkeypatch, tmp_path, subfolder, collision):
+ from app import database as database_module
+ from app.config import settings
+ from subtitles.tools.subsync_engines import SyncOutputOwnerIndex, sync_output_owner_is_unique
+ from utilities.path_mappings import path_mappings
+
+ video = tmp_path / 'one' / '\u00c9pisode.mkv'
+ other = tmp_path / 'two' / 'e\u0301PISODE.en.mkv'
+ folder = tmp_path / 'subs'
+ for path in (video, other):
+ path.parent.mkdir()
+ path.touch()
+ folder.mkdir()
+ source = folder / 'e\u0301pisode.en.srt'
+ source.touch()
+ monkeypatch.setattr(settings.general, 'subfolder', subfolder)
+ monkeypatch.setattr(settings.general, 'subfolder_custom', '../subs' if subfolder == 'relative' else str(folder))
+ monkeypatch.setattr(database_module, 'database', schema_session)
+ for owner in (7, 8):
+ schema_session.add(TableMovies(id=owner, arr_instance_id=owner, radarrId=1,
+ title='Mapped video', path='/same/remote.mkv', tmdbId=str(owner)))
+ schema_session.commit()
+ mappings = []
+
+ def mapped(path, owner, media_type):
+ assert (path, media_type) == ('/same/remote.mkv', 'movie')
+ mappings.append(owner)
+ return str(other if collision and owner == 8 else video)
+
+ monkeypatch.setattr(path_mappings, 'path_replace_instance', mapped)
+ index = SyncOutputOwnerIndex()
+ for _ in range(2):
+ assert sync_output_owner_is_unique(str(video), str(source), ownership_index=index) is (not collision)
+ assert sorted(mappings) == [7, 8]
+
+ # Standalone mutation checks must not inherit the earlier scan snapshot.
+ monkeypatch.setattr(path_mappings, 'path_replace_instance', lambda path, owner, kind: str(other if owner == 8 else video))
+ assert sync_output_owner_is_unique(str(video), str(source)) is False
+
+
+def test_scan_owner_index_fails_closed_after_incomplete_library_read(schema_session, monkeypatch, tmp_path):
+ from app import database as database_module
+ from app.config import settings
+ from subtitles.tools.subsync_engines import SyncOutputOwnerIndex, sync_output_owner_is_unique
+ from utilities.path_mappings import path_mappings
+
+ video = tmp_path / 'Video.mkv'
+ video.touch()
+ folder = tmp_path / 'subs'
+ folder.mkdir()
+ source = folder / 'Video.en.srt'
+ source.touch()
+ monkeypatch.setattr(settings.general, 'subfolder', 'relative')
+ monkeypatch.setattr(settings.general, 'subfolder_custom', 'subs')
+ monkeypatch.setattr(database_module, 'database', schema_session)
+ monkeypatch.setattr(path_mappings, 'path_replace_instance', lambda path, *args: path)
+ schema_session.add(TableShows(id=1, arr_instance_id=7, sonarrSeriesId=10, title='Show', path=str(tmp_path)))
+ schema_session.flush()
+ schema_session.add(TableEpisodes(id=1, arr_instance_id=7, series_id=1, sonarrSeriesId=10,
+ sonarrEpisodeId=1, title='Video', path=str(video), season=1, episode=1))
+ schema_session.commit()
+ execute = schema_session.execute
+ queries = []
+
+ def fail_movie_read(statement, *args, **kwargs):
+ queries.append(statement)
+ if list(statement.selected_columns)[0].table.name == 'table_movies':
+ raise RuntimeError('controlled owner lookup failure')
+ return execute(statement, *args, **kwargs)
+
+ monkeypatch.setattr(schema_session, 'execute', fail_movie_read)
+ index = SyncOutputOwnerIndex()
+ assert sync_output_owner_is_unique(str(video), str(source), ownership_index=index) is False
+ assert len(queries) == 2
+ monkeypatch.setattr(schema_session, 'execute', execute)
+ assert sync_output_owner_is_unique(str(video), str(source), ownership_index=index) is False
+ assert sync_output_owner_is_unique(str(video), str(source), ownership_index=SyncOutputOwnerIndex()) is True
+
+
def test_only_the_owning_episode_row_is_indexed(two_series_rows):
se, session = two_series_rows
diff --git a/tests/bazarr/test_openrouter_model_migration.py b/tests/bazarr/test_openrouter_model_migration.py
new file mode 100644
index 0000000000..5e951c8cc4
--- /dev/null
+++ b/tests/bazarr/test_openrouter_model_migration.py
@@ -0,0 +1,37 @@
+import logging
+from types import SimpleNamespace
+
+import pytest
+
+
+@pytest.mark.parametrize("retired,replacement", [
+ ("google/gemini-2.5-flash-preview-05-20", "google/gemini-2.5-flash"),
+ ("google/gemini-2.5-flash-lite-preview-06-17", "google/gemini-2.5-flash-lite"),
+ ("google/gemini-2.5-flash-lite-preview-09-2025", "google/gemini-2.5-flash-lite"),
+ ("google/gemini-3-pro-preview", "google/gemini-3.1-pro-preview"),
+ (" google/gemini-2.5-flash-preview-05-20 ", "google/gemini-2.5-flash"),
+])
+def test_migrate_retired_openrouter_model_rewrites_retired_id(retired, replacement, caplog):
+ from app import config
+
+ settings = SimpleNamespace(translator=SimpleNamespace(openrouter_model=retired))
+
+ with caplog.at_level(logging.WARNING):
+ assert config.migrate_retired_openrouter_model(settings) is True
+
+ assert settings.translator.openrouter_model == replacement
+ assert any(
+ record.levelno == logging.WARNING and retired.strip() in record.message and replacement in record.message
+ for record in caplog.records
+ )
+ assert config.migrate_retired_openrouter_model(settings) is False
+
+
+@pytest.mark.parametrize("model", ["google/gemini-2.5-flash-lite", "custom/model", " custom/model ", "", " "])
+def test_migrate_retired_openrouter_model_leaves_other_values_unchanged(model):
+ from app import config
+
+ settings = SimpleNamespace(translator=SimpleNamespace(openrouter_model=model))
+
+ assert config.migrate_retired_openrouter_model(settings) is False
+ assert settings.translator.openrouter_model == model
diff --git a/tests/bazarr/test_openrouter_provider_routing.py b/tests/bazarr/test_openrouter_provider_routing.py
new file mode 100644
index 0000000000..e8266b5ed2
--- /dev/null
+++ b/tests/bazarr/test_openrouter_provider_routing.py
@@ -0,0 +1,201 @@
+# coding=utf-8
+"""OpenRouter provider routing reaches the AI Subtitle Translator as ``config.provider``.
+
+The sidecar sorts OpenRouter providers by throughput unless it is told otherwise,
+so a user who wants the cheapest provider (OpenRouter's ``:floor``) or the
+priority tier (``:nitro``) needs a setting that Bazarr forwards on every request:
+the async translate job and the manual content endpoint alike.
+"""
+from types import SimpleNamespace
+
+import pytest
+from flask import Flask
+
+from app import config
+from subtitles.tools.translate.services import openrouter_translator
+
+ROUTING_VALUES = ['throughput', 'nitro', 'price', 'floor', 'latency', 'default']
+
+
+def _routing_validator():
+ return next(
+ v for v in config.validators
+ if v.names == ('translator.openrouter_provider_routing',)
+ )
+
+
+def test_setting_defaults_to_throughput_and_pins_the_allowed_values():
+ validator = _routing_validator()
+ assert validator.default == 'throughput'
+ assert list(validator.operations.get('is_in')) == ROUTING_VALUES
+ assert config.settings.translator.openrouter_provider_routing == 'throughput'
+
+
+def _sidecar_health(monkeypatch, version):
+ """Answer the sidecar's /health probe with the given version (None = unreachable)."""
+ openrouter_translator.reset_sidecar_version_cache()
+ calls = []
+
+ def _get(url, *args, **kwargs):
+ calls.append(url)
+ if version is None:
+ raise openrouter_translator.requests.exceptions.ConnectionError('down')
+ return SimpleNamespace(status_code=200, json=lambda: {'status': 'healthy', 'version': version})
+
+ monkeypatch.setattr(openrouter_translator.requests, 'get', _get)
+ return calls
+
+
+@pytest.mark.parametrize('value', ROUTING_VALUES)
+def test_build_provider_config_forwards_the_setting(monkeypatch, value):
+ _sidecar_health(monkeypatch, '1.3.4')
+ monkeypatch.setattr(openrouter_translator.settings.translator, 'openrouter_provider_routing', value)
+ assert openrouter_translator.build_provider_config() == {'sort': value}
+
+
+def test_build_provider_config_falls_back_to_throughput_for_unknown_values(monkeypatch):
+ _sidecar_health(monkeypatch, '1.3.4')
+ monkeypatch.setattr(openrouter_translator.settings.translator, 'openrouter_provider_routing', 'cheapest')
+ assert openrouter_translator.build_provider_config() == {'sort': 'throughput'}
+
+
+@pytest.mark.parametrize('value, expected', [
+ ('floor', 'price'),
+ ('nitro', 'throughput'),
+ ('default', 'throughput'),
+ ('price', 'price'),
+ ('latency', 'latency'),
+])
+def test_older_sidecars_get_the_plain_sort(monkeypatch, value, expected):
+ # Before 1.3.4 the sidecar forwards whatever it gets as provider.sort, and
+ # OpenRouter rejects nitro/floor/default there.
+ _sidecar_health(monkeypatch, '1.3.3')
+ monkeypatch.setattr(openrouter_translator.settings.translator, 'openrouter_provider_routing', value)
+ assert openrouter_translator.build_provider_config() == {'sort': expected}
+
+
+def test_unreachable_sidecar_gets_the_plain_sort(monkeypatch):
+ _sidecar_health(monkeypatch, None)
+ monkeypatch.setattr(openrouter_translator.settings.translator, 'openrouter_provider_routing', 'floor')
+ assert openrouter_translator.build_provider_config() == {'sort': 'price'}
+
+
+def test_sidecar_version_is_probed_once_per_url(monkeypatch):
+ calls = _sidecar_health(monkeypatch, '1.3.4')
+ monkeypatch.setattr(openrouter_translator.settings.translator, 'openrouter_url', 'http://sidecar:8765/')
+ monkeypatch.setattr(openrouter_translator.settings.translator, 'openrouter_provider_routing', 'floor')
+ assert openrouter_translator.build_provider_config() == {'sort': 'floor'}
+ assert openrouter_translator.build_provider_config() == {'sort': 'floor'}
+ assert calls == ['http://sidecar:8765/health']
+
+
+@pytest.mark.parametrize('version', ['1.3.3', '1.3.4', None])
+@pytest.mark.parametrize('suffix, setting, expected', [
+ ('floor', 'throughput', 'price'),
+ ('nitro', 'floor', 'throughput'),
+ ('floor', 'floor', 'price'),
+])
+def test_typed_routing_suffix_aligns_the_sort(monkeypatch, version, suffix, setting, expected):
+ # The slug says how to route; the sort Bazarr sends must never contradict it,
+ # whatever the setting says and whatever the sidecar version is.
+ _sidecar_health(monkeypatch, version)
+ monkeypatch.setattr(openrouter_translator.settings.translator, 'openrouter_model', f'deepseek/deepseek-v4-flash:{suffix}')
+ monkeypatch.setattr(openrouter_translator.settings.translator, 'openrouter_provider_routing', setting)
+ assert openrouter_translator.build_provider_config() == {'sort': expected}
+
+
+def test_other_model_variants_do_not_touch_the_sort(monkeypatch):
+ _sidecar_health(monkeypatch, '1.3.4')
+ monkeypatch.setattr(openrouter_translator.settings.translator, 'openrouter_model', 'deepseek/deepseek-chat:thinking')
+ monkeypatch.setattr(openrouter_translator.settings.translator, 'openrouter_provider_routing', 'floor')
+ assert openrouter_translator.build_provider_config() == {'sort': 'floor'}
+
+
+@pytest.mark.parametrize('version', ['1.3.4', '1.4.0', '2.0.0', '1.3.10', '1.3.4-rc1'])
+def test_versions_from_1_3_4_support_the_shortcuts(monkeypatch, version):
+ _sidecar_health(monkeypatch, version)
+ monkeypatch.setattr(openrouter_translator.settings.translator, 'openrouter_provider_routing', 'nitro')
+ assert openrouter_translator.build_provider_config() == {'sort': 'nitro'}
+
+
+def _build_service():
+ return openrouter_translator.OpenRouterTranslatorService(
+ source_srt_file='input.srt',
+ dest_srt_file='output.srt',
+ lang_obj=None,
+ to_lang='hun',
+ from_lang='en',
+ media_type='movie',
+ video_path='/tmp/video.mkv',
+ orig_to_lang='hu',
+ forced=False,
+ hi=False,
+ sonarr_series_id=None,
+ sonarr_episode_id=None,
+ radarr_id=7,
+ )
+
+
+def _translator_settings(monkeypatch, routing):
+ # Every key below exists in the settings box already (the validators give them
+ # defaults), so a plain setattr restores cleanly. Never patch a settings box with
+ # create=True: the restore deletes the key and later tests lose it.
+ for key, value in {
+ 'openrouter_url': 'http://sidecar:8765',
+ 'openrouter_api_key': 'sk-or-key',
+ 'openrouter_encryption_key': '',
+ 'openrouter_model': 'deepseek/deepseek-v4-flash',
+ 'openrouter_temperature': 0.3,
+ 'openrouter_max_concurrent': 2,
+ 'openrouter_parallel_batches': 4,
+ 'openrouter_reasoning': 'disabled',
+ 'openrouter_provider_routing': routing,
+ }.items():
+ monkeypatch.setattr(openrouter_translator.settings.translator, key, value)
+
+
+def test_translate_job_sends_the_routing_in_the_config(mocker, monkeypatch):
+ _translator_settings(monkeypatch, 'floor')
+ _sidecar_health(monkeypatch, '1.3.4')
+ mocker.patch.object(openrouter_translator, 'get_title', return_value='Some Movie')
+ mocker.patch.object(openrouter_translator, 'language_from_alpha2', lambda code: code)
+ mocker.patch.object(openrouter_translator, 'language_from_alpha3', lambda code: code)
+ mocker.patch.object(openrouter_translator, 'get_translator_auth_headers', return_value={})
+ post = mocker.patch.object(
+ openrouter_translator.requests,
+ 'post',
+ return_value=SimpleNamespace(status_code=200, json=lambda: {'jobId': 'job-1'}),
+ )
+ service = _build_service()
+ mocker.patch.object(service, '_poll_job', return_value=[{'index': 0, 'content': 'Szia'}])
+
+ result = service._submit_and_poll(['Hi'])
+
+ assert result == [{'index': 0, 'content': 'Szia'}]
+ payload = post.call_args.kwargs['json']
+ assert payload['config']['provider'] == {'sort': 'floor'}
+ assert payload['config']['model'] == 'deepseek/deepseek-v4-flash'
+
+
+def test_content_endpoint_sends_the_routing_in_the_config(mocker, monkeypatch):
+ from api.translator import translator as api_mod
+
+ _translator_settings(monkeypatch, 'nitro')
+ _sidecar_health(monkeypatch, '1.3.4')
+ mocker.patch.object(api_mod, 'get_translator_auth_headers', return_value={})
+ post = mocker.patch.object(
+ api_mod.requests,
+ 'post',
+ return_value=SimpleNamespace(status_code=200, json=lambda: {'jobId': 'job-2'}),
+ )
+
+ app = Flask(__name__)
+ with app.test_request_context(
+ '/api/translator/jobs', method='POST', json={'lines': ['Hi'], 'targetLanguage': 'hu'}
+ ):
+ body, status = api_mod.TranslatorJobs.post.__wrapped__(api_mod.TranslatorJobs())
+
+ assert status == 200
+ assert body == {'jobId': 'job-2'}
+ payload = post.call_args.kwargs['json']
+ assert payload['config']['provider'] == {'sort': 'nitro'}
diff --git a/tests/bazarr/test_openrouter_translator.py b/tests/bazarr/test_openrouter_translator.py
new file mode 100644
index 0000000000..ba5ea751a4
--- /dev/null
+++ b/tests/bazarr/test_openrouter_translator.py
@@ -0,0 +1,245 @@
+from pathlib import Path
+from types import SimpleNamespace
+
+import pysubs2
+import pytest
+
+from subtitles.tools.translate.services import openrouter_translator as module
+
+
+@pytest.fixture
+def service(tmp_path, monkeypatch):
+ source = tmp_path / 'source.en.srt'
+ source.write_text('1\n00:00:01,000 --> 00:00:02,000\nOne\n\n'
+ '2\n00:00:03,000 --> 00:00:04,000\nTwo\n\n'
+ '3\n00:00:05,000 --> 00:00:06,000\nThree\n', encoding='utf-8')
+ monkeypatch.setattr(module.settings.translator, 'translator_info', False)
+ monkeypatch.setattr(module, 'get_title', lambda **kwargs: 'Example')
+ monkeypatch.setattr(module, 'get_translator_auth_headers', lambda: {})
+ monkeypatch.setattr(module, 'language_from_alpha2', lambda code: {'en': 'English', 'hu': 'Hungarian'}[code])
+ monkeypatch.setattr(module, 'language_from_alpha3', lambda code: 'Hungarian')
+ monkeypatch.setattr(module.requests, 'post', lambda *args, **kwargs: SimpleNamespace(
+ status_code=200, json=lambda: {'jobId': 'fixture-job'}))
+ monkeypatch.setattr(module, 'show_progress', lambda **kwargs: None)
+ monkeypatch.setattr(module, 'hide_progress', lambda **kwargs: None)
+ monkeypatch.setattr(module.jobs_queue, 'update_job_progress', lambda **kwargs: None)
+ translator = module.OpenRouterTranslatorService(
+ source_srt_file=str(source), dest_srt_file=str(tmp_path / 'output.hu.srt'),
+ lang_obj=None, to_lang='hun', from_lang='en', media_type='episode',
+ video_path=str(tmp_path / 'video.mkv'), orig_to_lang='hu', forced=False, hi=False,
+ sonarr_series_id=1, sonarr_episode_id=2, radarr_id=None,
+ )
+ monkeypatch.setattr(translator, '_get_api_key_value', lambda: '')
+ return translator
+
+
+@pytest.fixture
+def events(monkeypatch):
+ captured = SimpleNamespace(messages=[], history=[])
+ monkeypatch.setattr(module, 'show_message', captured.messages.append)
+ monkeypatch.setattr(module, 'history_log', lambda **kwargs: captured.history.append(kwargs))
+ monkeypatch.setattr(module, 'history_log_movie', lambda **kwargs: captured.history.append(kwargs))
+ return captured
+
+
+def _response(monkeypatch, status, result=None, **fields):
+ payload = {'status': status, 'result': result, **fields}
+ monkeypatch.setattr(module.requests, 'get', lambda *args, **kwargs: SimpleNamespace(
+ status_code=200, json=lambda: payload))
+
+
+@pytest.mark.parametrize('structured', [True, False])
+@pytest.mark.parametrize('status', ['partial', 'completed'])
+def test_poll_preserves_usable_lines(service, events, monkeypatch, status, structured):
+ lines = [{'position': 2, 'line': 'Három'}, {'position': 0, 'line': 'Egy'}]
+ _response(monkeypatch, status, {'lines': lines} if structured else lines,
+ error='One batch failed')
+
+ assert service._poll_job('http://fixture', 'job', 3) == lines
+ if status == 'partial':
+ assert any('partial' in message.lower() for message in events.messages)
+
+
+@pytest.mark.parametrize('status', ['partial', 'completed'])
+@pytest.mark.parametrize('result', [None, [], {}, {'lines': []}, {'lines': None},
+ {'lines': 'invalid'}, 'invalid'])
+def test_poll_rejects_missing_or_empty_lines(service, events, monkeypatch, status, result):
+ _response(monkeypatch, status, result)
+ assert service._poll_job('http://fixture', 'job', 3) is None
+
+
+@pytest.mark.parametrize('status', ['failed', 'cancelled'])
+def test_poll_does_not_return_failed_output(service, events, monkeypatch, status):
+ _response(monkeypatch, status, [{'position': 0, 'line': 'Egy'}], error='Unavailable')
+ assert service._poll_job('http://fixture', 'job', 3) is None
+
+
+@pytest.mark.parametrize('media_type', ['episode', 'movie'])
+def test_partial_translation_writes_ordered_cues_and_records_warning(service, events, monkeypatch, media_type):
+ service.media_type = media_type
+ service.radarr_id = 3 if media_type == 'movie' else None
+ source = Path(service.source_srt_file).read_bytes()
+ _response(monkeypatch, 'partial', {'lines': [
+ {'position': 2, 'line': 'Három'}, {'position': 0, 'line': 'Egy\nMásik'},
+ ]}, error='One batch failed: malformed response')
+
+ assert service.translate(job_id='bazarr-job') == service.dest_srt_file
+
+ output = pysubs2.load(service.dest_srt_file)
+ assert [cue.plaintext for cue in output] == ['Egy\nMásik', 'Two', 'Három']
+ assert [(cue.start, cue.end) for cue in output] == [(1000, 2000), (3000, 4000), (5000, 6000)]
+ assert Path(service.source_srt_file).read_bytes() == source
+ assert len(events.history) == 1
+ message = events.history[0]['result'].message
+ assert 'partial' in message.lower()
+ assert 'source language' in message.lower()
+ assert 'malformed response' in message
+ assert any('partial' in message.lower() for message in events.messages)
+
+
+@pytest.mark.parametrize('lines', [
+ [], [{'position': 0}], [{'position': -1, 'line': 'Invalid'}],
+ [{'position': 3, 'line': 'Invalid'}], [{'position': True, 'line': 'Invalid'}],
+ [{'position': '0', 'line': 'Invalid'}], [{'position': 0, 'line': None}],
+ [{'position': 0, 'line': ''}], [{'position': 0, 'line': ' '}],
+ [{'position': 0, 'line': 'Valid'}, {'position': 0, 'line': 'Duplicate'}],
+ [{'position': 0, 'line': 'Valid'}, {'position': 1, 'line': ['Invalid']}],
+])
+@pytest.mark.parametrize('status', ['partial', 'completed'])
+def test_invalid_results_do_not_overwrite_files(service, events, monkeypatch, status, lines):
+ destination = Path(service.dest_srt_file)
+ destination.write_bytes(b'existing subtitle')
+ source = Path(service.source_srt_file).read_bytes()
+ _response(monkeypatch, status, {'lines': lines})
+
+ assert service.translate() is False
+
+ assert destination.read_bytes() == b'existing subtitle'
+ assert Path(service.source_srt_file).read_bytes() == source
+ assert events.history == []
+
+
+def test_partial_detail_is_bounded_and_cleared_for_next_operation(service, events, monkeypatch):
+ lines = [{'position': 0, 'line': 'Egy'}]
+ _response(monkeypatch, 'partial', lines, error='Failure detail ' + 'x' * 2000)
+ assert service.translate() == service.dest_srt_file
+ assert len(events.history[-1]['result'].message) < 1000
+
+ complete_lines = [{'position': i, 'line': line} for i, line in enumerate(['Egy', 'Kettő', 'Három'])]
+ _response(monkeypatch, 'completed', complete_lines)
+ assert service.translate() == service.dest_srt_file
+ assert 'partial' not in events.history[-1]['result'].message.lower()
+ assert not service.partial_error
+
+ _response(monkeypatch, 'partial', lines, error='Failure detail')
+ assert service.translate() == service.dest_srt_file
+ _response(monkeypatch, 'failed', error='Unavailable')
+ assert service.translate() is False
+ assert not service.partial_error
+
+
+def test_partial_without_error_detail_still_marks_the_saved_output(service, events, monkeypatch):
+ monkeypatch.setattr(module.settings.translator, 'translator_info', True)
+ _response(monkeypatch, 'partial', [{'position': 0, 'line': 'Egy'}], error=' ')
+
+ assert service.translate() == service.dest_srt_file
+ assert 'partially translated' in pysubs2.load(service.dest_srt_file)[-1].plaintext.lower()
+ assert 'partial' in events.history[-1]['result'].message.lower()
+
+
+def test_empty_source_does_not_report_a_saved_translation(service, events):
+ Path(service.source_srt_file).write_text('', encoding='utf-8')
+ assert service.translate() is False
+ assert not Path(service.dest_srt_file).exists()
+ assert events.history == []
+
+
+@pytest.mark.parametrize('valid', [True, False])
+def test_sync_fallback_uses_the_same_result_validation(service, events, monkeypatch, valid):
+ lines = [{'position': 0, 'line': 'Egy'}, {'position': 1, 'line': ''}]
+ if not valid:
+ lines[0]['position'] = 9
+ responses = iter([
+ SimpleNamespace(status_code=404),
+ SimpleNamespace(status_code=200, json=lambda: lines),
+ ])
+ monkeypatch.setattr(module.requests, 'post', lambda *args, **kwargs: next(responses))
+
+ result = service.translate()
+ if valid:
+ assert result == service.dest_srt_file
+ assert [cue.plaintext for cue in pysubs2.load(result)] == ['Egy', 'Two', 'Three']
+ assert 'partial' in events.history[-1]['result'].message.lower()
+ else:
+ assert result is False
+ assert not Path(service.dest_srt_file).exists()
+ assert events.history == []
+
+
+@pytest.mark.parametrize('status', ['partial', 'completed'])
+def test_save_failure_preserves_destination_and_cleans_temporary_file(service, events, monkeypatch, status):
+ destination = Path(service.dest_srt_file)
+ destination.write_bytes(b'existing subtitle')
+ before = set(destination.parent.iterdir())
+ _response(monkeypatch, status, [{'position': 0, 'line': 'Egy'}])
+
+ def fail_save(subtitles, filename, *args, **kwargs):
+ Path(filename).write_bytes(b'incomplete write')
+ raise OSError('write failed')
+
+ monkeypatch.setattr(pysubs2.SSAFile, 'save', fail_save)
+
+ assert service.translate() is False
+ assert destination.read_bytes() == b'existing subtitle'
+ assert set(destination.parent.iterdir()) == before
+ assert events.history == []
+
+
+@pytest.mark.parametrize('synchronous', [False, True])
+def test_missing_or_blank_cues_are_reported_as_partial(service, events, monkeypatch, synchronous):
+ lines = [{'position': 0, 'line': 'Egy'}, {'position': 1, 'line': ' '}]
+ monkeypatch.setattr(module.settings.translator, 'translator_info', True)
+ if synchronous:
+ responses = iter([SimpleNamespace(status_code=404),
+ SimpleNamespace(status_code=200, json=lambda: lines)])
+ monkeypatch.setattr(module.requests, 'post', lambda *args, **kwargs: next(responses))
+ else:
+ _response(monkeypatch, 'completed', {'lines': lines})
+
+ assert service.translate() == service.dest_srt_file
+ output = pysubs2.load(service.dest_srt_file)
+ assert [cue.plaintext for cue in output[:3]] == ['Egy', 'Two', 'Three']
+ assert 'partially translated' in output[-1].plaintext.lower()
+ assert 'partial' in events.history[-1]['result'].message.lower()
+ assert any('partial' in message.lower() for message in events.messages)
+
+
+def test_long_destination_filename_retains_atomic_saving_and_permissions(service, events, monkeypatch):
+ destination = Path(service.dest_srt_file).with_name('x' * 220 + '.hu.srt')
+ destination.write_bytes(b'existing subtitle')
+ destination.chmod(0o640)
+ service.dest_srt_file = str(destination)
+ before = set(destination.parent.iterdir())
+ lines = [{'position': i, 'line': line} for i, line in enumerate(['Egy', 'Kettő', 'Három'])]
+ _response(monkeypatch, 'completed', lines)
+
+ assert service.translate() == str(destination)
+ assert [cue.plaintext for cue in pysubs2.load(destination)] == ['Egy', 'Kettő', 'Három']
+ assert destination.stat().st_mode & 0o777 == 0o640
+ assert set(destination.parent.iterdir()) == before
+ assert 'partial' not in events.history[-1]['result'].message.lower()
+
+
+def test_existing_staging_file_is_never_overwritten_or_removed(service, events, monkeypatch):
+ destination = Path(service.dest_srt_file)
+ destination.write_bytes(b'existing subtitle')
+ staging = destination.with_name('.bazarr-write-fixture-collision.srt')
+ staging.write_bytes(b'other operation')
+ from subtitles.tools import subsync_engines
+ monkeypatch.setattr(subsync_engines.uuid, 'uuid4', lambda: SimpleNamespace(hex='fixture-collision'))
+ _response(monkeypatch, 'completed', [{'position': 0, 'line': 'Egy'}])
+
+ assert service.translate() is False
+ assert staging.read_bytes() == b'other operation'
+ assert destination.read_bytes() == b'existing subtitle'
+ assert not events.history
diff --git a/tests/bazarr/test_openrouter_translator_partial.py b/tests/bazarr/test_openrouter_translator_partial.py
new file mode 100644
index 0000000000..a720fa5491
--- /dev/null
+++ b/tests/bazarr/test_openrouter_translator_partial.py
@@ -0,0 +1,250 @@
+import logging
+from pathlib import Path
+
+import pytest
+
+from subtitles.tools.translate.services import openrouter_translator
+
+
+def _build_service(source_srt_file="input.srt", dest_srt_file="output.srt", media_type="episode"):
+ return openrouter_translator.OpenRouterTranslatorService(
+ source_srt_file=source_srt_file,
+ dest_srt_file=dest_srt_file,
+ lang_obj=None,
+ to_lang="hun",
+ from_lang="en",
+ media_type=media_type,
+ video_path="/tmp/video.mkv",
+ orig_to_lang="hu",
+ forced=False,
+ hi=False,
+ sonarr_series_id=1,
+ sonarr_episode_id=2,
+ radarr_id=3,
+ )
+
+
+@pytest.fixture(autouse=True)
+def _mock_dependencies(mocker):
+ mocker.patch.object(openrouter_translator.requests, "get", return_value=mocker.Mock(status_code=200))
+ mocker.patch.object(openrouter_translator.time, "sleep")
+ for name in (
+ "show_progress", "hide_progress", "show_message", "jobs_queue", "history_log", "history_log_movie",
+ "add_translator_info", "create_process_result",
+ ):
+ mocker.patch.object(openrouter_translator, name)
+
+
+@pytest.mark.parametrize("structured", [True, False])
+def test_poll_job_keeps_partial_lines_and_bounded_error(structured, caplog):
+ service = _build_service()
+ lines = [{"position": 0, "line": "Szia"}, {"position": 1, "line": "Source text"}]
+ error = "1 of 58 batches failed: " + "Failed to parse JSON. " * 100
+ detail = error.strip()[:500]
+ result = {"lines": lines, "model_used": "google/gemini-2.5-flash-lite", "tokens_used": 100} if structured else lines
+ openrouter_translator.requests.get.return_value.json.return_value = {
+ "status": "partial", "result": result, "error": error,
+ }
+
+ with caplog.at_level(logging.WARNING, logger=openrouter_translator.__name__):
+ assert service._poll_job("http://translator", "job-1", 2, bazarr_job_id="bazarr-job-1") == lines
+
+ assert service.partial_error == detail
+ openrouter_translator.hide_progress.assert_called_once_with(id="translate_progress_output.srt")
+ openrouter_translator.show_message.assert_called_once_with(
+ f"Translation is partial. Some lines may remain in the source language. {detail}"
+ )
+ assert (openrouter_translator.__name__, logging.WARNING,
+ f"Translation partially completed: {detail}") in caplog.record_tuples
+ openrouter_translator.time.sleep.assert_not_called()
+
+
+@pytest.mark.parametrize("result", [None, {}, [], {"lines": []}, {"lines": "invalid"}, "invalid", 42])
+def test_poll_job_rejects_partial_without_lines(result, caplog):
+ service = _build_service()
+ error = "No lines translated"
+ openrouter_translator.requests.get.return_value.json.return_value = {
+ "status": "partial", "result": result, "error": error,
+ }
+
+ assert service._poll_job("http://translator", "job-1", 1) is None
+ openrouter_translator.hide_progress.assert_called_once_with(id="translate_progress_output.srt")
+ openrouter_translator.show_message.assert_called_once_with(f"Translation failed (partial): {error}")
+ assert (openrouter_translator.__name__, logging.ERROR,
+ f"Translation partially failed: {error}") in caplog.record_tuples
+
+
+@pytest.mark.parametrize("structured", [True, False])
+def test_poll_job_returns_completed_lines(structured):
+ service = _build_service()
+ lines = [{"position": 0, "line": "Szia"}]
+ result = {"lines": lines, "model_used": "google/gemini-2.5-flash-lite", "tokens_used": 100} if structured else lines
+ openrouter_translator.requests.get.return_value.json.return_value = {"status": "completed", "result": result}
+
+ assert service._poll_job("http://translator", "job-1", 1) == lines
+ assert service.partial_error is None
+ openrouter_translator.hide_progress.assert_called_once_with(id="translate_progress_output.srt")
+ openrouter_translator.show_message.assert_not_called()
+
+
+@pytest.mark.parametrize("result", [None, [], {"lines": []}, {"lines": "invalid"}, {"model_used": "model"}, "invalid", 42])
+def test_poll_job_rejects_completed_without_lines(result):
+ service = _build_service()
+ openrouter_translator.requests.get.return_value.json.return_value = {"status": "completed", "result": result}
+
+ assert service._poll_job("http://translator", "job-1", 1) is None
+
+
+@pytest.mark.parametrize("media_type", ["episode", "movie"])
+def test_translate_saves_partial_subtitles_and_marks_history(tmp_path, mocker, media_type):
+ source = tmp_path / "input.srt"
+ destination = tmp_path / "output.srt"
+ source.write_text(
+ "1\n00:00:00,000 --> 00:00:02,000\nHello\n\n"
+ "2\n00:00:03,000 --> 00:00:05,000\nSource text\n\n",
+ encoding="utf-8",
+ )
+ service = _build_service(str(source), str(destination), media_type)
+ error = "1 of 2 batches failed: " + "Failed to parse JSON. " * 15
+
+ def _partial_result(lines_list, bazarr_job_id=None):
+ assert lines_list == ["Hello", "Source text"]
+ assert bazarr_job_id == "bazarr-job-1"
+ service._mark_partial(error)
+ return [{"position": 0, "line": "Szia"}, {"position": 1, "line": "Source text"}]
+
+ mocker.patch.object(service, "_submit_and_poll", side_effect=_partial_result)
+ mocker.patch.object(openrouter_translator, "language_from_alpha2", return_value="English")
+ mocker.patch.object(openrouter_translator, "language_from_alpha3", return_value="Hungarian")
+
+ assert service.translate(job_id="bazarr-job-1") == str(destination)
+ assert destination.read_text(encoding="utf-8") == (
+ "1\n00:00:00,000 --> 00:00:02,000\nSzia\n\n"
+ "2\n00:00:03,000 --> 00:00:05,000\nSource text\n\n"
+ )
+ openrouter_translator.create_process_result.assert_called_once()
+ history_message = openrouter_translator.create_process_result.call_args.args[0]
+ assert "partially translated" in history_message
+ assert history_message.endswith(error.strip()[:500])
+ openrouter_translator.add_translator_info.assert_called_once()
+ staged, footer = openrouter_translator.add_translator_info.call_args.args
+ assert Path(staged).parent == destination.parent
+ assert Path(staged).name.startswith(".bazarr-write-")
+ assert footer == "# Subtitles partially translated with AI Subtitle Translator #"
+ result = openrouter_translator.create_process_result.return_value
+ if media_type == "episode":
+ openrouter_translator.history_log.assert_called_once_with(
+ action=6, sonarr_series_id=1, sonarr_episode_id=2, result=result,
+ )
+ openrouter_translator.history_log_movie.assert_not_called()
+ else:
+ openrouter_translator.history_log_movie.assert_called_once_with(action=6, radarr_id=3, result=result)
+ openrouter_translator.history_log.assert_not_called()
+
+
+class _FakeClock:
+ def __init__(self):
+ self.elapsed = 0
+
+ def monotonic(self):
+ return 1000 + self.elapsed
+
+ def advance(self, seconds):
+ self.elapsed += seconds
+
+
+@pytest.fixture
+def poll_clock(mocker, _mock_dependencies):
+ clock = _FakeClock()
+ mocker.patch.object(openrouter_translator.time, "monotonic", side_effect=clock.monotonic)
+ openrouter_translator.time.sleep.side_effect = clock.advance
+ return clock
+
+
+@pytest.mark.parametrize("status", ["processing", "queued"])
+def test_poll_job_completes_after_more_than_thirty_minutes(poll_clock, mocker, status):
+ service = _build_service()
+ lines = [{"position": 0, "line": "Szia"}]
+ response = mocker.Mock(status_code=200)
+
+ def _get_status(*args, **kwargs):
+ if poll_clock.elapsed < 40 * 60:
+ response.json.return_value = {"status": status}
+ else:
+ response.json.return_value = {"status": "completed", "result": {"lines": lines}}
+ return response
+
+ openrouter_translator.requests.get.side_effect = _get_status
+
+ assert service._poll_job("http://translator", "job-1", 1) == lines
+ assert poll_clock.elapsed == 40 * 60
+ openrouter_translator.hide_progress.assert_called_once_with(id="translate_progress_output.srt")
+ openrouter_translator.show_message.assert_not_called()
+
+
+@pytest.mark.parametrize("failure", ["http_500", "request_exception"])
+def test_poll_job_stops_when_status_endpoint_is_unreachable(poll_clock, mocker, caplog, failure):
+ service = _build_service()
+ response = mocker.Mock(status_code=500)
+
+ def _get_status(*args, **kwargs):
+ poll_clock.advance(8)
+ if failure == "request_exception":
+ raise openrouter_translator.requests.exceptions.RequestException("Service unavailable")
+ return response
+
+ openrouter_translator.requests.get.side_effect = _get_status
+
+ assert service._poll_job("http://translator", "job-1", 1) is None
+ assert poll_clock.elapsed == 10 * 60
+ openrouter_translator.hide_progress.assert_called_once_with(id="translate_progress_output.srt")
+ openrouter_translator.show_message.assert_called_once()
+ assert any(
+ record.levelno == logging.ERROR
+ and "job-1" in record.message
+ and "unreachable for 10 minutes" in record.message
+ for record in caplog.records
+ )
+
+
+@pytest.mark.parametrize("failure", ["http_500", "request_exception"])
+def test_poll_job_resets_unreachable_clock_after_http_200(poll_clock, mocker, failure):
+ service = _build_service()
+ lines = [{"position": 0, "line": "Szia"}]
+ response = mocker.Mock(status_code=200)
+ failed_response = mocker.Mock(status_code=500)
+
+ def _get_status(*args, **kwargs):
+ if poll_clock.elapsed == 8 * 60:
+ response.json.return_value = {"status": "processing"}
+ return response
+ if poll_clock.elapsed >= 16 * 60:
+ response.json.return_value = {"status": "completed", "result": {"lines": lines}}
+ return response
+ if failure == "request_exception":
+ raise openrouter_translator.requests.exceptions.RequestException("Service unavailable")
+ return failed_response
+
+ openrouter_translator.requests.get.side_effect = _get_status
+
+ assert service._poll_job("http://translator", "job-1", 1) == lines
+ assert poll_clock.elapsed == 16 * 60
+ openrouter_translator.hide_progress.assert_called_once_with(id="translate_progress_output.srt")
+ openrouter_translator.show_message.assert_not_called()
+
+
+def test_poll_job_stops_at_twelve_hour_hard_cap(poll_clock, caplog):
+ service = _build_service()
+ openrouter_translator.requests.get.return_value.json.return_value = {"status": "processing"}
+ openrouter_translator.time.sleep.side_effect = lambda seconds: poll_clock.advance(5 * 60)
+
+ assert service._poll_job("http://translator", "job-1", 1) is None
+ assert poll_clock.elapsed == 12 * 3600
+ openrouter_translator.hide_progress.assert_called_once_with(id="translate_progress_output.srt")
+ openrouter_translator.show_message.assert_called_once()
+ assert any(
+ record.levelno == logging.ERROR
+ and "job-1" in record.message
+ and "hard cap" in record.message
+ for record in caplog.records
+ )
diff --git a/tests/bazarr/test_provider_hub.py b/tests/bazarr/test_provider_hub.py
index 945d8470ad..8c41173ba8 100644
--- a/tests/bazarr/test_provider_hub.py
+++ b/tests/bazarr/test_provider_hub.py
@@ -445,6 +445,7 @@ def test_worker_download_auto_selects_single_archive_member():
def test_worker_download_rejects_missing_member_and_bad_archive():
from provider_hub.protocol import WorkerProtocolError, worker_download_to_content
+ from subliminal_patch.exceptions import SubtitleCandidateRejected
candidate = _hub_candidate("sub-bad")
buffer = io.BytesIO()
@@ -452,7 +453,7 @@ def test_worker_download_rejects_missing_member_and_bad_archive():
archive.writestr("Show.S01E01.srt", b"1\n00:00:01,000 --> 00:00:02,000\nHi\n")
archive_bytes = buffer.getvalue()
- with pytest.raises(WorkerProtocolError):
+ with pytest.raises(SubtitleCandidateRejected, match="Pinned subtitle member is absent"):
worker_download_to_content(
candidate,
{
diff --git a/tests/bazarr/test_provider_hub_archive_candidates.py b/tests/bazarr/test_provider_hub_archive_candidates.py
new file mode 100644
index 0000000000..84a30c01d4
--- /dev/null
+++ b/tests/bazarr/test_provider_hub_archive_candidates.py
@@ -0,0 +1,922 @@
+"""Archive mismatch rejects one download without disabling its provider."""
+import base64
+import hashlib
+import io
+import logging
+import stat
+from types import SimpleNamespace
+import zipfile
+
+import pytest
+from subzero.language import Language
+
+from provider_hub import protocol, registry, worker_runner
+from subliminal_patch import core, core_persistent
+from subliminal_patch.providers.utils import get_archive_from_bytes, get_subtitle_from_archive
+
+
+SRT = b"1\n00:00:01,000 --> 00:00:02,000\nFixture\n"
+
+
+def archive_payload(names, **extra):
+ buffer = io.BytesIO()
+ with zipfile.ZipFile(buffer, "w") as archive:
+ members = names.items() if isinstance(names, dict) else ((name, SRT) for name in names)
+ for name, content in members:
+ archive.writestr(name, content)
+ body = buffer.getvalue()
+ return {"archive_b64": base64.b64encode(body).decode("ascii"),
+ "archive_sha256": hashlib.sha256(body).hexdigest(), "episode": 1, **extra}
+
+
+def formatted_archive_payload(kind, members, **extra):
+ if kind == "zip":
+ return archive_payload(members, **extra)
+ buffer = io.BytesIO()
+ if kind == "rar":
+ import struct
+ import zlib
+
+ def block(block_type, flags, body):
+ header = struct.pack("
00:00:02,000\nx\n"
@@ -85,7 +89,7 @@ def test_select_member_pin_unknown_member_raises():
def test_select_member_reject_raises():
body = _zip(["show.eng.srt", "show.fre.srt"])
- with pytest.raises(proto.WorkerProtocolError):
+ with pytest.raises(SubtitleCandidateRejected, match="No matching subtitle language"):
_run(body, _archive_payload(body, select_member=True),
lambda members: {"member": None, "decision": "reject"})
@@ -134,25 +138,254 @@ def select_archive_member(self, provider_payload, language, members, config):
assert seen["payload"]["url"] == "x"
+@pytest.mark.parametrize("context,expected", [
+ ({}, {"season": 99, "episode": 99}),
+ ({"season": None}, {"season": None, "episode": 99}),
+ ({"episode": None}, {"season": 99, "episode": None}),
+ ({"season": None, "episode": None}, {"season": None, "episode": None}),
+ ({"season": 3}, {"season": 3, "episode": 99}),
+ ({"episode": 1}, {"season": 99, "episode": 1}),
+ ({"season": 3, "episode": None}, {"season": 3, "episode": None}),
+ ({"season": None, "episode": 1}, {"season": None, "episode": 1}),
+ ({"season": 3, "episode": 1}, {"season": 3, "episode": 1}),
+])
+def test_selector_context_distinguishes_absent_and_null_without_mutating_payload(context, expected):
+ from provider_hub import worker_runner
+
+ opaque = {"season": 99, "episode": 99, "id": "stored-candidate"}
+
+ class Provider:
+ def select_archive_member(self, provider_payload, **kwargs):
+ assert provider_payload == {**expected, "id": "stored-candidate"}
+ provider_payload["id"] = "selector-local"
+ return {"decision": "defer"}
+
+ result = worker_runner._handle(Provider(), "select_archive_member", {
+ "provider_payload": opaque, **context,
+ })
+
+ assert result == {"decision": "defer", "member": None}
+ assert opaque == {"season": 99, "episode": 99, "id": "stored-candidate"}
+
+
+@pytest.mark.parametrize("context,expected", [({}, 99), ({"absolute_episode": None}, None),
+ ({"absolute_episode": 0}, 0), ({"absolute_episode": 49}, 49)])
+def test_selector_absolute_context_preserves_presence_and_payload_copy(context, expected):
+ from provider_hub import worker_runner
+
+ opaque = {"absolute_episode": 99, "id": "stored-candidate"}
+
+ class Provider:
+ def select_archive_member(self, provider_payload, **kwargs):
+ assert provider_payload["absolute_episode"] == expected
+ provider_payload["absolute_episode"] = 50
+ return {"decision": "defer"}
+
+ assert worker_runner._handle(Provider(), "select_archive_member", {
+ "provider_payload": opaque, **context,
+ }) == {"decision": "defer", "member": None}
+ assert opaque == {"absolute_episode": 99, "id": "stored-candidate"}
+
+
+@pytest.fixture
+def selector_worker(tmp_path):
+ from provider_hub.worker import ProviderWorkerClient, worker_command
+
+ # The bundle uses only stdlib and the actual isolated worker entry point.
+ (tmp_path / "provider.py").write_text('''
+class Provider:
+ def search(self, video, languages, config):
+ return [{
+ "id": "fixture", "language": languages[0],
+ "provider_payload": {"archive": config["archive"], **config["opaque"]},
+ "display": {"season": 99, "episode": 99},
+ }]
+
+ def download(self, provider_payload, language, config):
+ return provider_payload["archive"]
+
+ def select_archive_member(self, provider_payload, language, members, config):
+ if config.get("absolute_selector"):
+ number = provider_payload.get("absolute_episode")
+ if number is None:
+ number = provider_payload.get("episode")
+ member = str(number) + ".en.srt"
+ if member not in members:
+ return {"decision": "reject"}
+ decision = config["decision"]
+ return {"decision": decision, "member": member if decision == "pin" else None}
+ # A provider may use these fields to accept, pin or defer an archive.
+ # Incorrect context must be observable even when the host would defer.
+ context = {key: provider_payload.get(key) for key in ("season", "episode")}
+ if context != config["requested"]:
+ return {"decision": "pin", "member": "Stale.S99E99.srt"}
+ decision = config["decision"]
+ return {"decision": decision, "member": members[0] if decision == "pin" else None}
+''', encoding="utf-8")
+ runner = Path(__file__).parents[2] / "bazarr" / "provider_hub" / "worker_runner.py"
+ client = ProviderWorkerClient(
+ worker_command(sys.executable, runner), cwd=tmp_path,
+ env={"BAZARR_PROVIDER_HUB_BUNDLE": str(tmp_path),
+ "BAZARR_PROVIDER_HUB_MANIFEST": json.dumps({"entry_module": "provider", "entry_class": "Provider"})},
+ )
+ try:
+ yield client
+ finally:
+ process = client.process
+ client.stop()
+ if process is not None:
+ assert process.poll() is not None
+
+
+@pytest.mark.parametrize("context,expected", [
+ ({}, {"season": 99, "episode": 99}),
+ ({"season": None}, {"season": None, "episode": 99}),
+ ({"episode": None}, {"season": 99, "episode": None}),
+])
+def test_real_worker_preserves_legacy_context_only_for_absent_keys(selector_worker, context, expected):
+ response = selector_worker.select_archive_member({
+ "provider_payload": {"season": 99, "episode": 99},
+ "members": ["Requested.srt", "Stale.S99E99.srt"],
+ "config": {"requested": expected, "decision": "pin"},
+ **context,
+ }, timeout=5)
+ assert response.payload == {"decision": "pin", "member": "Requested.srt"}
+
+
+@pytest.mark.parametrize("context,member", [({}, "99.en.srt"), ({"absolute_episode": None}, "1.en.srt"),
+ ({"absolute_episode": 0}, "0.en.srt"),
+ ({"absolute_episode": 49}, "49.en.srt")])
+def test_real_worker_absolute_context_preserves_absent_null_and_zero(selector_worker, context, member):
+ response = selector_worker.select_archive_member({
+ "provider_payload": {"episode": 1, "absolute_episode": 99},
+ "members": ["99.en.srt", "1.en.srt", "0.en.srt", "49.en.srt"],
+ "config": {"absolute_selector": True, "decision": "pin"}, **context,
+ }, timeout=5)
+ assert response.payload == {"decision": "pin", "member": member}
+
+
+@pytest.mark.parametrize("absolute,member", [(49, "49.en.srt"), (0, "0.en.srt"), (None, "1.en.srt")])
+@pytest.mark.parametrize("opaque_absolute", [{}, {"absolute_episode": None}, {"absolute_episode": 99}],
+ ids=["missing", "null", "stale"])
+@pytest.mark.parametrize("decision", ["pin", "defer", "reject"])
+def test_registry_forwards_absolute_context_to_real_selector(
+ selector_worker, absolute, member, opaque_absolute, decision):
+ from provider_hub.registry import HubProxyProvider
+ from subzero.language import Language
+ from subliminal_patch.core import Episode
+
+ buffer = io.BytesIO()
+ with zipfile.ZipFile(buffer, "w") as archive:
+ archive.writestr(member, _SRT)
+ archive.writestr("99.en.srt", _SRT.replace(b"\nx\n", b"\nwrong member\n"))
+ payload = _archive_payload(buffer.getvalue(), select_member=True, episode=99)
+ opaque = {"episode": 99, **opaque_absolute}
+ provider = HubProxyProvider(worker_client=selector_worker, archive=payload, opaque=opaque,
+ absolute_selector=True, decision=decision)
+ provider.provider_name = "fixture"
+ video = Episode("/fixtures/Show.mkv", "Show", 3, 1)
+ video.absolute_episode = absolute
+ subtitle = provider.list_subtitles(video, {Language("eng")})[0]
+ # Selection uses the frozen search request, never a later video mutation.
+ video.absolute_episode = 50
+ subtitle.absolute_episode = 50
+ stored = {"archive": payload, **opaque}
+ for _ in range(2):
+ if decision == "reject":
+ with pytest.raises(SubtitleCandidateRejected):
+ provider.download_subtitle(subtitle)
+ else:
+ assert provider.download_subtitle(subtitle) is True
+ assert subtitle.content == _SRT
+ assert subtitle.provider_payload == stored
+
+
+@pytest.mark.parametrize("attributes,member", [({}, "99.en.srt"), ({"absolute_episode": None}, "1.en.srt"),
+ ({"absolute_episode": 0}, "0.en.srt"),
+ ({"absolute_episode": 49}, "49.en.srt")])
+def test_legacy_registry_selector_only_forwards_available_absolute_context(selector_worker, attributes, member):
+ from provider_hub.registry import HubProxyProvider
+ from subzero.language import Language
+ from subliminal_patch.core import Episode
+
+ buffer = io.BytesIO()
+ with zipfile.ZipFile(buffer, "w") as archive:
+ for name in ["99.en.srt", "1.en.srt", "0.en.srt", "49.en.srt"]:
+ archive.writestr(name, _SRT if name == member else _SRT.replace(b"\nx\n", b"\nwrong member\n"))
+ payload = _archive_payload(buffer.getvalue(), select_member=True)
+ opaque = {"episode": 1, "absolute_episode": 99}
+ provider = HubProxyProvider(worker_client=selector_worker, archive=payload, opaque=opaque,
+ absolute_selector=True, decision="pin")
+ provider.provider_name = "fixture"
+ subtitle = provider.list_subtitles(Episode("/fixtures/Show.mkv", "Show", 3, 1), {Language("eng")})[0]
+ del subtitle._requested_archive_context
+ assert not hasattr(subtitle, "absolute_episode")
+ for key, value in attributes.items():
+ setattr(subtitle, key, value)
+ subtitle.season, subtitle.episode = 3, 1
+ assert provider.download_subtitle(subtitle) is True
+ assert subtitle.content == _SRT
+ assert subtitle.provider_payload == {"archive": payload, **opaque}
+
+
+@pytest.mark.parametrize("kind,season,episode,member", [
+ ("movie", None, None, "Film.srt"),
+ ("season_only", 3, None, "Show.S03E01.srt"),
+ ("unknown_season", None, 1, "Show.S04E01.srt"),
+])
+@pytest.mark.parametrize("opaque", [{}, {"season": None, "episode": None}, {"season": 99, "episode": 99}],
+ ids=["missing", "null", "stale"])
+@pytest.mark.parametrize("decision", ["pin", "defer", "reject"])
+def test_registry_selector_preserves_empty_context_through_real_worker(
+ selector_worker, kind, season, episode, member, opaque, decision):
+ from provider_hub.registry import HubProxyProvider
+ from subzero.language import Language
+ from subliminal_patch.core import Episode, Movie
+
+ buffer = io.BytesIO()
+ with zipfile.ZipFile(buffer, "w") as archive:
+ archive.writestr(member, _SRT)
+ archive.writestr("Stale.S99E99.srt", _SRT.replace(b"\nx\n", b"\nwrong member\n"))
+ payload = _archive_payload(buffer.getvalue(), select_member=True, season=99, episode=99)
+ provider = HubProxyProvider(worker_client=selector_worker, archive=payload, opaque=opaque,
+ requested={"season": season, "episode": episode}, decision=decision)
+ provider.provider_name = "fixture"
+ video = (Movie("/fixtures/Film.mkv", "Film", year=2024) if kind == "movie" else
+ Episode("/fixtures/Show.mkv", "Show", season, episode))
+ subtitle = provider.list_subtitles(video, {Language("eng")})[0]
+ stored = {"archive": payload, **opaque}
+ assert subtitle.provider_payload == stored
+
+ # Repeat the download to expose mutation of the stored opaque payload.
+ for _ in range(2):
+ if decision == "reject":
+ with pytest.raises(SubtitleCandidateRejected, match="No matching subtitle language"):
+ provider.download_subtitle(subtitle)
+ else:
+ assert provider.download_subtitle(subtitle) is True
+ assert subtitle.content == _SRT
+ assert subtitle.provider_payload == stored
+
+
def test_worker_runner_select_archive_member_rejects_when_unimplemented():
from provider_hub import worker_runner
class P:
pass
- out = worker_runner._handle(P(), "select_archive_member", {"members": ["a.srt"]})
- assert out == {"member": None, "decision": "reject"}
+ with pytest.raises(ValueError, match="not implemented"):
+ worker_runner._handle(P(), "select_archive_member", {"members": ["a.srt"]})
-def test_worker_runner_select_archive_member_coerces_bad_decision():
+def test_worker_runner_select_archive_member_rejects_bad_decision():
from provider_hub import worker_runner
class P:
def select_archive_member(self, provider_payload, language, members, config):
return {"member": None, "decision": "weird"}
- out = worker_runner._handle(P(), "select_archive_member", {"members": ["a.srt"]})
- assert out["decision"] == "reject"
+ with pytest.raises(ValueError, match="invalid decision"):
+ worker_runner._handle(P(), "select_archive_member", {"members": ["a.srt"]})
def test_select_member_callback_receives_listed_members():
diff --git a/tests/bazarr/test_provider_hub_worker_errors.py b/tests/bazarr/test_provider_hub_worker_errors.py
new file mode 100644
index 0000000000..9e37b778a2
--- /dev/null
+++ b/tests/bazarr/test_provider_hub_worker_errors.py
@@ -0,0 +1,217 @@
+import datetime
+import json
+from pathlib import Path
+import sys
+
+import pytest
+
+from provider_hub.worker import ProviderWorkerClient, WorkerError, worker_command
+from subliminal.exceptions import (
+ AuthenticationError,
+ ConfigurationError,
+ DownloadLimitExceeded,
+ ServiceUnavailable,
+)
+from subliminal_patch.exceptions import APIThrottled, TooManyRequests
+
+
+@pytest.fixture
+def error_worker(tmp_path):
+ bundle = tmp_path / "bundle"
+ bundle.mkdir()
+ (bundle / "provider.py").write_text(
+ """
+class ErrorProvider:
+ def search(self, video, languages, config):
+ raise type(config["failure"], (RuntimeError,), {})(config["message"])
+
+ def download(self, provider_payload, language, config):
+ raise type(config["failure"], (RuntimeError,), {})(config["message"])
+""",
+ encoding="utf-8",
+ )
+ runner = Path(__file__).parents[2] / "bazarr/provider_hub/worker_runner.py"
+ client = ProviderWorkerClient(
+ worker_command(sys.executable, runner),
+ cwd=bundle,
+ env={
+ "BAZARR_PROVIDER_HUB_BUNDLE": str(bundle),
+ "BAZARR_PROVIDER_HUB_MANIFEST": json.dumps(
+ {"entry_module": "provider", "entry_class": "ErrorProvider"}
+ ),
+ },
+ )
+ yield client
+ client.stop()
+
+
+@pytest.fixture
+def throttle_state(monkeypatch, tmp_path):
+ from app.get_args import args
+ from types import SimpleNamespace
+
+ for name in ("config", "db", "cache", "log", "backup"):
+ (tmp_path / name).mkdir()
+ monkeypatch.setattr(args, "config_dir", str(tmp_path))
+ from app import get_providers
+
+ monkeypatch.setattr(get_providers, "tp", {})
+ monkeypatch.setattr(get_providers, "throttle_count", {})
+ names = ["opensubtitlescom", "examplehub"]
+ monkeypatch.setattr(
+ get_providers, "settings",
+ SimpleNamespace(general=SimpleNamespace(enabled_providers=names)),
+ )
+ monkeypatch.setattr(get_providers, "provider_registry", SimpleNamespace(names=lambda: names))
+ monkeypatch.setattr(get_providers, "event_stream", lambda **kwargs: None)
+ return get_providers
+
+
+@pytest.mark.parametrize("operation", ["search", "download"])
+@pytest.mark.parametrize(
+ "remote_name,provider,host_type,seconds",
+ [
+ ("DownloadLimitExceeded", "opensubtitlescom", DownloadLimitExceeded, 21600),
+ ("DownloadLimitExceeded", "examplehub", DownloadLimitExceeded, 10800),
+ ("RateLimited", "opensubtitlescom", TooManyRequests, 60),
+ ("TooManyRequests", "examplehub", TooManyRequests, 3600),
+ ("ServiceUnavailable", "examplehub", ServiceUnavailable, 1200),
+ ("APIThrottled", "examplehub", APIThrottled, 600),
+ ("AuthenticationRequired", "opensubtitlescom", AuthenticationError, 43200),
+ ("AuthenticationError", "examplehub", AuthenticationError, 43200),
+ ("ConfigurationError", "examplehub", ConfigurationError, 43200),
+ ("RuntimeError", "opensubtitlescom", WorkerError, 600),
+ ],
+)
+def test_worker_failure_reaches_persisted_provider_throttle(
+ error_worker, throttle_state, operation, remote_name, provider, host_type, seconds,
+):
+ # The message deliberately looks like quota exhaustion even for unknown errors.
+ # Classification must come from the fixed semantic names, never message parsing.
+ with pytest.raises(Exception) as raised:
+ error_worker.request(operation, {
+ "config": {"failure": remote_name, "message": "download limit exceeded"},
+ }, timeout=5)
+
+ # Counted transient errors throttle on their fifth failure. Keep the real
+ # counter and persistence path while avoiding four retry sleeps in this test.
+ before = datetime.datetime.now()
+ throttle_state.throttle_count[provider] = {
+ "count": 4, "time": before + datetime.timedelta(seconds=120),
+ }
+ throttle_state.provider_throttle(provider, raised.value)
+ after = datetime.datetime.now()
+
+ reason, until, _description = throttle_state.get_throttled_providers()[provider]
+ expected_delay = datetime.timedelta(seconds=seconds)
+ assert before + expected_delay <= until <= after + expected_delay
+ assert reason == host_type.__name__
+ assert type(raised.value) is host_type
+ remote_error = raised.value if host_type is WorkerError else raised.value.__cause__
+ assert isinstance(remote_error, WorkerError)
+ assert remote_error.remote_class_name == remote_name
+ assert remote_error.code == "provider"
+ assert remote_error.retryable is False
+ assert str(raised.value) == "download limit exceeded"
+ assert error_worker.request("health", timeout=5).payload == {"initialized": True}
+
+
+@pytest.fixture
+def response_worker(tmp_path):
+ clients = []
+
+ def start(response):
+ script = tmp_path / f"response-{len(clients)}.py"
+ script.write_text(
+ "import json, sys\n"
+ f"response = json.loads({json.dumps(response)!r})\n"
+ "for line in sys.stdin:\n"
+ " request = json.loads(line)\n"
+ " if isinstance(response, dict):\n"
+ " response.setdefault('abi', request['abi'])\n"
+ " response.setdefault('id', request['id'])\n"
+ " print(json.dumps(response), flush=True)\n",
+ encoding="utf-8",
+ )
+ client = ProviderWorkerClient(worker_command(sys.executable, script))
+ clients.append(client)
+ return client
+
+ yield start
+ for client in clients:
+ client.stop()
+
+
+@pytest.mark.parametrize("error", [None, [], ["DownloadLimitExceeded"], "failure", 5])
+def test_malformed_error_metadata_stays_worker_error(response_worker, error):
+ with pytest.raises(WorkerError):
+ response_worker({"ok": False, "error": error}).request("search", timeout=5)
+
+
+@pytest.mark.parametrize(
+ "remote_name,code",
+ [
+ ("builtins.PermissionError", "provider"),
+ ("SystemExit", "provider"),
+ ("DownloadLimitExceeded", "transport"),
+ ("DownloadLimitExceeded", None),
+ ("DownloadLimitExceeded", []),
+ (["DownloadLimitExceeded"], "provider"),
+ ({"class": "DownloadLimitExceeded"}, "provider"),
+ ],
+)
+def test_unknown_or_invalid_semantic_metadata_stays_worker_error(response_worker, remote_name, code):
+ with pytest.raises(WorkerError, match="failure") as raised:
+ response_worker({"ok": False, "error": {
+ "message": "failure", "class_name": remote_name, "code": code, "retryable": True,
+ }}).request("search", timeout=5)
+ assert type(raised.value) is WorkerError
+ assert raised.value.remote_class_name == (remote_name if isinstance(remote_name, str) else None)
+ assert raised.value.code == (code if isinstance(code, str) else None)
+ assert raised.value.retryable is True
+
+
+@pytest.mark.parametrize("retryable", [True, False, "false", 1, None, []])
+def test_retryable_metadata_accepts_only_booleans(response_worker, retryable):
+ with pytest.raises(DownloadLimitExceeded) as raised:
+ response_worker({"ok": False, "error": {
+ "class_name": "DownloadLimitExceeded", "code": "provider", "message": "quota",
+ "retryable": retryable,
+ }}).request("download", timeout=5)
+ assert raised.value.__cause__.retryable is (retryable if isinstance(retryable, bool) else False)
+
+
+@pytest.mark.parametrize(
+ "response,diagnostic",
+ [
+ ([], "response must be an object"),
+ ({"abi": "unsupported", "ok": False, "error": {"class_name": "DownloadLimitExceeded"}}, "unsupported ABI"),
+ ({"id": "wrong-id", "ok": False, "error": {"class_name": "DownloadLimitExceeded"}}, "mismatched request id"),
+ ],
+)
+def test_invalid_envelope_is_not_promoted_to_provider_error(response_worker, response, diagnostic):
+ with pytest.raises(WorkerError, match=diagnostic):
+ response_worker(response).request("search", timeout=5)
+
+
+@pytest.mark.parametrize(
+ "output,diagnostic",
+ [("not-json", "malformed JSON"), (None, "closed stdout")],
+)
+def test_worker_transport_failure_keeps_generic_error(output, diagnostic):
+ script = "import sys; sys.stdin.readline(); "
+ script += "sys.exit(1)" if output is None else f"print({output!r}, flush=True)"
+ client = ProviderWorkerClient([sys.executable, "-I", "-B", "-c", script])
+ try:
+ with pytest.raises(WorkerError, match=diagnostic) as raised:
+ client.request("download", timeout=5)
+ assert raised.value.remote_class_name is None
+ assert raised.value.code is None
+ assert raised.value.retryable is False
+ finally:
+ client.stop()
+
+
+def test_invalid_success_payload_keeps_generic_error(response_worker):
+ with pytest.raises(WorkerError, match="payload must be an object"):
+ response_worker({"ok": True, "payload": ["candidate"]}).request("search", timeout=5)
diff --git a/tests/bazarr/test_release_type_mismatch.py b/tests/bazarr/test_release_type_mismatch.py
index c030a9810b..491c79a8b3 100644
--- a/tests/bazarr/test_release_type_mismatch.py
+++ b/tests/bazarr/test_release_type_mismatch.py
@@ -1013,8 +1013,11 @@ class _Written:
storage_path = str(written_file)
matches = set()
- search.monkeypatch.setattr(search.module, "save_subtitles",
- lambda *args, **kwargs: [_Written()])
+ def save(*args, **kwargs):
+ kwargs['write_subtitle'](str(written_file), b'1\n')
+ return [_Written()]
+
+ search.monkeypatch.setattr(search.module, "save_subtitles", save)
search.monkeypatch.setattr(search.module, "process_subtitle", lambda **kwargs: None)
search.run()
diff --git a/tests/bazarr/test_secret_store_crypto.py b/tests/bazarr/test_secret_store_crypto.py
index eb9dbcd968..0685590b5d 100644
--- a/tests/bazarr/test_secret_store_crypto.py
+++ b/tests/bazarr/test_secret_store_crypto.py
@@ -6,6 +6,8 @@
covers just the crypto primitives.
"""
from unittest.mock import MagicMock
+import json
+from pathlib import Path
import pytest
@@ -18,6 +20,23 @@
)
+_OLD_CRYPTOGRAPHY = json.loads(
+ (Path(__file__).with_name('fixtures') / 'cryptography49_fernet.json').read_text(encoding='utf-8')
+)
+
+
+@pytest.mark.parametrize('case', _OLD_CRYPTOGRAPHY['cases'], ids=['provider', 'translator', 'unicode'])
+def test_ciphertext_from_cryptography_49_remains_readable(case):
+ """Persisted synthetic fixtures were encrypted by the actual 49.0.0 wheel."""
+ key = _OLD_CRYPTOGRAPHY['master_key']
+ assert decrypt_secret(case['ciphertext'], master_key=key) == case['plaintext']
+ assert encrypt_secret(case['ciphertext'], master_key=key) == case['ciphertext']
+ with pytest.raises(ValueError, match='tampered|master key'):
+ decrypt_secret(case['ciphertext'], master_key='synthetic-wrong-master-key')
+ with pytest.raises(ValueError, match='tampered|master key'):
+ decrypt_secret(case['ciphertext'][:-2] + 'AA', master_key=key)
+
+
@pytest.fixture
def settings_obj():
"""Minimal stand-in for the dynaconf settings root with a writable
diff --git a/tests/bazarr/test_subsync_engines.py b/tests/bazarr/test_subsync_engines.py
index e314af4730..fe0e6f8942 100644
--- a/tests/bazarr/test_subsync_engines.py
+++ b/tests/bazarr/test_subsync_engines.py
@@ -412,7 +412,7 @@ def test_successful_sync_without_history_does_not_log_error(monkeypatch, tmp_pat
_write(subtitle, 'original')
class FakeRunner:
- def run(self, srt_path, output_mode, enabled_engines, execute_engine, force_sync=False):
+ def run(self, srt_path, output_mode, enabled_engines, execute_engine, force_sync=False, **source_options):
result = SyncRunResult(source_path=srt_path, output_mode=output_mode)
result.results = [
SyncEngineResult(
@@ -663,6 +663,7 @@ def test_subsyncer_reports_engine_progress(monkeypatch, tmp_path):
subtitle = tmp_path / 'Movie.hu.srt'
_write(subtitle, 'original')
+ (tmp_path / 'Movie.mkv').touch()
progress = []
def fake_engine(self, output_path, **kwargs):
@@ -692,6 +693,7 @@ def fake_engine(self, output_path, **kwargs):
('Preparing synchronization', 0, 1),
('Running FFsubsync (1/1)', 0, 1),
('Finished FFsubsync (1/1)', 1, 1),
+ ('Saving synchronized subtitle', None, None),
]
@@ -756,6 +758,135 @@ def test_add_sync_engine_outputs_indexes_generated_files(tmp_path):
) == 'hu:sync-alass'
+@pytest.mark.parametrize('engine', ['ffsubsync', 'autosubsync', 'ALASS'])
+@pytest.mark.parametrize('extension', ['srt', 'sub', 'smi', 'txt', 'ssa', 'ASS', 'mpl', 'vtt'])
+@pytest.mark.parametrize('suffix, basename, hi, forced', [
+ ('en', 'en', False, False),
+ ('en.HI', 'en', True, False),
+ ('hu.sdh', 'hu', True, False),
+ ('fr.cc', 'fr', True, False),
+ ('pt_BR.forced', 'pt-BR', False, True),
+ ('pb.forced.hi', 'pt-BR', True, True),
+])
+def test_sync_output_owner_filter_preserves_language_and_format(tmp_path, engine, extension,
+ suffix, basename, hi, forced):
+ from subtitles.indexer.utils import add_sync_engine_outputs
+
+ filename = f'Movie.Release.{suffix}.{engine}.{extension}'
+ _write(tmp_path / filename, 'subtitle')
+ _write(tmp_path / f'Movie.Release.Extended.{suffix}.{engine}.{extension}', 'sibling')
+ _write(tmp_path / f'Movie.{suffix}.{engine}.{extension}', 'shorter stem')
+
+ result = add_sync_engine_outputs(str(tmp_path), {}, video_filename='Movie.Release.mkv')
+
+ assert set(result) == {filename}
+ language = result[filename]
+ assert language.basename == basename
+ assert language.hi is hi
+ assert language.forced is forced
+
+
+def test_sync_output_owner_filter_preserves_existing_entries_and_is_idempotent(tmp_path):
+ from subzero.language import Language
+ from subtitles.indexer.utils import add_sync_engine_outputs
+
+ original = Language.fromietf('hu')
+ existing = Language.fromietf('de')
+ subtitles = {'Movie.hu.srt': original, 'Movie.en.alass.srt': existing,
+ 'Existing.en.srt': Language.fromietf('en')}
+ for filename in ['Movie.hu.srt', 'Movie.en.alass.srt', 'Movie.en.ffsubsync.srt',
+ 'Other.en.alass.srt', 'Movie.en.unknown.srt', 'Movie.en.alass.mkv',
+ 'Movie.invalid.alass.srt', 'Movie.en.combined-hu.alass.srt']:
+ _write(tmp_path / filename, 'subtitle')
+ (tmp_path / 'Movie.fr.alass.srt').mkdir()
+
+ result = add_sync_engine_outputs(str(tmp_path), subtitles, video_filename='Movie.mkv')
+ assert result is subtitles
+ assert set(result) == {'Movie.hu.srt', 'Movie.en.alass.srt', 'Existing.en.srt',
+ 'Movie.en.ffsubsync.srt'}
+ assert result['Movie.hu.srt'] is original
+ assert result['Movie.en.alass.srt'] is existing
+ first_scan = result.copy()
+
+ assert add_sync_engine_outputs(str(tmp_path), result, video_filename='Movie.mkv') == first_scan
+ assert add_sync_engine_outputs(str(tmp_path / 'missing'), result,
+ video_filename='Movie.mkv') == first_scan
+
+
+@pytest.mark.parametrize('video,subtitle', [
+ ('Movie.mkv', 'movie.en.ffsubsync.srt'),
+ ('\u00c9pisode.mkv', 'E\u0301PISODE.en.ffsubsync.srt'),
+ ('E\u0301pisode.mkv', '\u00e9pisode.en.ffsubsync.srt'),
+])
+def test_sync_output_owner_uses_case_and_unicode_normalization(tmp_path, video, subtitle):
+ from subtitles.indexer.utils import add_sync_engine_outputs
+
+ _write(tmp_path / subtitle, 'subtitle')
+ _write(tmp_path / subtitle.replace('.en.', '.Extended.en.'), 'sibling')
+ assert set(add_sync_engine_outputs(str(tmp_path), {}, video_filename=video)) == {subtitle}
+
+
+@pytest.mark.parametrize('stem', ['Movie', 'Movie.en', 'Movie.hi', 'Movie.forced'])
+def test_sync_output_keeps_complete_actual_owner_stem(tmp_path, stem):
+ from subtitles.indexer.utils import add_sync_engine_outputs
+
+ for sibling in ['Movie', 'Movie.en', 'Movie.hi', 'Movie.forced', 'Movie.en.Extended']:
+ _write(tmp_path / f'{sibling}.mkv', 'video')
+ _write(tmp_path / f'{sibling}.ffsubsync.srt', 'subtitle')
+ result = add_sync_engine_outputs(str(tmp_path), {}, video_filename=f'{stem}.mkv')
+ assert result == {f'{stem}.ffsubsync.srt': None}
+
+
+@pytest.mark.parametrize('video_stem,subtitle_stem,sibling_stem', [
+ ('Movie', 'movie', 'MOVIE.EN'),
+ ('\u00c9pisode', 'E\u0301PISODE', '\u00e9pisode.en'),
+ ('E\u0301pisode', '\u00e9pisode', 'E\u0301PISODE.EN'),
+])
+@pytest.mark.parametrize('sibling_kind', ['media', 'directory', 'non-media', 'absent'])
+def test_tagged_sync_output_defers_only_to_an_actual_media_owner(
+ tmp_path, monkeypatch, video_stem, subtitle_stem, sibling_stem, sibling_kind):
+ from subtitles.indexer.utils import add_sync_engine_outputs
+
+ media_folder = tmp_path / 'media'
+ media_folder.mkdir()
+ subtitle_folder = tmp_path / 'subtitles'
+ subtitle_folder.mkdir()
+ video = media_folder / f'{video_stem}.mkv'
+ _write(video, 'video')
+ _write(media_folder / f'{sibling_stem}.Extended.mkv', 'prefix sibling')
+ sibling = media_folder / f'{sibling_stem}.MP4'
+ if sibling_kind == 'media':
+ _write(sibling, 'video')
+ elif sibling_kind == 'directory':
+ sibling.mkdir()
+ elif sibling_kind == 'non-media':
+ _write(media_folder / f'{sibling_stem}.txt', 'not a video')
+ subtitle = f'{subtitle_stem}.en.ffsubsync.srt'
+ _write(subtitle_folder / subtitle, 'subtitle')
+
+ from types import SimpleNamespace
+ from unittest.mock import Mock
+ from app import database as db_module
+ from app.config import settings
+ from utilities.path_mappings import path_mappings
+ monkeypatch.setattr(settings.general, 'subfolder', 'absolute')
+ monkeypatch.setattr(settings.general, 'subfolder_custom', str(subtitle_folder))
+ rows = [SimpleNamespace(path=str(path), arr_instance_id=None) for path in media_folder.iterdir()
+ if path.is_file() and path.suffix.lower() in ('.mkv', '.mp4')]
+ db = Mock()
+ db.execute.return_value.all.return_value = rows
+ monkeypatch.setattr(db_module, 'database', db)
+ monkeypatch.setattr(path_mappings, 'path_replace_instance', lambda path, *args: path)
+ result = add_sync_engine_outputs(str(subtitle_folder), {}, video_path=str(video))
+
+ if sibling_kind == 'media':
+ assert result == {}
+ assert add_sync_engine_outputs(str(subtitle_folder), {}, video_path=str(sibling)) == {subtitle: None}
+ else:
+ assert set(result) == {subtitle}
+ assert result[subtitle].basename == 'en'
+
+
def test_keep_all_job_name_does_not_claim_original_was_overwritten():
from subtitles.sync import _sync_complete_job_name
from subtitles.tools.subsync_engines import (
diff --git a/tests/bazarr/test_subtitle_content_sync_outputs.py b/tests/bazarr/test_subtitle_content_sync_outputs.py
index 8907126879..f57ed2c480 100644
--- a/tests/bazarr/test_subtitle_content_sync_outputs.py
+++ b/tests/bazarr/test_subtitle_content_sync_outputs.py
@@ -7,6 +7,7 @@
from types import SimpleNamespace
from flask import Flask
+import pytest
import app.database # noqa: F401
@@ -223,6 +224,72 @@ def fake_resolve(media_type, media_id, language_code, arr_instance_id=None):
assert events == [{'type': 'movie', 'payload': 1203}]
+@pytest.mark.parametrize('media_type', ['movie', 'episode'])
+@pytest.mark.parametrize('failure', ['index', 'event', 'history'])
+def test_promotion_preserves_confirmation_and_refresh_attempts_on_failure(schema_session, tmp_path, monkeypatch,
+ media_type, failure):
+ from app.database import TableHistory, TableHistoryMovie, select
+ from radarr import history as movie_history
+ from sonarr import history as episode_history
+
+ content = _real_module('api.subtitles.content')
+ video = tmp_path / 'Video.mkv'
+ original = tmp_path / 'Video.en.srt'
+ generated = tmp_path / 'Video.en.alass.srt'
+ video.touch()
+ original.write_text('original subtitle')
+ generated.write_text('selected subtitle')
+ metadata = {'mediaPath': str(video), 'mediaId': 10, 'mediaUpstreamId': 20,
+ 'episodeId': 30, 'episodeUpstreamId': 40, 'arrInstanceId': 7}
+ media_id = 40 if media_type == 'episode' else 20
+ table = TableHistory if media_type == 'episode' else TableHistoryMovie
+ refreshed = []
+
+ monkeypatch.setattr(content, 'resolve_subtitle_path',
+ lambda kind, item_id, lang, **kw: (str(generated if ':sync-' in lang else original), metadata))
+ monkeypatch.setattr(content, 'database', schema_session)
+ for module in (movie_history, episode_history):
+ monkeypatch.setattr(module, 'database', schema_session)
+ monkeypatch.setattr(module, 'event_stream', lambda **kw: None)
+ for name in ('path_replace_reverse', 'path_replace_reverse_movie'):
+ monkeypatch.setattr(content.path_mappings, name, lambda path: path)
+ monkeypatch.setattr(content.path_mappings, 'path_replace_instance', lambda path, *a: path)
+ monkeypatch.setattr(content, '_active_sync_job_for_path', lambda path: None)
+
+ def refresh_step(step):
+ refreshed.append(step)
+ if step == failure:
+ raise RuntimeError('controlled refresh failure')
+
+ for name in ('store_subtitles', 'store_subtitles_movie'):
+ monkeypatch.setattr(content, name, lambda *a, **kw: refresh_step('index'))
+ monkeypatch.setattr(content, 'event_stream', lambda **kw: refresh_step('event'))
+ if failure == 'history':
+ execute = schema_session.execute
+
+ def fail_history_insert(statement, *args, **kwargs):
+ if getattr(statement, 'is_insert', False):
+ raise RuntimeError('controlled refresh failure')
+ return execute(statement, *args, **kwargs)
+
+ monkeypatch.setattr(schema_session, 'execute', fail_history_insert)
+
+ with pytest.raises(RuntimeError, match='controlled refresh failure'):
+ content.promote_sync_subtitle(media_type, media_id, 'en', 'en:sync-alass', arr_instance_id=7)
+
+ assert original.read_text() == 'selected subtitle'
+ rows = schema_session.execute(select(table)).scalars().all()
+ if failure == 'history':
+ assert refreshed == (['index', 'event', 'event'] if media_type == 'episode' else ['index', 'event'])
+ assert rows == []
+ return
+ assert len(rows) == 1, 'a completed publication lost its action-5 confirmation'
+ assert (rows[0].action, rows[0].arr_instance_id, rows[0].subtitles_path) == (5, 7, str(original))
+ status, code = content.get_subtitle_sync_status(media_type, media_id, 'en', arr_instance_id=7)
+ assert code == 200
+ assert status['confirmed'] is True
+
+
def test_promote_sync_output_rejects_different_base_language(monkeypatch):
content = _real_module('api.subtitles.content')
diff --git a/tests/bazarr/test_subtitle_destination_path.py b/tests/bazarr/test_subtitle_destination_path.py
new file mode 100644
index 0000000000..e01a45ca41
--- /dev/null
+++ b/tests/bazarr/test_subtitle_destination_path.py
@@ -0,0 +1,206 @@
+# coding=utf-8
+"""A new external subtitle has to land in the configured subtitle folder.
+
+get_external_subtitles_path() is a lookup: it returns a path only for a file that
+already exists. translate and mods used it to build the path of the file they were
+about to WRITE, so in the absolute and relative subfolder modes a first-time
+translation got None and crashed on save. get_subtitle_destination_path() keeps the
+lookup's preference for an existing file and otherwise resolves the configured folder.
+"""
+import os
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+
+@pytest.fixture
+def subtitle_folder(monkeypatch):
+ from app import config as app_config
+ from subtitles.indexer import utils as indexer_utils
+
+ # Startup modules write the config to disk when first imported. If that first
+ # import happens while these values are patched, the patched folder would be
+ # persisted into the local test config and break every later run.
+ monkeypatch.setattr(app_config, "write_config", lambda: None)
+
+ def _configure(mode, custom=""):
+ monkeypatch.setattr(indexer_utils.settings.general, "subfolder", mode)
+ monkeypatch.setattr(indexer_utils.settings.general, "subfolder_custom", custom)
+
+ return _configure
+
+
+def test_current_mode_writes_next_to_the_video(tmp_path, subtitle_folder):
+ from subtitles.indexer.utils import get_subtitle_destination_path
+
+ subtitle_folder("current")
+ video = tmp_path / "video.mkv"
+
+ assert get_subtitle_destination_path(str(video), "video.hu.srt") == str(tmp_path / "video.hu.srt")
+
+
+def test_absolute_mode_resolves_and_creates_the_custom_folder(tmp_path, subtitle_folder):
+ from subtitles.indexer.utils import get_subtitle_destination_path
+
+ custom = tmp_path / "subs"
+ subtitle_folder("absolute", str(custom))
+ video = tmp_path / "video.mkv"
+
+ destination = get_subtitle_destination_path(str(video), "video.hu.srt")
+
+ assert destination == str(custom / "video.hu.srt")
+ assert custom.is_dir(), "the write target folder has to exist, the way downloads create it"
+
+
+def test_relative_mode_resolves_under_the_video_folder(tmp_path, subtitle_folder):
+ from subtitles.indexer.utils import get_subtitle_destination_path
+
+ subtitle_folder("relative", "Subs")
+ video = tmp_path / "video.mkv"
+
+ assert get_subtitle_destination_path(str(video), "video.hu.srt") == str(tmp_path / "Subs" / "video.hu.srt")
+
+
+def test_an_existing_file_next_to_the_video_keeps_precedence(tmp_path, subtitle_folder):
+ from subtitles.indexer.utils import get_subtitle_destination_path
+
+ subtitle_folder("absolute", str(tmp_path / "subs"))
+ video = tmp_path / "video.mkv"
+ existing = tmp_path / "video.hu.srt"
+ existing.write_text("1\n00:00:00,000 --> 00:00:01,000\nSzia\n", encoding="utf-8")
+
+ assert get_subtitle_destination_path(str(video), "video.hu.srt") == str(existing)
+
+
+def test_translate_passes_a_custom_folder_destination_to_the_translator(tmp_path, monkeypatch, subtitle_folder):
+ from subtitles.tools.translate import main as translate_main
+ from subzero.language import Language
+
+ custom = tmp_path / "subs"
+ subtitle_folder("absolute", str(custom))
+ video = tmp_path / "video.mkv"
+
+ monkeypatch.setattr(translate_main, "validate_translation_params", lambda *a, **kw: None)
+ monkeypatch.setattr(translate_main, "convert_language_codes",
+ lambda to_lang, forced, hi: (Language("hun"), to_lang))
+ monkeypatch.setattr(translate_main, "get_subtitle_path", lambda *a, **kw: str(tmp_path / "video.hu.srt"))
+ monkeypatch.setattr(translate_main, "alpha3_from_alpha2", lambda code: "hun")
+
+ seen = {}
+ translator = MagicMock()
+ translator.translate.return_value = True
+
+ def _create(kind, **kwargs):
+ seen.update(kwargs)
+ return translator
+
+ monkeypatch.setattr(translate_main.TranslatorFactory, "create_translator", staticmethod(_create))
+
+ with (
+ patch("api.subtitles.subtitles.postprocess_subtitles", lambda *a, **kw: None),
+ patch("subtitles.tools.combine.main.try_combine_for_video", lambda **kw: None),
+ ):
+ translate_main.translate_subtitles_file(
+ video_path=str(video), source_srt_file=str(tmp_path / "video.en.srt"),
+ from_lang="en", to_lang="hu", forced=False, hi=False,
+ media_type="movies", sonarr_series_id=None, sonarr_episode_id=None,
+ radarr_id=9, metadata={}, job_id="job-1")
+
+ assert seen["dest_srt_file"] == os.path.join(str(custom), "video.hu.srt"), (
+ "a first-time translation in absolute subfolder mode must target the custom folder, not None")
+
+
+@pytest.mark.parametrize("mode", ["absolute", "relative"])
+@pytest.mark.parametrize("status", ["partial", "completed"])
+@pytest.mark.parametrize("failure", [None, "footer", "replace"])
+def test_translation_saves_atomic_results_in_configured_folder(
+ tmp_path, monkeypatch, subtitle_folder, mode, status, failure):
+ import sys
+ from types import SimpleNamespace
+
+ import pysubs2
+
+ from languages import get_languages
+ from subtitles.tools.translate import main as translate_main
+ from subtitles.tools.translate.services import openrouter_translator as service_module
+
+ monkeypatch.setattr(get_languages, "languages_dict", [
+ {"code2": "en", "code3": "eng", "code3b": "eng", "name": "English"},
+ {"code2": "hu", "code3": "hun", "code3b": "hun", "name": "Hungarian"},
+ ], raising=False)
+ video = tmp_path / "video.mkv"
+ video.touch()
+ source = tmp_path / "video.en.srt"
+ source.write_text("1\n00:00:01,000 --> 00:00:02,000\nOne\n\n"
+ "2\n00:00:03,000 --> 00:00:04,000\nTwo\n", encoding="utf-8")
+ original_source = source.read_bytes()
+ custom = tmp_path / "Subs"
+ destination = custom / "video.hu.srt"
+ subtitle_folder(mode, str(custom) if mode == "absolute" else "Subs")
+ if failure:
+ custom.mkdir()
+ destination.write_bytes(b"existing subtitle")
+
+ monkeypatch.setattr(service_module.settings.translator, "translator_info", True)
+ monkeypatch.setattr(service_module.settings.translator, "translator_type", "openrouter")
+ monkeypatch.setattr(service_module, "get_title", lambda **kwargs: "Example")
+ monkeypatch.setattr(service_module, "get_translator_auth_headers", lambda: {})
+ monkeypatch.setattr(service_module.OpenRouterTranslatorService, "_get_api_key_value", lambda self: "")
+ monkeypatch.setattr(service_module.requests, "post", lambda *args, **kwargs: SimpleNamespace(
+ status_code=200, json=lambda: {"jobId": "fixture-job"}))
+ lines = [{"position": 0, "line": "Egy"}]
+ if status == "completed":
+ lines.append({"position": 1, "line": "Kettő"})
+ monkeypatch.setattr(service_module.requests, "get", lambda *args, **kwargs: SimpleNamespace(
+ status_code=200, json=lambda: {"status": status, "result": {"lines": lines},
+ "error": "Some batches failed" if failure else None}))
+ for name in ("show_progress", "hide_progress", "show_message"):
+ monkeypatch.setattr(service_module, name, lambda *args, **kwargs: None)
+ history = []
+ monkeypatch.setattr(service_module, "history_log_movie", lambda **kwargs: history.append(kwargs))
+ monkeypatch.setattr(service_module.jobs_queue, "update_job_progress", lambda **kwargs: None)
+ names = []
+ monkeypatch.setattr(translate_main.jobs_queue, "get_job_name", lambda job_id: "Translating Example")
+ monkeypatch.setattr(translate_main.jobs_queue, "update_job_name",
+ lambda **kwargs: names.append(kwargs["new_job_name"]))
+ monkeypatch.setattr(translate_main.TranslatorFactory, "create_translator",
+ staticmethod(lambda kind, **kwargs: service_module.OpenRouterTranslatorService(**kwargs)))
+ postprocessed = []
+
+ def fail_write(*args, **kwargs):
+ raise OSError("synthetic write failure")
+
+ if failure == "footer":
+ monkeypatch.setattr(service_module, "add_translator_info", fail_write)
+ elif failure == "replace":
+ from subtitles.tools import subsync_engines
+ monkeypatch.setattr(subsync_engines.os, "replace", fail_write)
+
+ monkeypatch.setitem(sys.modules, "api.subtitles.subtitles", SimpleNamespace(
+ postprocess_subtitles=lambda *args, **kwargs: postprocessed.append(args[0])))
+ monkeypatch.setitem(sys.modules, "subtitles.tools.combine.main", SimpleNamespace(
+ try_combine_for_video=lambda **kwargs: None))
+ kwargs = dict(video_path=str(video), source_srt_file=str(source), from_lang="en", to_lang="hu",
+ forced=False, hi=False, media_type="movies", sonarr_series_id=None,
+ sonarr_episode_id=None, radarr_id=9, metadata={}, job_id="fixture-job", arr_instance_id=3)
+ if failure:
+ with pytest.raises(RuntimeError, match="failed translation result"):
+ translate_main.translate_subtitles_file(**kwargs)
+ else:
+ assert translate_main.translate_subtitles_file(**kwargs) == str(destination)
+
+ assert source.read_bytes() == original_source
+ assert not list(custom.glob(".bazarr-translate-*"))
+ if failure:
+ assert destination.read_bytes() == b"existing subtitle"
+ assert not history
+ assert not postprocessed
+ assert names[-1].startswith("Failed")
+ else:
+ output = pysubs2.load(destination)
+ assert [cue.plaintext for cue in output[:2]] == (["Egy", "Two"] if status == "partial" else ["Egy", "Kettő"])
+ assert [(cue.start, cue.end) for cue in output[:2]] == [(1000, 2000), (3000, 4000)]
+ assert ("partially translated" in output[-1].plaintext.lower()) == (status == "partial")
+ assert ("partial" in history[0]["result"].message.lower()) == (status == "partial")
+ assert names[-1].startswith("Partially translated" if status == "partial" else "Translated")
+ assert postprocessed == [str(destination)]
diff --git a/tests/bazarr/test_threading_followup.py b/tests/bazarr/test_threading_followup.py
index d1ad9f2da4..a9780f078a 100644
--- a/tests/bazarr/test_threading_followup.py
+++ b/tests/bazarr/test_threading_followup.py
@@ -303,7 +303,7 @@ def __str__(self):
return "en"
monkeypatch.setattr(si, "search_external_subtitles", lambda *a, **k: {sub_local: _Lang()})
- monkeypatch.setattr(si, "add_sync_engine_outputs", lambda f, s: s)
+ monkeypatch.setattr(si, "add_sync_engine_outputs", lambda f, s, **k: s)
monkeypatch.setattr(si, "add_combined_outputs", lambda f, s, **k: s)
monkeypatch.setattr(si, "guess_external_subtitles", lambda f, s, t, e: s)
monkeypatch.setattr(si, "get_external_subtitles_path", lambda r, s: s)
diff --git a/tests/bazarr/test_translate_job_media_name.py b/tests/bazarr/test_translate_job_media_name.py
new file mode 100644
index 0000000000..5298637e11
--- /dev/null
+++ b/tests/bazarr/test_translate_job_media_name.py
@@ -0,0 +1,275 @@
+# coding=utf-8
+"""Translation job labels have to name the media, movies included.
+
+``translate_subtitles_file`` and the AI translator both build their label from
+``get_title``, and the LLM prompt gets its context from ``get_description``.
+Both branch on ``media_type``, and the callers do not agree on how to spell it:
+the manual translate endpoint sends "movie" while the batch paths send
+"movies". Only the plural matched, so a movie translated from its detail page
+fell through to the series branch, found no ``sonarr_series_id`` and produced an
+empty title. The job then read "Translating HU to EN" with no film in it, the
+Translation Jobs table showed only the language pair, and the prompt lost the
+movie's overview.
+
+Both lookups also have to be scoped to the owning instance (#156). ``radarrId``
+and ``sonarrSeriesId`` are unique only together with ``arr_instance_id``
+(``ux_table_movies_instance_upstream_id``), so an unscoped query can hand back a
+sibling instance's media and label the job, and prompt the provider, with the
+wrong film.
+"""
+import pytest
+
+from app.database import TableEpisodes, TableMovies, TableShows
+from subtitles.tools.translate.core import translator_utils
+
+
+@pytest.fixture
+def library(schema_session, monkeypatch):
+ """Two Radarr/Sonarr instances that reuse the same upstream ids."""
+ monkeypatch.setattr(translator_utils, "database", schema_session)
+ schema_session.add(
+ TableMovies(
+ arr_instance_id=1,
+ radarrId=7,
+ tmdbId="12345",
+ title="The Quiet Earth",
+ year="1985",
+ imdbId="tt0089869",
+ overview="The last man alive.",
+ path="/movies/quiet.mkv",
+ tags="[]",
+ monitored="True",
+ )
+ )
+ schema_session.add(
+ TableShows(
+ arr_instance_id=1,
+ sonarrSeriesId=3,
+ tvdbId=999,
+ title="Dark Matter",
+ year="2024",
+ imdbId="tt1234567",
+ overview="A man wakes in another life.",
+ path="/tv/dark-matter",
+ tags="[]",
+ monitored="True",
+ seriesType="standard",
+ )
+ )
+ schema_session.add(
+ TableEpisodes(
+ arr_instance_id=1,
+ sonarrEpisodeId=42,
+ sonarrSeriesId=3,
+ season=2,
+ episode=5,
+ title="Superposition",
+ path="/tv/dark-matter/s02e05.mkv",
+ monitored="True",
+ )
+ )
+ # The 4K instance reuses the same upstream ids for different media.
+ schema_session.add(
+ TableMovies(
+ arr_instance_id=2,
+ radarrId=7,
+ tmdbId="67890",
+ title="Sorcerer",
+ year="1977",
+ imdbId="tt0076740",
+ overview="Four men drive nitroglycerin through the jungle.",
+ path="/movies-4k/sorcerer.mkv",
+ tags="[]",
+ monitored="True",
+ )
+ )
+ schema_session.add(
+ TableShows(
+ arr_instance_id=2,
+ sonarrSeriesId=3,
+ tvdbId=1000,
+ title="Severance",
+ year="2022",
+ imdbId="tt11280740",
+ overview="Work you cannot remember.",
+ path="/tv-4k/severance",
+ tags="[]",
+ monitored="True",
+ seriesType="standard",
+ )
+ )
+ schema_session.add(
+ TableEpisodes(
+ arr_instance_id=2,
+ sonarrEpisodeId=42,
+ sonarrSeriesId=3,
+ season=1,
+ episode=9,
+ title="The We We Are",
+ path="/tv-4k/severance/s01e09.mkv",
+ monitored="True",
+ )
+ )
+ schema_session.commit()
+ return schema_session
+
+
+@pytest.mark.parametrize("media_type", ["movie", "movies"])
+def test_movie_title_is_found_however_the_caller_spells_the_media_type(library, media_type):
+ assert translator_utils.get_title(media_type, radarr_id=7) == "The Quiet Earth"
+
+
+@pytest.mark.parametrize("media_type", ["movie", "movies"])
+def test_movie_description_is_found_however_the_caller_spells_the_media_type(library, media_type):
+ description = translator_utils.get_description(media_type, radarr_id=7, sonarr_series_id=None)
+ assert "The Quiet Earth" in description
+ assert "The last man alive." in description
+
+
+def test_unknown_movie_still_gives_an_empty_title(library):
+ assert translator_utils.get_title("movie", radarr_id=999) == ""
+
+
+def test_episode_title_still_carries_the_series_and_the_episode_number(library):
+ title = translator_utils.get_title(
+ "episode", sonarr_series_id=3, sonarr_episode_id=42
+ )
+ assert title == "Dark Matter - S02E05 - Superposition"
+
+
+def test_series_description_is_unchanged(library):
+ description = translator_utils.get_description(
+ "episode", radarr_id=None, sonarr_series_id=3
+ )
+ assert "Dark Matter" in description
+
+
+@pytest.mark.parametrize(
+ "instance, expected", [(1, "The Quiet Earth"), (2, "Sorcerer")]
+)
+def test_movie_title_comes_from_the_owning_instance(library, instance, expected):
+ # radarrId 7 exists on both instances; only the pair identifies the film.
+ assert (
+ translator_utils.get_title("movie", radarr_id=7, arr_instance_id=instance)
+ == expected
+ )
+
+
+@pytest.mark.parametrize(
+ "instance, expected", [(1, "The last man alive."), (2, "nitroglycerin")]
+)
+def test_movie_description_comes_from_the_owning_instance(library, instance, expected):
+ description = translator_utils.get_description(
+ "movie", radarr_id=7, sonarr_series_id=None, arr_instance_id=instance
+ )
+ assert expected in description
+
+
+@pytest.mark.parametrize(
+ "instance, expected",
+ [(1, "Dark Matter - S02E05 - Superposition"), (2, "Severance - S01E09 - The We We Are")],
+)
+def test_episode_title_comes_from_the_owning_instance(library, instance, expected):
+ assert (
+ translator_utils.get_title(
+ "episode", sonarr_series_id=3, sonarr_episode_id=42, arr_instance_id=instance
+ )
+ == expected
+ )
+
+
+def test_series_description_comes_from_the_owning_instance(library):
+ description = translator_utils.get_description(
+ "episode", radarr_id=None, sonarr_series_id=3, arr_instance_id=2
+ )
+ assert "Severance" in description
+
+
+def test_an_instance_that_owns_nothing_gives_an_empty_title(library):
+ assert translator_utils.get_title("movie", radarr_id=7, arr_instance_id=99) == ""
+
+
+# --- the owner has to survive the trip from the endpoint to the lookup --------
+
+
+@pytest.mark.parametrize(
+ "module_name, service_name, helper",
+ [
+ ("openrouter_translator", "OpenRouterTranslatorService", "get_title"),
+ ("lingarr_translator", "LingarrTranslatorService", "get_title"),
+ ("gemini_translator", "GeminiTranslatorService", "get_description"),
+ ],
+)
+def test_translator_services_pass_the_owner_to_the_lookup(
+ monkeypatch, module_name, service_name, helper
+):
+ import importlib
+
+ module = importlib.import_module(
+ f"subtitles.tools.translate.services.{module_name}"
+ )
+ seen = {}
+
+ def _capture(*args, **kwargs):
+ seen.update(kwargs)
+ seen["positional"] = args
+ return ""
+
+ monkeypatch.setattr(module, helper, _capture)
+
+ service = getattr(module, service_name)(
+ source_srt_file="in.srt",
+ dest_srt_file="out.srt",
+ lang_obj=None,
+ to_lang="hun",
+ from_lang="en",
+ media_type="movie",
+ video_path="/movies/x.mkv",
+ orig_to_lang="hu",
+ forced=False,
+ hi=False,
+ sonarr_series_id=None,
+ sonarr_episode_id=None,
+ radarr_id=7,
+ arr_instance_id=2,
+ )
+
+ assert service.arr_instance_id == 2
+
+
+def test_translate_subtitles_file_labels_the_job_with_the_owning_instance(monkeypatch):
+ from subtitles.tools.translate import main as translate_main
+
+ seen = {}
+
+ def _capture(*args, **kwargs):
+ seen["args"] = args
+ seen["kwargs"] = kwargs
+ return "The Quiet Earth"
+
+ monkeypatch.setattr(translate_main, "get_title", _capture)
+ monkeypatch.setattr(
+ translate_main.jobs_queue,
+ "add_job_from_function",
+ lambda *a, **k: seen.setdefault("label", a[0]),
+ )
+
+ translate_main.translate_subtitles_file(
+ video_path="/movies/x.mkv",
+ source_srt_file="in.srt",
+ from_lang="en",
+ to_lang="hu",
+ forced=False,
+ hi=False,
+ media_type="movie",
+ sonarr_series_id=None,
+ sonarr_episode_id=None,
+ radarr_id=7,
+ metadata={},
+ job_id=None,
+ arr_instance_id=2,
+ )
+
+ assert seen["label"] == "Translating The Quiet Earth (EN to HU)"
+ passed = list(seen["args"]) + list(seen["kwargs"].values())
+ assert 2 in passed
diff --git a/tests/bazarr/test_translate_owner_threading.py b/tests/bazarr/test_translate_owner_threading.py
index 8bcaaa1f2a..8c81e14a01 100644
--- a/tests/bazarr/test_translate_owner_threading.py
+++ b/tests/bazarr/test_translate_owner_threading.py
@@ -27,12 +27,13 @@ def translate_harness(monkeypatch, tmp_path):
lambda to_lang, forced, hi: (Language('nld'), to_lang))
monkeypatch.setattr(translate_main, 'get_subtitle_path',
lambda *a, **kw: str(tmp_path / 'video.nl.srt'))
- monkeypatch.setattr(translate_main, 'get_external_subtitles_path',
+ monkeypatch.setattr(translate_main, 'get_subtitle_destination_path',
lambda file, subtitle: str(tmp_path / subtitle))
monkeypatch.setattr(translate_main, 'alpha3_from_alpha2', lambda code: 'nld')
translator = MagicMock()
translator.translate.return_value = True
+ translator.partial_error = None
monkeypatch.setattr(translate_main.TranslatorFactory, 'create_translator',
staticmethod(lambda *a, **kw: translator))
return translate_main
@@ -80,3 +81,27 @@ def _postprocess(subtitles_path, video_path, media_type, metadata, id,
radarr_id=9, metadata={}, job_id='job-1')
assert seen['arr_instance_id'] is None
+
+
+@pytest.mark.parametrize('partial', [False, True])
+@pytest.mark.parametrize('current_name', [None, 'Translating Example'])
+def test_translation_job_label_preserves_partial_status(translate_harness, monkeypatch, partial, current_name):
+ translate_main = translate_harness
+ translator = translate_main.TranslatorFactory.create_translator('openrouter')
+ translator.partial_error = 'Some batches failed' if partial else None
+ names = []
+ monkeypatch.setattr(translate_main.jobs_queue, 'get_job_name', lambda job_id: current_name)
+ monkeypatch.setattr(translate_main.jobs_queue, 'update_job_name',
+ lambda **kwargs: names.append(kwargs['new_job_name']))
+
+ with (
+ patch('api.subtitles.subtitles.postprocess_subtitles', lambda *a, **kw: None),
+ patch('subtitles.tools.combine.main.try_combine_for_video', lambda **kw: None),
+ ):
+ translate_main.translate_subtitles_file(
+ video_path='/local/tv/s/e.mkv', source_srt_file='/local/tv/s/e.en.srt',
+ from_lang='en', to_lang='nl', forced=False, hi=False,
+ media_type='episode', sonarr_series_id=1, sonarr_episode_id=42,
+ radarr_id=None, metadata={}, job_id='job-1', arr_instance_id=3)
+
+ assert names[-1].startswith('Partially translated' if partial else 'Translated')
diff --git a/tests/bazarr/test_translator_model_migration.py b/tests/bazarr/test_translator_model_migration.py
new file mode 100644
index 0000000000..8df7f0695b
--- /dev/null
+++ b/tests/bazarr/test_translator_model_migration.py
@@ -0,0 +1,60 @@
+import json
+import os
+from pathlib import Path
+import subprocess
+import sys
+
+import pytest
+import yaml
+
+
+@pytest.mark.parametrize('configured, expected', [
+ (None, 'google/gemini-2.5-flash-lite'),
+ ('google/gemini-2.5-flash-preview-05-20', 'google/gemini-2.5-flash'),
+ ('google/gemini-2.5-flash-lite-preview-06-17', 'google/gemini-2.5-flash-lite'),
+ ('google/gemini-2.5-flash-lite-preview-09-2025', 'google/gemini-2.5-flash-lite'),
+ ('google/gemini-3-pro-preview', 'google/gemini-3.1-pro-preview'),
+ ('google/gemini-2.5-flash', 'google/gemini-2.5-flash'),
+ ('google/gemini-2.5-flash-lite', 'google/gemini-2.5-flash-lite'),
+ ('google/gemini-3.1-pro-preview', 'google/gemini-3.1-pro-preview'),
+ ('x-ai/grok-4-fast', 'x-ai/grok-4-fast'),
+ ('x-ai/grok-4.20-beta', 'x-ai/grok-4.20-beta'),
+ ('custom/my-model', 'custom/my-model'),
+ ('google/gemini-2.5-flash-preview-custom', 'google/gemini-2.5-flash-preview-custom'),
+])
+def test_startup_persists_only_known_model_replacements(tmp_path, configured, expected):
+ config_dir = tmp_path / 'install'
+ (config_dir / 'config').mkdir(parents=True)
+ config_file = config_dir / 'config' / 'config.yaml'
+ translator = {'openrouter_temperature': 0.42, 'translator_type': 'openrouter'}
+ if configured is not None:
+ translator['openrouter_model'] = configured
+ config_file.write_text(yaml.safe_dump({'translator': translator}), encoding='utf-8')
+ repo = Path(__file__).resolve().parents[2]
+ script = '''
+import json
+import os
+import sys
+sys.path[:0] = [os.path.join(sys.argv[1], 'custom_libs'), os.path.join(sys.argv[1], 'bazarr')]
+os.environ['NO_CLI'] = 'true'
+from app.get_args import args
+args.config_dir = sys.argv[2]
+args.no_tasks = True
+from app.config import settings
+print(json.dumps({'model': settings.translator.openrouter_model,
+ 'temperature': settings.translator.openrouter_temperature}))
+'''
+ env = {**os.environ, 'PYTHONDONTWRITEBYTECODE': '1', 'XDG_CACHE_HOME': str(tmp_path / 'cache')}
+ first_contents = None
+ for _startup in range(2):
+ process = subprocess.run([sys.executable, '-c', script, str(repo), str(config_dir)],
+ cwd=repo, env=env, capture_output=True, text=True, timeout=30)
+ assert process.returncode == 0, process.stderr
+ assert json.loads(process.stdout) == {'model': expected, 'temperature': 0.42}
+ persisted = yaml.safe_load(config_file.read_text(encoding='utf-8'))
+ assert persisted['translator']['openrouter_model'] == expected
+ assert persisted['translator']['openrouter_temperature'] == 0.42
+ if first_contents is None:
+ first_contents = config_file.read_bytes()
+ else:
+ assert config_file.read_bytes() == first_contents
diff --git a/tests/bazarr/test_upload_background_sync.py b/tests/bazarr/test_upload_background_sync.py
new file mode 100644
index 0000000000..b7ec83766c
--- /dev/null
+++ b/tests/bazarr/test_upload_background_sync.py
@@ -0,0 +1,1738 @@
+"""Manual uploads remain visible while their separate sync job is running."""
+
+from io import BytesIO
+import ast
+from pathlib import Path
+from threading import Event, Thread
+from types import SimpleNamespace
+from unittest.mock import Mock
+
+import pytest
+
+
+@pytest.fixture
+def upload_flow(monkeypatch, tmp_path):
+ from app import jobs_queue as queue_module
+ from app.config import settings
+ from arr_instances import resolution
+ from languages import get_languages
+ from subtitles import manual, processing, sync, upload
+ from subtitles.indexer import movies, series
+ from subtitles.tools import delete, subsyncer
+ from subtitles.tools.subsync_engines import InMemorySubsyncFailureStore, SubsyncEngineRunner
+
+ monkeypatch.setattr(queue_module.JobsQueue, "_flush_progress_loop", lambda self: None)
+ queue = queue_module.JobsQueue()
+ events, indexes, history, notifications, sync_history, engine_calls = [], [], [], [], [], []
+ real_indexers = {"series": series.store_subtitles, "movie": movies.store_subtitles_movie}
+ controls = SimpleNamespace(fail=False)
+ engine_started, release_engine = Event(), Event()
+ video = tmp_path / "Video.mkv"
+ video.touch()
+ metadata = SimpleNamespace(sonarrSeriesId=10, sonarrEpisodeId=20, radarrId=30,
+ profileId=1, imdbId="tt1", tvdbId=1, tmdbId=1,
+ season=1, episode=1)
+ db = Mock()
+ db.execute.return_value.first.return_value = metadata
+ monkeypatch.setattr(get_languages, "languages_dict", [
+ {"code2": "en", "code3": "eng", "code3b": "eng", "name": "English"},
+ ], raising=False)
+ monkeypatch.setattr(upload, "database", db)
+ monkeypatch.setattr(delete, "database", db)
+ monkeypatch.setattr(upload, "get_profiles_list", lambda _: {"originalFormat": False})
+ monkeypatch.setattr(upload, "get_audio_profile_languages", lambda _: [])
+ monkeypatch.setattr(upload, "client_for_instance", lambda *a, **k: None)
+ monkeypatch.setattr(delete, "client_for_instance", lambda *a, **k: None)
+ monkeypatch.setattr(delete, "call_external_webhook", lambda **k: None)
+ monkeypatch.setattr(upload, "get_target_folder", lambda _: None)
+ monkeypatch.setattr(manual, "clear_mismatch_after_manual_save", lambda *a: None)
+ monkeypatch.setattr(processing, "_postprocessing_config", lambda *a: (False, "", False, 0))
+ monkeypatch.setattr(resolution, "_subtitle_settings_cache", {7: {}, 8: {}})
+ monkeypatch.setattr(upload.path_mappings, "path_replace_reverse_instance", lambda path, *a: path)
+ monkeypatch.setattr(upload.path_mappings, "path_replace_instance", lambda path, *a: path)
+ monkeypatch.setattr("utilities.media_ids.local_episode_id", lambda episode_id, owner: 2000 + owner)
+ for name, value in {"single_language": False, "chmod_enabled": False, "utf8_encode": True,
+ "dont_notify_manual_actions": False, "use_plex": False, "use_jellyfin": False}.items():
+ monkeypatch.setattr(settings.general, name, value)
+ for name, value in {"use_subsync": True, "use_subsync_threshold": False,
+ "use_subsync_movie_threshold": False, "enabled_engines": ["ffsubsync"],
+ "output_mode": "overwrite", "debug": False}.items():
+ monkeypatch.setattr(settings.subsync, name, value)
+
+ def event(**kwargs):
+ if kwargs.get("type") in ("movie", "series", "episode"):
+ assert indexes, "media events must follow the first subtitle index"
+ events.append(kwargs)
+
+ def index(mapped_path, path, arr_instance_id=None):
+ indexes.append((arr_instance_id, {p.name: p.read_text() for p in Path(path).parent.glob("*.srt")}))
+
+ for module in (queue_module, upload, sync):
+ monkeypatch.setattr(module, "jobs_queue", queue)
+ for module in (queue_module, upload, delete):
+ monkeypatch.setattr(module, "event_stream", event)
+ monkeypatch.setattr("app.event_handler.event_stream", event)
+ monkeypatch.setattr(series, "store_subtitles", index)
+ monkeypatch.setattr(movies, "store_subtitles_movie", index)
+ monkeypatch.setattr(delete, "store_subtitles", index)
+ monkeypatch.setattr(delete, "store_subtitles_movie", index)
+ for name in ("history_log", "history_log_movie"):
+ monkeypatch.setattr(upload, name, lambda *a, **k: history.append((a, k)))
+ monkeypatch.setattr(delete, name, lambda *a, **k: None)
+ for name in ("notify_sonarr", "notify_radarr", "send_notifications", "send_notifications_movie"):
+ monkeypatch.setattr(upload, name, lambda *a, **k: notifications.append((a, k)))
+ for name in ("notify_sonarr", "notify_radarr"):
+ monkeypatch.setattr(delete, name, lambda *a, **k: None)
+ monkeypatch.setattr(subsyncer.SubSyncer, "_log_sync_history", lambda *a, **k: sync_history.append(k))
+ monkeypatch.setattr(subsyncer, "SubsyncEngineRunner", lambda: SubsyncEngineRunner(InMemorySubsyncFailureStore()))
+
+ def engine(self, output_path, **kwargs):
+ engine_calls.append(kwargs)
+ source = Path(self.srtin).read_text()
+ engine_started.set()
+ assert release_engine.wait(5), "test did not release sync engine"
+ output_path.write_text("1\n00:00:03,000 --> 00:00:04,000\nSynced " + source)
+ if controls.fail:
+ raise RuntimeError("controlled sync failure")
+ return {"offset_seconds": 0, "framerate_scale_factor": 1}
+
+ monkeypatch.setattr(subsyncer.SubSyncer, "_run_ffsubsync_engine", engine)
+
+ def submit(media_type, content="Uploaded", owner=7, **kwargs):
+ return upload.manual_upload_subtitle(
+ path=str(video), language="en", forced=kwargs.pop("forced", False),
+ hi=kwargs.pop("hi", False), media_type=media_type,
+ subtitle=BytesIO(f"1\n00:00:01,000 --> 00:00:02,000\n{content}\n".encode()),
+ filename="upload.srt", audio_language=[],
+ sonarrSeriesId=kwargs.pop("sonarrSeriesId", 10 if media_type == "series" else None),
+ sonarrEpisodeId=20 if media_type == "series" else None,
+ radarrId=30 if media_type == "movie" else None,
+ arr_instance_id=owner, **kwargs)
+
+ threads = []
+
+ def start(job_id=None):
+ job = next(job for job in queue.jobs_pending_queue if job_id is None or job.job_id == job_id)
+ queue.jobs_pending_queue.remove(job)
+ queue.jobs_running_queue.append(job)
+ thread = Thread(target=queue._run_job, args=(job,))
+ threads.append(thread)
+ thread.start()
+ return job, thread
+
+ def remove(media_type):
+ return delete.delete_subtitles(media_type=media_type, language="en", forced=False, hi=False,
+ media_path=str(video), subtitles_path=str(video.with_suffix(".en.srt")),
+ sonarr_series_id=10, sonarr_episode_id=20, radarr_id=30, arr_instance_id=7)
+
+ yield SimpleNamespace(submit=submit, start=start, queue=queue, events=events, indexes=indexes,
+ history=history, notifications=notifications, engine_started=engine_started,
+ release_engine=release_engine, video=video, remove=remove, controls=controls,
+ sync_history=sync_history, engine_calls=engine_calls, real_indexers=real_indexers)
+ release_engine.set()
+ for thread in threads:
+ thread.join(5)
+ assert not thread.is_alive()
+
+
+@pytest.mark.parametrize("media_type", ["movie", "series"])
+@pytest.mark.parametrize("failure", ["settings", "enqueue"])
+def test_saved_upload_refreshes_consumers_when_sync_setup_fails(upload_flow, monkeypatch, media_type, failure):
+ from app.config import settings
+ from subtitles import sync, upload
+
+ flow = upload_flow
+ refreshes = []
+ monkeypatch.setattr(settings.general, 'use_plex', True)
+ monkeypatch.setattr(settings.general, 'use_jellyfin', True)
+ for service in (settings.plex, settings.jellyfin):
+ monkeypatch.setattr(service, 'update_movie_library', True)
+ monkeypatch.setattr(service, 'update_series_library', True)
+ monkeypatch.setattr(settings.plex, 'set_episode_added', False)
+ monkeypatch.setattr(settings.plex, 'set_movie_added', False)
+
+ def consumer(name):
+ def refresh(*args, **kwargs):
+ assert flow.indexes, 'consumers must see an indexed source publication'
+ refreshes.append((name, args, kwargs))
+ return refresh
+
+ for name in ('notify_sonarr', 'notify_radarr', 'plex_refresh_item', 'jellyfin_refresh_item'):
+ monkeypatch.setattr(upload, name, consumer(name))
+
+ def fail(*args, **kwargs):
+ raise RuntimeError('controlled sync setup failure')
+
+ if failure == 'settings':
+ monkeypatch.setattr(sync, '_resolve_subsync_overrides', fail)
+ else:
+ monkeypatch.setattr(flow.queue, 'add_job_from_function', fail)
+
+ with pytest.raises(RuntimeError, match='controlled sync setup failure'):
+ flow.submit(media_type, job_id='existing-upload-job')
+
+ assert 'Uploaded' in flow.video.with_suffix('.en.srt').read_text()
+ assert flow.indexes
+ assert len(flow.history) == 1
+ assert not flow.queue.jobs_pending_queue
+ assert [name for name, args, kwargs in refreshes] == [
+ 'notify_sonarr' if media_type == 'series' else 'notify_radarr',
+ 'plex_refresh_item', 'jellyfin_refresh_item']
+ assert refreshes[0][1] == (10 if media_type == 'series' else 30,)
+ assert refreshes[1][2]['is_movie'] == (media_type == 'movie')
+ assert refreshes[2][2]['is_movie'] == (media_type == 'movie')
+
+
+@pytest.mark.parametrize("media_type", ["movie", "series"])
+def test_saved_upload_is_visible_and_upload_completes_before_sync(upload_flow, media_type):
+ flow = upload_flow
+ upload_id = flow.submit(media_type)
+ upload_job, upload_thread = flow.start()
+ upload_thread.join(1)
+
+ assert (flow.video.parent / "Video.en.srt").is_file()
+ assert upload_job.status != "failed"
+ assert flow.indexes, "the saved subtitle is still hidden while sync is pending/running"
+ assert upload_job.status == "completed"
+ assert upload_job.job_returned_value == ("", 204)
+ assert len(flow.history) == 1
+ assert len(flow.queue.jobs_pending_queue) == 1
+ sync_job, sync_thread = flow.start()
+ assert flow.engine_started.wait(2)
+ assert sync_job.job_id != upload_id
+ assert sync_job.is_progress
+ assert sync_job.status == "running"
+ assert "Uploaded" in flow.indexes[-1][1]["Video.en.srt"]
+ flow.release_engine.set()
+ sync_thread.join(3)
+ assert sync_job.status == "completed"
+ assert "Synced" in flow.indexes[-1][1]["Video.en.srt"]
+ assert len(flow.history) == 1
+ assert sum("arr_client" in kwargs for _, kwargs in flow.notifications) == 2
+ assert sum("arr_instance_id" in kwargs for _, kwargs in flow.notifications) == 1
+ assert len(flow.sync_history) == 1
+
+
+@pytest.mark.parametrize("media_type", ["movie", "series"])
+@pytest.mark.parametrize("output_mode", ["overwrite", "keep_all"])
+@pytest.mark.parametrize("running", [False, True], ids=["queued", "running"])
+@pytest.mark.parametrize("change", ["upload", "delete"])
+def test_stale_sync_does_not_replace_a_new_upload_or_restore_a_deleted_file(
+ upload_flow, monkeypatch, media_type, output_mode, running, change):
+ from app.config import settings
+
+ monkeypatch.setattr(settings.subsync, "output_mode", output_mode)
+ flow = upload_flow
+ flow.submit(media_type)
+ job, thread = flow.start()
+ thread.join(2)
+ assert job.status == "completed"
+ sync_id = flow.queue.jobs_pending_queue[0].job_id
+ if running:
+ sync_job, sync_thread = flow.start(sync_id)
+ assert flow.engine_started.wait(2)
+
+ source = flow.video.parent / "Video.en.srt"
+ if change == "upload":
+ second_upload_id = flow.submit(media_type, content="New upload")
+ second_job, second_thread = flow.start(second_upload_id)
+ second_thread.join(2)
+ assert second_job.status == "completed"
+ assert "New upload" in source.read_text()
+ else:
+ source.unlink()
+
+ flow.release_engine.set()
+ if not running:
+ sync_job, sync_thread = flow.start(sync_id)
+ sync_thread.join(2)
+ assert sync_job.status == "completed"
+ if not running:
+ assert not flow.engine_started.is_set(), "outdated queued sync should skip its engines"
+ assert not (flow.video.parent / "Video.en.ffsubsync.srt").exists()
+ if change == "upload":
+ assert "New upload" in source.read_text()
+ assert "Synced" not in source.read_text()
+ latest_sync, latest_thread = flow.start()
+ latest_thread.join(2)
+ assert latest_sync.status == "completed"
+ output = source if output_mode == "overwrite" else source.with_name("Video.en.ffsubsync.srt")
+ assert "Synced" in output.read_text()
+ assert "New upload" in output.read_text()
+ else:
+ assert not source.exists()
+ assert not list(flow.video.parent.glob(".bazarr-sync-*"))
+
+
+@pytest.mark.parametrize("media_type", ["movie", "series"])
+def test_delete_during_sync_publication_cannot_be_undone(upload_flow, monkeypatch, media_type):
+ from subtitles.tools import subsync_engines
+
+ flow = upload_flow
+ flow.submit(media_type)
+ upload_job, upload_thread = flow.start()
+ upload_thread.join(2)
+ assert upload_job.status == "completed"
+ publishing, publish = Event(), Event()
+ real_replace = subsync_engines.os.replace
+
+ def paused_replace(source, destination):
+ publishing.set()
+ assert publish.wait(5)
+ return real_replace(source, destination)
+
+ monkeypatch.setattr(subsync_engines.os, "replace", paused_replace)
+ flow.release_engine.set()
+ sync_job, sync_thread = flow.start()
+ assert publishing.wait(2)
+ deletion = Thread(target=flow.remove, args=(media_type,))
+ deletion.start()
+ try:
+ deletion.join(0.1)
+ assert deletion.is_alive(), "deletion must serialize with the checked output publication"
+ finally:
+ publish.set()
+ sync_thread.join(2)
+ deletion.join(2)
+ assert not deletion.is_alive()
+ assert not flow.video.with_suffix(".en.srt").exists()
+
+
+@pytest.mark.parametrize("media_type", ["movie", "series"])
+@pytest.mark.parametrize("outcome", ["failure", "cancel", "disabled", "forced", "threshold"])
+def test_optional_sync_failure_or_skip_keeps_the_successful_upload(upload_flow, monkeypatch, media_type, outcome):
+ from app.config import settings
+
+ flow = upload_flow
+ if outcome == "disabled":
+ monkeypatch.setattr(settings.subsync, "use_subsync", False)
+ if outcome == "threshold":
+ threshold = "subsync_threshold" if media_type == "series" else "subsync_movie_threshold"
+ monkeypatch.setattr(settings.subsync, "use_" + threshold, True)
+ monkeypatch.setattr(settings.subsync, threshold, 99)
+ flow.controls.fail = outcome == "failure"
+ flow.submit(media_type, forced=outcome == "forced")
+ upload_job, upload_thread = flow.start()
+ upload_thread.join(2)
+ assert upload_job.status == "completed"
+ before = flow.indexes[-1]
+ if outcome == "disabled":
+ assert not flow.queue.jobs_pending_queue
+ else:
+ sync_job, sync_thread = flow.start()
+ if outcome in ("cancel", "failure"):
+ assert flow.engine_started.wait(2)
+ if outcome == "cancel":
+ assert flow.queue.cancel_running_job(sync_job.job_id)
+ flow.release_engine.set()
+ sync_thread.join(2)
+ assert sync_job.status == "completed"
+ if outcome == "cancel":
+ assert sync_job.progress_message == "Cancelled by user"
+ assert sync_job.job_returned_value is not True
+ assert flow.indexes[-1] == before
+ assert len(flow.history) == 1
+ assert len(flow.notifications) == 2
+ assert not flow.sync_history
+ assert not list(flow.video.parent.glob(".bazarr-sync-*"))
+
+
+@pytest.mark.parametrize("media_type", ["movie", "series"])
+def test_upload_preserves_postprocessing_hi_and_notification_policy(upload_flow, monkeypatch, media_type):
+ from app.config import settings
+ from subtitles import processing, upload
+
+ flow = upload_flow
+ monkeypatch.setattr(settings.general, "dont_notify_manual_actions", True)
+ monkeypatch.setattr(processing, "_postprocessing_config", lambda kind, owner: (True, "process", False, 0))
+ monkeypatch.setattr(upload, "pp_replace", lambda *args: "process")
+ monkeypatch.setattr(upload, "set_chmod", lambda **kwargs: None)
+
+ def postprocess(command, video_path, subtitle_path=None):
+ assert command == "process"
+ flow.video.with_suffix(".en.hi.srt").write_text("1\n00:00:01,000 --> 00:00:02,000\nProcessed\n")
+
+ monkeypatch.setattr(upload, "postprocessing", postprocess)
+ flow.submit(media_type, hi=True)
+ upload_job, upload_thread = flow.start()
+ upload_thread.join(2)
+ assert upload_job.status == "completed"
+ assert "Processed" in flow.indexes[-1][1]["Video.en.hi.srt"]
+ flow.release_engine.set()
+ sync_job, sync_thread = flow.start()
+ sync_thread.join(2)
+ assert sync_job.status == "completed"
+ assert "Synced" in flow.indexes[-1][1]["Video.en.hi.srt"]
+ assert "Processed" in flow.indexes[-1][1]["Video.en.hi.srt"]
+ assert sum("arr_client" in kwargs for _, kwargs in flow.notifications) == 2
+ assert not any("arr_instance_id" in kwargs for _, kwargs in flow.notifications)
+ assert flow.sync_history[0]["hi"] is True
+
+
+@pytest.mark.parametrize("media_type", ["movie", "series"])
+def test_real_index_and_settings_stay_with_the_upload_owner(upload_flow, schema_session, monkeypatch, media_type):
+ from app.config import settings
+ from app.database import TableEpisodes, TableMovies, TableShows, select
+ from arr_instances import resolution
+ from subzero.language import Language
+ from subtitles import upload
+ from subtitles.indexer import movies, series
+ from subtitles.tools import subsyncer
+
+ flow = upload_flow
+ module = series if media_type == "series" else movies
+ table = TableEpisodes if media_type == "series" else TableMovies
+ for owner in (7, 8):
+ if media_type == "series":
+ schema_session.add(TableShows(id=owner, arr_instance_id=owner, sonarrSeriesId=10,
+ title="Show", path=str(flow.video.parent), profileId=None))
+ schema_session.flush()
+ row = TableEpisodes(id=owner, arr_instance_id=owner, series_id=owner,
+ sonarrSeriesId=10, sonarrEpisodeId=20, title="Episode", path=str(flow.video),
+ season=1, episode=1, subtitles="[]")
+ else:
+ row = TableMovies(id=owner, arr_instance_id=owner, radarrId=30, title="Movie",
+ path=str(flow.video), tmdbId=str(owner), profileId=None, subtitles="[]")
+ schema_session.add(row)
+ schema_session.commit()
+ monkeypatch.setattr(upload, "database", schema_session)
+ monkeypatch.setattr(module, "database", schema_session)
+ monkeypatch.setattr(settings.general, "use_embedded_subs", False)
+ monkeypatch.setattr(settings.general, "subfolder", "current")
+ monkeypatch.setattr(module, "get_language_set", lambda: {Language.fromietf("en")})
+ monkeypatch.setattr(module.core, "CUSTOM_PATHS", [])
+ missing = "list_missing_subtitles" if media_type == "series" else "list_missing_subtitles_movies"
+ monkeypatch.setattr(module, missing, lambda *a, **k: None)
+ monkeypatch.setattr(module, "event_stream", lambda **kwargs: None)
+ real_index = flow.real_indexers[media_type]
+
+ def index(*args, **kwargs):
+ result = real_index(*args, **kwargs)
+ flow.indexes.append((kwargs["arr_instance_id"], result))
+ return result
+
+ monkeypatch.setattr(module, "store_subtitles" if media_type == "series" else "store_subtitles_movie", index)
+ resolution._subtitle_settings_cache[7] = {"subsync": {"use_subsync": False}}
+ resolution._subtitle_settings_cache[8] = {"subsync": {
+ "use_subsync": True, "enabled_engines": ["alass"], "max_offset_seconds": 17,
+ "use_subsync_threshold": True, "subsync_threshold": 100,
+ "use_subsync_movie_threshold": True, "subsync_movie_threshold": 100,
+ }}
+ monkeypatch.setattr(settings.subsync, "use_subsync", False)
+ monkeypatch.setattr(settings.subsync, "output_mode", "keep_all")
+ external_calls = []
+
+ def external(self, engine, output_path, video_path):
+ external_calls.append(engine)
+ output_path.write_text("1\n00:00:03,000 --> 00:00:04,000\nSynced\n")
+ return {"offset_seconds": 16, "framerate_scale_factor": 1}
+
+ monkeypatch.setattr(subsyncer.SubSyncer, "_run_external_engine", external)
+ flow.submit(media_type, owner=8)
+
+ def run_next():
+ job = flow.queue.jobs_pending_queue.popleft()
+ flow.queue.jobs_running_queue.append(job)
+ assert flow.queue._run_job(job)
+ return job
+
+ upload_job = run_next()
+ assert upload_job.job_returned_value == ("", 204)
+ before = ast.literal_eval(schema_session.execute(select(table.subtitles).where(table.id == 8)).scalar())
+ assert len(before) == 1 and before[0][0] == "en"
+ assert schema_session.execute(select(table.subtitles).where(table.id == 7)).scalar() == "[]"
+ sync_job = run_next()
+ assert sync_job.job_returned_value is True
+ after = ast.literal_eval(schema_session.execute(select(table.subtitles).where(table.id == 8)).scalar())
+ assert {row[0] for row in after} == {"en", "en:sync-alass"}
+ assert schema_session.execute(select(table.subtitles).where(table.id == 7)).scalar() == "[]"
+ assert external_calls == ["alass"]
+ assert all(row[0] == 8 for row in flow.indexes)
+ assert flow.history[0][1]["arr_instance_id"] == 8
+ assert flow.sync_history[0]["arr_instance_id"] == 8
+
+
+def test_unrelated_upload_finishes_while_other_media_postprocessing_is_blocked(upload_flow, monkeypatch):
+ from subtitles import processing, upload
+
+ flow = upload_flow
+ blocked, unblock, second_entered = Event(), Event(), Event()
+
+ def config(kind, owner):
+ if owner == 8:
+ second_entered.set()
+ return (owner == 7, 'controlled', False, 0)
+
+ def postprocess(command, video_path, subtitle_path=None):
+ blocked.set()
+ assert unblock.wait(5), 'probe failed to release postprocessing'
+
+ monkeypatch.setattr(processing, '_postprocessing_config', config)
+ monkeypatch.setattr(upload, 'pp_replace', lambda *args: 'controlled')
+ monkeypatch.setattr(upload, 'postprocessing', postprocess)
+ monkeypatch.setattr(upload, 'set_chmod', lambda **kwargs: None)
+ flow.submit('movie', owner=7)
+ first_job, first_thread = flow.start()
+ assert blocked.wait(2)
+ other_video = flow.video.with_name('Unrelated.mkv')
+ other_video.touch()
+ second_id = upload.manual_upload_subtitle(
+ path=str(other_video), language='en', forced=False, hi=False, media_type='movie',
+ subtitle=BytesIO(b'1\n00:00:01,000 --> 00:00:02,000\nOther media\n'),
+ filename='other.srt', audio_language=[], radarrId=31, arr_instance_id=8)
+ second_job, second_thread = flow.start(second_id)
+ try:
+ assert second_entered.wait(2), 'second upload did not start'
+ second_thread.join(0.25)
+ completed_before_release = second_job.status == 'completed'
+ saved_before_release = other_video.with_suffix('.en.srt').exists()
+ finally:
+ unblock.set()
+ first_thread.join(2)
+ second_thread.join(2)
+ assert not first_thread.is_alive() and not second_thread.is_alive()
+ assert first_job.status == second_job.status == 'completed'
+ assert completed_before_release and saved_before_release, 'unrelated upload was blocked by another media postprocessing lock'
+
+
+@pytest.mark.parametrize("output_mode", ["overwrite", "keep_all"])
+def test_cancel_while_finished_engine_waits_for_publication_preserves_upload(upload_flow, monkeypatch, output_mode):
+ from app.config import settings
+ monkeypatch.setattr(settings.subsync, "output_mode", output_mode)
+ from subtitles.tools import subsync_engines, subsyncer
+
+ flow = upload_flow
+ flow.submit('movie')
+ upload_job, upload_thread = flow.start()
+ upload_thread.join(2)
+ assert upload_job.status == 'completed'
+ original = flow.video.with_suffix('.en.srt').read_bytes()
+ finished_checkpoint = Event()
+ real_report = subsyncer.SubSyncer._report_progress
+
+ def report(self, message, value, total):
+ result = real_report(self, message, value, total)
+ if message.startswith('Finished '):
+ finished_checkpoint.set()
+ return result
+
+ monkeypatch.setattr(subsyncer.SubSyncer, '_report_progress', report)
+ with subsync_engines.subtitle_write_lock(str(flow.video), str(flow.video.parent)):
+ flow.release_engine.set()
+ sync_job, sync_thread = flow.start()
+ assert finished_checkpoint.wait(2), 'engine did not reach publication boundary'
+ assert flow.video.with_suffix('.en.srt').read_bytes() == original
+ assert flow.queue.cancel_running_job(sync_job.job_id)
+ sync_thread.join(2)
+ assert not sync_thread.is_alive()
+ assert sync_job.progress_message == 'Cancelled by user'
+ assert flow.video.with_suffix('.en.srt').read_bytes() == original
+ assert not flow.video.with_suffix('.en.ffsubsync.srt').exists()
+ assert not list(flow.video.parent.glob('.bazarr-sync-*'))
+ assert not flow.sync_history
+
+
+@pytest.mark.parametrize("media_type", ["movie", "series"])
+def test_sync_reindex_cannot_restore_a_listing_after_successful_delete(upload_flow, monkeypatch, media_type):
+ from sqlalchemy import create_engine
+ from sqlalchemy.orm import sessionmaker
+ from sqlalchemy.sql.dml import Update
+ from app.config import settings
+ from app.database import Base, TableEpisodes, TableMovies, TableShows, select
+ from subzero.language import Language
+ from subtitles import upload
+ from subtitles.indexer import movies, series
+ from subtitles.tools import delete
+
+ flow = upload_flow
+ module = series if media_type == "series" else movies
+ table = TableEpisodes if media_type == "series" else TableMovies
+ engine = create_engine(f"sqlite:///{flow.video.parent / 'index.sqlite'}")
+ Base.metadata.create_all(engine)
+ Session = sessionmaker(bind=engine)
+ with Session.begin() as session:
+ if media_type == "series":
+ session.add(TableShows(id=7, arr_instance_id=7, sonarrSeriesId=10,
+ title="Show", path=str(flow.video.parent), profileId=None))
+ session.flush()
+ session.add(TableEpisodes(id=7, arr_instance_id=7, series_id=7, sonarrSeriesId=10,
+ sonarrEpisodeId=20, title="Episode", path=str(flow.video),
+ season=1, episode=1, subtitles="[]"))
+ else:
+ session.add(TableMovies(id=7, arr_instance_id=7, radarrId=30, title="Movie",
+ path=str(flow.video), tmdbId="1", profileId=None, subtitles="[]"))
+ before_commit, commit = Event(), Event()
+ controls = {"armed": False}
+
+ class Database:
+ def execute(self, statement, *args, **kwargs):
+ if controls["armed"] and isinstance(statement, Update):
+ controls["armed"] = False
+ before_commit.set()
+ assert commit.wait(5)
+ with Session.begin() as session:
+ result = session.execute(statement, *args, **kwargs)
+ return result.freeze()() if statement.is_select else result
+
+ db = Database()
+ for item in (upload, delete, module):
+ monkeypatch.setattr(item, "database", db)
+ monkeypatch.setattr(settings.general, "use_embedded_subs", False)
+ monkeypatch.setattr(settings.general, "subfolder", "current")
+ monkeypatch.setattr(module, "get_language_set", lambda: {Language.fromietf("en")})
+ missing = "list_missing_subtitles" if media_type == "series" else "list_missing_subtitles_movies"
+ monkeypatch.setattr(module, missing, lambda *a, **k: None)
+ monkeypatch.setattr(module, "event_stream", lambda **k: None)
+
+ def index(*args, **kwargs):
+ result = flow.real_indexers[media_type](*args, **kwargs)
+ flow.indexes.append((kwargs["arr_instance_id"], result))
+ return result
+
+ index_name = "store_subtitles" if media_type == "series" else "store_subtitles_movie"
+ monkeypatch.setattr(module, index_name, index)
+ monkeypatch.setattr(delete, index_name, index)
+ deletion = None
+ try:
+ flow.submit(media_type)
+ upload_job, upload_thread = flow.start()
+ upload_thread.join(2)
+ assert upload_job.status == "completed"
+ assert len(ast.literal_eval(db.execute(select(table.subtitles)).scalar())) == 1
+ controls["armed"] = True
+ flow.release_engine.set()
+ sync_job, sync_thread = flow.start()
+ assert before_commit.wait(2)
+ deleted = []
+ deletion = Thread(target=lambda: deleted.append(flow.remove(media_type)))
+ deletion.start()
+ deletion.join(0.2)
+ commit.set()
+ sync_thread.join(2)
+ deletion.join(2)
+ assert not deletion.is_alive() and not sync_thread.is_alive()
+ assert sync_job.status == "completed"
+ assert deleted == [True]
+ assert not flow.video.with_suffix(".en.srt").exists()
+ assert ast.literal_eval(db.execute(select(table.subtitles)).scalar()) == []
+ finally:
+ commit.set()
+ if deletion:
+ deletion.join(2)
+ engine.dispose()
+
+
+@pytest.mark.parametrize("media_type", ["movie", "series"])
+@pytest.mark.parametrize("output_mode", ["overwrite", "keep_all"])
+def test_review_sync_publication_refreshes_external_consumers(upload_flow, monkeypatch, media_type, output_mode):
+ from app.config import settings
+ from subtitles import upload
+
+ flow = upload_flow
+ monkeypatch.setattr(settings.subsync, "output_mode", output_mode)
+ monkeypatch.setattr(settings.general, "use_plex", True)
+ monkeypatch.setattr(settings.general, "use_jellyfin", True)
+ for name in ("update_series_library", "update_movie_library"):
+ monkeypatch.setattr(settings.plex, name, True)
+ monkeypatch.setattr(settings.jellyfin, name, True)
+ monkeypatch.setattr(settings.plex, "set_movie_added", False)
+ monkeypatch.setattr(settings.plex, "set_episode_added", False)
+ refreshes = []
+
+ def refresh(consumer, *args, **kwargs):
+ refreshes.append((consumer, {path.name: path.read_text() for path in flow.video.parent.glob("*.srt")}))
+
+ for name in ("notify_sonarr", "notify_radarr", "plex_refresh_item", "jellyfin_refresh_item"):
+ monkeypatch.setattr(upload, name, lambda *args, _consumer=name, **kwargs: refresh(_consumer, *args, **kwargs))
+ flow.submit(media_type)
+ upload_job, upload_thread = flow.start()
+ upload_thread.join(2)
+ assert upload_job.status == "completed"
+ assert len(refreshes) == 3
+ flow.release_engine.set()
+ sync_job, sync_thread = flow.start()
+ sync_thread.join(3)
+ assert sync_job.status == "completed"
+ assert len(refreshes) == 6, "external consumers were not refreshed after sync publication"
+ expected = "Video.en.ffsubsync.srt" if output_mode == "keep_all" else "Video.en.srt"
+ assert all("Synced" in files[expected] for _, files in refreshes[3:])
+ assert len(flow.history) == 1
+ assert len(flow.notifications) == 1, "sync publication repeated the upload notification"
+
+
+def test_review_upload_sync_uses_resolved_series_id(upload_flow):
+ flow = upload_flow
+ flow.submit("series", sonarrSeriesId=999)
+ upload_job, upload_thread = flow.start()
+ upload_thread.join(2)
+ assert upload_job.status == "completed"
+ sync_job = flow.queue.jobs_pending_queue[0]
+ assert sync_job.kwargs["sonarr_series_id"] == 10, "unvalidated request ID reached synchronization"
+ assert sync_job.kwargs["callback"].keywords["sonarr_series_id"] == 10
+ assert sync_job.kwargs["sonarr_episode_id"] == 20
+ assert sync_job.kwargs["arr_instance_id"] == 7
+
+
+@pytest.mark.parametrize("media_type", ["movie", "series"])
+@pytest.mark.parametrize("outcome", ["success", "failure", "cancel", "disabled"])
+def test_review_replacement_upload_does_not_list_stale_generated_outputs(upload_flow, monkeypatch, media_type, outcome):
+ from app.config import settings
+
+ flow = upload_flow
+ monkeypatch.setattr(settings.subsync, "output_mode", "keep_all")
+ old_output = flow.video.with_suffix(".en.ffsubsync.srt")
+ old_bytes = b"1\n00:00:01,000 --> 00:00:02,000\nOld generated output\n"
+ old_output.write_bytes(old_bytes)
+ if outcome == "disabled":
+ monkeypatch.setattr(settings.subsync, "use_subsync", False)
+ flow.submit(media_type, content="Replacement upload")
+ upload_job, upload_thread = flow.start()
+ upload_thread.join(2)
+ assert upload_job.status == "completed"
+ assert "Replacement upload" in flow.indexes[-1][1]["Video.en.srt"]
+ assert old_output.name not in flow.indexes[-1][1], "the initial upload index exposed old generated text"
+ assert not old_output.exists()
+ assert any(path.read_bytes() == old_bytes for path in flow.video.parent.rglob("*") if path.is_file()), \
+ "old generated bytes were destroyed instead of quarantined"
+ if outcome == "disabled":
+ assert not flow.queue.jobs_pending_queue
+ return
+ flow.controls.fail = outcome == "failure"
+ sync_job, sync_thread = flow.start()
+ assert flow.engine_started.wait(2)
+ if outcome == "cancel":
+ flow.queue.cancel_running_job(sync_job.job_id)
+ flow.release_engine.set()
+ sync_thread.join(3)
+ assert not sync_thread.is_alive()
+ if outcome == "success":
+ assert "Replacement upload" in old_output.read_text()
+ assert "Old generated output" not in old_output.read_text()
+ else:
+ assert not old_output.exists()
+ assert old_output.name not in flow.indexes[-1][1]
+
+
+@pytest.mark.parametrize("media_type", ["movie", "series"])
+@pytest.mark.parametrize("running", [False, True], ids=["queued", "running"])
+def test_review_deleted_generated_destination_stays_deleted(upload_flow, monkeypatch, media_type, running):
+ from app.config import settings
+ from subtitles.tools import delete
+
+ flow = upload_flow
+ monkeypatch.setattr(settings.subsync, "output_mode", "keep_all")
+ destination = flow.video.with_suffix(".en.ffsubsync.srt")
+ destination.write_text("Old generated output")
+ flow.submit(media_type)
+ upload_job, upload_thread = flow.start()
+ upload_thread.join(2)
+ assert upload_job.status == "completed"
+ if running:
+ sync_job, sync_thread = flow.start()
+ assert flow.engine_started.wait(2)
+ delete.delete_subtitles(media_type=media_type, language="en", forced=False, hi=False,
+ media_path=str(flow.video), subtitles_path=str(destination),
+ sonarr_series_id=10, sonarr_episode_id=20, radarr_id=30, arr_instance_id=7)
+ assert not destination.exists()
+ flow.release_engine.set()
+ if not running:
+ sync_job, sync_thread = flow.start()
+ sync_thread.join(3)
+ assert not sync_thread.is_alive()
+ assert not destination.exists(), "background sync recreated an explicitly deleted generated destination"
+ assert destination.name not in flow.indexes[-1][1]
+
+
+@pytest.mark.parametrize("output_mode", ["overwrite", "keep_all"])
+@pytest.mark.parametrize("operation", ["edit", "edit-etag", "promote", "mods", "manual-sync", "google", "lingarr", "openrouter", "gemini", "manual-download", "auto-download", "postprocessing"])
+def test_review_editor_write_cannot_be_lost_at_sync_publication(upload_flow, monkeypatch, output_mode, operation):
+ import importlib
+ import os
+ import sys
+ from threading import current_thread
+ from flask import Flask
+ from app.config import settings
+ from subtitles.tools import subsync_engines
+
+ existing = sys.modules.get("api.subtitles.content")
+ if existing is not None and not getattr(existing, "__file__", None):
+ monkeypatch.delitem(sys.modules, "api.subtitles.content")
+ with monkeypatch.context() as importing:
+ importing.setattr("app.check_update.check_releases", lambda *args, **kwargs: None)
+ importing.setattr("app.announcements.get_announcements_to_file", lambda *args, **kwargs: None)
+ content = importlib.import_module("api.subtitles.content")
+ flow = upload_flow
+ monkeypatch.setattr(settings.subsync, "output_mode", output_mode)
+ source = flow.video.with_suffix(".en.srt")
+ output = flow.video.with_suffix(".en.ffsubsync.srt")
+ promotion = flow.video.with_suffix(".en.alass.srt")
+ user_text = "1\n00:00:01,000 --> 00:00:02,000\nUser selected text\n"
+ metadata = {"mediaPath": str(flow.video), "mediaId": 30, "arrInstanceId": 7}
+ monkeypatch.setattr(content, "resolve_subtitle_path", lambda media_type, media_id, language, **kwargs:
+ (str(promotion if language == "en:sync-alass" else source), metadata))
+ monkeypatch.setattr(content, "store_subtitles_movie", lambda *args, **kwargs: None)
+ monkeypatch.setattr(content, "event_stream", lambda **kwargs: None)
+ monkeypatch.setattr(content, "history_log_movie", lambda **kwargs: None)
+ monkeypatch.setattr(content, "language_from_alpha2", lambda value: "English")
+ reached_publication, release_publication, writer_started, writer_done = Event(), Event(), Event(), Event()
+ real_replace = os.replace
+ published_destination = output if output_mode == "keep_all" else source
+
+ def replace(temporary, destination):
+ if (Path(destination) == published_destination and Path(temporary).name.startswith(".bazarr-sync-")
+ and current_thread().name != "competing-subtitle-writer"):
+ reached_publication.set()
+ assert release_publication.wait(5), "test did not release sync publication"
+ return real_replace(temporary, destination)
+
+ monkeypatch.setattr(subsync_engines.os, "replace", replace)
+ flow.submit("movie")
+ upload_job, upload_thread = flow.start()
+ upload_thread.join(2)
+ assert upload_job.status == "completed"
+ promotion.write_text(user_text)
+ initial_etag = content.generate_etag(str(source))
+ sync_job, sync_thread = flow.start()
+ assert flow.engine_started.wait(2)
+ flow.release_engine.set()
+ writer_results = []
+ writer_errors = []
+
+ def write():
+ try:
+ writer_started.set()
+ if operation in ("edit", "edit-etag"):
+ app = Flask(__name__)
+ with app.test_request_context(json={"content": user_text},
+ headers={"If-Match": initial_etag} if operation == "edit-etag" else {}):
+ response = content._save_subtitle_content("movie", 30, "en", arr_instance_id=7)
+ writer_results.append(response.status_code if hasattr(response, "status_code") else response[1])
+ elif operation == "promote":
+ _, status = content.promote_sync_subtitle("movie", 30, "en", "en:sync-alass", arr_instance_id=7)
+ writer_results.append(status)
+ elif operation == "mods":
+ from subtitles.tools import mods
+ monkeypatch.setattr(mods.Subtitle, "get_modified_content", lambda self, **kwargs: user_text.encode())
+ mods.subtitles_apply_mods("en", str(source), [], str(flow.video), arr_instance_id=7)
+ writer_results.append(200)
+ elif operation == "manual-sync":
+ from subtitles.tools import subsyncer
+
+ def external(self, engine, output_path, video_path):
+ output_path.write_text(user_text)
+ return {"offset_seconds": 0}
+
+ monkeypatch.setattr(subsyncer.SubSyncer, "_run_external_engine", external)
+ result = subsyncer.SubSyncer().sync(
+ str(flow.video), str(source), "en", False, False, 60, False, False,
+ output_mode="overwrite", enabled_engines=["alass"], write_history=False)
+ writer_results.append(200 if result.success else 500)
+ elif operation in ("manual-download", "auto-download"):
+ from subtitles import manual, download, pool
+ from subliminal_patch.subtitle import Subtitle
+ from subzero.language import Language
+
+ subtitle = Subtitle(Language("eng"), original_format=True)
+ subtitle.content = user_text.encode()
+ subtitle.provider_name = "fixture"
+ subtitle.matches = set()
+ video = Mock(original_path=str(flow.video))
+ provider_pool = Mock(providers=["fixture"], discarded_providers=[])
+ monkeypatch.setattr(pool, "_update_pool", lambda *args, **kwargs: False)
+ module = manual if operation == "manual-download" else download
+ monkeypatch.setattr(module, "get_video", lambda *args, **kwargs: video)
+ monkeypatch.setattr(module, "_get_pool", lambda *args, **kwargs: provider_pool)
+ monkeypatch.setattr(module, "get_target_folder", lambda *args, **kwargs: None)
+ monkeypatch.setattr(module, "process_subtitle", lambda **kwargs: "saved")
+ monkeypatch.setattr(module.subliminal, "region", Mock())
+ if operation == "manual-download":
+ monkeypatch.setattr(manual.subtitle_cache, "get", lambda *args: subtitle)
+ monkeypatch.setattr(manual, "download_subtitles", lambda *args: None)
+ result = manual.manual_download_subtitle(
+ str(flow.video), [], False, False, "cached", "fixture", None, "Video", "movie", True, 1,
+ arr_instance_id=7)
+ assert result == "saved"
+ else:
+ monkeypatch.setattr(download, "_get_language_obj", lambda **kwargs: {Language("eng")})
+ monkeypatch.setattr(download, "get_profiles_list", lambda **kwargs: {"originalFormat": True})
+ monkeypatch.setattr(download, "download_best_subtitles", lambda **kwargs: {video: [subtitle]})
+ monkeypatch.setattr(download, "clear_mismatch_for_video", lambda *args, **kwargs: None)
+ result = list(download.generate_subtitles(
+ str(flow.video), [("en", False, False)], [], None, "Video", "movie", 1, arr_instance_id=7))
+ assert result == ["saved"]
+ writer_results.append(200)
+ elif operation == "postprocessing":
+ from subtitles import post_processing
+
+ def popen(*args, **kwargs):
+ source.write_text(user_text)
+ return Mock(communicate=lambda: ("", ""))
+
+ monkeypatch.setattr(post_processing.subprocess, "Popen", popen)
+ post_processing.postprocessing("fixture command", str(flow.video))
+ writer_results.append(200)
+ else:
+ module = importlib.import_module(f"subtitles.tools.translate.services.{operation}_translator")
+ classes = {"google": "GoogleTranslatorService", "lingarr": "LingarrTranslatorService",
+ "openrouter": "OpenRouterTranslatorService", "gemini": "GeminiTranslatorService"}
+ service = getattr(module, classes[operation])(
+ source_srt_file=str(promotion), dest_srt_file=str(source), lang_obj=None,
+ to_lang="eng", from_lang="en", media_type="movie", video_path=str(flow.video),
+ orig_to_lang="en", forced=False, hi=False, sonarr_series_id=None,
+ sonarr_episode_id=None, radarr_id=30)
+ monkeypatch.setattr(module, "jobs_queue", Mock())
+ monkeypatch.setattr(module, "history_log_movie", Mock())
+ monkeypatch.setattr(module, "create_process_result", Mock())
+ monkeypatch.setattr(module, "add_translator_info", lambda *args: None)
+ if operation == "google":
+ monkeypatch.setattr(service, "_translate_text", lambda *args: "User selected text")
+ elif operation == "lingarr":
+ monkeypatch.setattr(service, "_translate_content", lambda *args, **kwargs:
+ [{"position": 0, "line": "User selected text"}])
+ elif operation == "openrouter":
+ monkeypatch.setattr(service, "_submit_and_poll", lambda *args, **kwargs:
+ [{"position": 0, "line": "User selected text"}])
+ else:
+ monkeypatch.setattr(service, "_get_configured_api_keys", lambda: [])
+ monkeypatch.setattr(service, "_select_next_api_key", lambda: "fixture")
+ monkeypatch.setattr(service, "_check_saved_progress", lambda: None)
+ monkeypatch.setattr(module, "get_description", lambda *args, **kwargs: "")
+ monkeypatch.setattr(service, "_translate_with_gemini", lambda:
+ Path(service.output_file).write_text(user_text))
+ service.translate(job_id=123)
+ writer_results.append(200)
+
+ except BaseException as exc:
+ writer_errors.append(exc)
+ finally:
+ writer_done.set()
+
+ writer = Thread(target=write, name="competing-subtitle-writer")
+ try:
+ assert reached_publication.wait(2)
+ writer.start()
+ assert writer_started.wait(2)
+ writer_done.wait(0.3)
+ release_publication.set()
+ sync_thread.join(3)
+ writer.join(3)
+ assert not writer.is_alive() and not sync_thread.is_alive()
+ assert not writer_errors
+ if operation == "edit-etag" and output_mode == "overwrite":
+ assert writer_results == [412]
+ assert "Synced" in source.read_text()
+ else:
+ assert writer_results == [204 if operation in ("edit", "edit-etag") else 200]
+ assert "User selected text" in source.read_text(), "sync publication overwrote the completed user write"
+ if output_mode == "keep_all":
+ assert not output.exists(), "an output for the superseded source remained available"
+ finally:
+ release_publication.set()
+ if writer.ident:
+ writer.join(3)
+
+
+@pytest.mark.parametrize("failure", ["cancel-before-engine", "setup-error", "settings-error"])
+def test_review_terminal_job_releases_publication_lease(upload_flow, monkeypatch, failure):
+ from subtitles import sync
+
+ flow = upload_flow
+ flow.submit("movie")
+ _, upload_thread = flow.start()
+ upload_thread.join(2)
+ job = flow.queue.jobs_pending_queue[0]
+ publication = job.kwargs["source_version"]
+ if failure == "settings-error":
+ monkeypatch.setattr(sync, "_resolve_subsync_overrides", Mock(side_effect=RuntimeError("controlled settings failure")))
+ elif failure == "setup-error":
+ monkeypatch.setattr(sync, "SubSyncer", Mock(side_effect=RuntimeError("controlled setup failure")))
+ else:
+ original = sync._report_progress
+
+ def report(*args, **kwargs):
+ flow.queue.cancel_running_job(job.job_id)
+ return original(*args, **kwargs)
+
+ monkeypatch.setattr(sync, "_report_progress", report)
+ _, thread = flow.start()
+ thread.join(3)
+ assert not thread.is_alive()
+ assert job.status in ("completed", "failed")
+ assert publication.state is None, "terminal Job kwargs retained the media coordinator"
+
+
+def test_review_partial_publication_refreshes_consumers_after_cancellation(upload_flow, monkeypatch):
+ from app.config import settings
+ from app.jobs_queue import JobCancelled
+ from subtitles.tools import subsyncer
+
+ flow = upload_flow
+ monkeypatch.setattr(settings.subsync, "output_mode", "keep_all")
+ monkeypatch.setattr(settings.subsync, "enabled_engines", ["ffsubsync", "alass"])
+ def cancel(self, **kwargs):
+ flow.queue.cancel_running_job(self.job_id)
+ raise JobCancelled()
+
+ monkeypatch.setattr(subsyncer.SubSyncer, "_run_external_engine", cancel)
+ flow.submit("movie")
+ _, thread = flow.start()
+ thread.join(2)
+ flow.release_engine.set()
+ job, thread = flow.start()
+ thread.join(3)
+ assert job.status == "completed" and job.cancelled
+ assert flow.video.with_suffix(".en.ffsubsync.srt").is_file()
+ assert sum("arr_client" in kwargs for _, kwargs in flow.notifications) == 2
+ assert sum("arr_instance_id" in kwargs for _, kwargs in flow.notifications) == 1
+ assert len(flow.history) == 1
+
+
+def test_review_failed_delete_preserves_existing_generated_output(upload_flow, monkeypatch):
+ import os
+ from subtitles.tools import delete
+
+ flow = upload_flow
+ source = flow.video.with_suffix(".en.srt")
+ output = flow.video.with_suffix(".en.ffsubsync.srt")
+ source.write_text("Base")
+ output.write_text("Valid generated output")
+ remove = os.remove
+
+ def reject(path):
+ if Path(path) == source:
+ raise PermissionError("controlled rejected delete")
+ return remove(path)
+
+ monkeypatch.setattr(delete.os, "remove", reject)
+ assert flow.remove("movie") is False
+ assert source.read_text() == "Base"
+ assert output.read_text() == "Valid generated output"
+
+
+@pytest.mark.parametrize("collision", [False, True], ids=["same-mapped-owner", "distinct-owners"])
+def test_review_shared_folder_quarantine_requires_unique_mapped_owner(upload_flow, schema_session, monkeypatch, collision):
+ from app import database as db_module
+ from app.database import TableMovies
+ from app.config import settings
+ from subtitles.tools.subsync_engines import quarantine_sync_outputs, SubtitlePublication, subtitle_source_version
+
+ flow = upload_flow
+ folder = flow.video.parent / "shared"
+ folder.mkdir()
+ other = flow.video.parent / "other" / flow.video.name
+ other.parent.mkdir()
+ other.touch()
+ source = folder / "Video.en.srt"
+ output = folder / "Video.en.ffsubsync.srt"
+ source.write_text("Base")
+ output.write_text("Existing generated bytes")
+ for owner, path in [(7, flow.video), (8, other if collision else flow.video)]:
+ schema_session.add(TableMovies(id=owner, arr_instance_id=owner, radarrId=30,
+ title="Movie", path=str(path), tmdbId=str(owner), subtitles="[]"))
+ schema_session.commit()
+ monkeypatch.setattr(db_module, "database", schema_session)
+ monkeypatch.setattr(settings.general, "subfolder", "absolute")
+ monkeypatch.setattr(settings.general, "subfolder_custom", str(folder))
+ quarantine_sync_outputs(str(flow.video), str(source))
+ publication = SubtitlePublication(str(flow.video), str(source), subtitle_source_version(source))
+ try:
+ if collision:
+ assert output.read_text() == "Existing generated bytes"
+ assert not publication.destination_unchanged(output), "ambiguous output remained eligible for overwrite"
+ from subtitles.indexer.utils import add_sync_engine_outputs
+ assert output.name not in add_sync_engine_outputs(str(folder), {}, video_path=str(flow.video))
+ else:
+ assert not output.exists()
+ assert publication.destination_unchanged(output)
+ assert any(p.read_text() == "Existing generated bytes" for p in folder.glob("*.bak"))
+ finally:
+ publication.release()
+
+
+def test_review_create_cannot_overwrite_a_later_upload(upload_flow, monkeypatch):
+ import importlib
+ from threading import current_thread
+ from flask import Flask
+ from app.config import settings
+
+ with monkeypatch.context() as importing:
+ importing.setattr("app.check_update.check_releases", lambda *args, **kwargs: None)
+ importing.setattr("app.announcements.get_announcements_to_file", lambda *args, **kwargs: None)
+ content = importlib.import_module("api.subtitles.content")
+ flow = upload_flow
+ monkeypatch.setattr(settings.subsync, "use_subsync", False)
+ monkeypatch.setattr(content, "database", Mock(execute=Mock(return_value=Mock(
+ first=Mock(return_value=SimpleNamespace(path=str(flow.video), id=30))))))
+ monkeypatch.setattr(content, "get_target_folder", lambda *args: None)
+ monkeypatch.setattr(content, "store_subtitles_movie", lambda *args, **kwargs: None)
+ monkeypatch.setattr(content, "event_stream", lambda **kwargs: None)
+ reached, release = Event(), Event()
+ mkstemp = content.tempfile.mkstemp
+
+ def pause(*args, **kwargs):
+ if current_thread().name == "create-subtitle":
+ reached.set()
+ assert release.wait(5)
+ return mkstemp(*args, **kwargs)
+
+ monkeypatch.setattr(content.tempfile, "mkstemp", pause)
+ results = []
+
+ def create():
+ with Flask(__name__).test_request_context(json={"language": "en", "format": "srt", "content": "Created first"}):
+ results.append(content._create_subtitle("movie", 30, arr_instance_id=7))
+
+ creator = Thread(target=create, name="create-subtitle")
+ creator.start()
+ try:
+ assert reached.wait(2)
+ flow.submit("movie", content="Uploaded later")
+ job, uploader = flow.start()
+ uploader.join(0.3)
+ release.set()
+ creator.join(3)
+ uploader.join(3)
+ assert results[0][1] == 201
+ assert job.status == "completed"
+ assert "Uploaded later" in flow.video.with_suffix(".en.srt").read_text()
+ finally:
+ release.set()
+ creator.join(3)
+
+
+def test_review_combine_waits_for_an_existing_publication(upload_flow, monkeypatch):
+ from subtitles.tools.combine import main
+ from subtitles.tools.combine.rules import SourcePaths
+ from subtitles.tools.subsync_engines import subtitle_write_lock
+
+ flow = upload_flow
+ first = flow.video.with_suffix(".en.srt")
+ second = flow.video.with_suffix(".hu.srt")
+ first.write_text("1\n00:00:01,000 --> 00:00:02,000\nFirst\n")
+ second.write_text("1\n00:00:01,000 --> 00:00:02,000\nSecond\n")
+ monkeypatch.setattr(main, "resolve_source_paths", lambda **kwargs: SourcePaths(str(first), [str(second)]))
+ monkeypatch.setattr(main, "_post_write", lambda *args: None)
+ output = flow.video.with_suffix(".en.combined-hu.srt")
+ results = []
+ finished = Event()
+
+ def combine():
+ results.append(main.try_combine_for_video(str(flow.video), "movie", languages=["en", "hu"], format="srt"))
+ finished.set()
+
+ with subtitle_write_lock(str(flow.video), str(flow.video.parent)):
+ worker = Thread(target=combine)
+ worker.start()
+ blocked = not finished.wait(0.3)
+ worker.join(3)
+ assert results[0].status == "built"
+ assert blocked, "combine published while another writer owned the publication lock"
+ assert output.is_file()
+
+
+@pytest.mark.parametrize("media_type", ["series", "movie"])
+def test_review_external_index_waits_for_publication(upload_flow, monkeypatch, media_type):
+ from subtitles.indexer import movies, series
+ from subtitles.tools.subsync_engines import subtitle_write_lock
+
+ flow = upload_flow
+ module = movies if media_type == "movie" else series
+ db = Mock()
+ db.execute.return_value.first.return_value = SimpleNamespace(arr_instance_id=7, subtitles="[]")
+ db.execute.return_value.all.return_value = []
+ monkeypatch.setattr(module, "database", db)
+ monkeypatch.setattr("app.config.settings.general.use_embedded_subs", False)
+ monkeypatch.setattr(module, "get_language_set", lambda: set())
+ monkeypatch.setattr(module, "event_stream", lambda **kwargs: None)
+ entered = Event()
+ monkeypatch.setattr(module, "search_external_subtitles", lambda *args, **kwargs: (entered.set() or {}))
+ errors = []
+
+ def index():
+ try:
+ flow.real_indexers[media_type](str(flow.video), str(flow.video), arr_instance_id=7)
+ except Exception as exc:
+ errors.append(exc)
+
+ with subtitle_write_lock(str(flow.video), str(flow.video.parent)):
+ worker = Thread(target=index)
+ worker.start()
+ entered_while_locked = entered.wait(0.3)
+ worker.join(3)
+ assert not worker.is_alive() and not errors
+ assert entered.is_set()
+ assert not entered_while_locked, "external scan ran inside another writer's publication transaction"
+
+
+def test_review_duplicate_enqueue_keeps_the_existing_job_lease(upload_flow):
+ from subtitles import sync
+
+ flow = upload_flow
+ flow.submit("movie")
+ _, thread = flow.start()
+ thread.join(2)
+ job = flow.queue.jobs_pending_queue[0]
+ publication = job.kwargs["source_version"]
+ assert sync.sync_subtitles(**job.kwargs) is False
+ assert list(flow.queue.jobs_pending_queue) == [job]
+ assert publication.state is not None, "duplicate rejection invalidated the original queued publication"
+ flow.release_engine.set()
+ _, thread = flow.start()
+ thread.join(3)
+ assert "Synced" in flow.video.with_suffix(".en.srt").read_text()
+ assert publication.state is None
+
+
+def test_review_removed_pending_job_does_not_retain_the_coordinator(upload_flow):
+ import gc
+ import weakref
+
+ flow = upload_flow
+ flow.submit("movie")
+ _, thread = flow.start()
+ thread.join(2)
+ job = flow.queue.jobs_pending_queue[0]
+ state = weakref.ref(job.kwargs["source_version"].state)
+ assert flow.queue.remove_job_from_pending_queue(job.job_id)
+ del job
+ gc.collect()
+ assert state() is None
+
+
+@pytest.mark.parametrize("media_type", ["series", "movie"])
+def test_review_notification_failure_does_not_strand_upload_sync(upload_flow, monkeypatch, media_type):
+ from subtitles import upload
+
+ flow = upload_flow
+ name = "send_notifications" if media_type == "series" else "send_notifications_movie"
+ monkeypatch.setattr(upload, name, Mock(side_effect=RuntimeError("controlled notification failure")))
+ flow.submit(media_type)
+ job, thread = flow.start()
+ thread.join(2)
+ assert job.status == "completed"
+ assert len(flow.queue.jobs_pending_queue) == 1
+ flow.release_engine.set()
+ _, thread = flow.start()
+ thread.join(3)
+ assert "Synced" in flow.video.with_suffix(".en.srt").read_text()
+
+
+@pytest.fixture
+def review_translator(upload_flow, monkeypatch, request):
+ import importlib
+
+ flow = upload_flow
+ name, existing = request.param if isinstance(request.param, tuple) else (request.param, True)
+ module = importlib.import_module(f"subtitles.tools.translate.services.{name}_translator")
+ class_name = {"google": "GoogleTranslatorService", "lingarr": "LingarrTranslatorService",
+ "openrouter": "OpenRouterTranslatorService", "gemini": "GeminiTranslatorService"}[name]
+ source = flow.video.with_suffix(".hu.srt")
+ destination = flow.video.with_suffix(".en.srt")
+ source.write_text("1\n00:00:01,000 --> 00:00:02,000\nSource\n")
+ if existing:
+ destination.write_text("1\n00:00:01,000 --> 00:00:02,000\nOriginal destination\n")
+ service = getattr(module, class_name)(
+ source_srt_file=str(source), dest_srt_file=str(destination), lang_obj=None,
+ to_lang="eng", from_lang="en", media_type="movie", video_path=str(flow.video),
+ orig_to_lang="en", forced=False, hi=False, sonarr_series_id=None, sonarr_episode_id=None, radarr_id=30)
+ monkeypatch.setattr(module, "jobs_queue", flow.queue)
+ monkeypatch.setattr(module, "history_log_movie", Mock())
+ monkeypatch.setattr(module, "create_process_result", Mock())
+ monkeypatch.setattr(module, "add_translator_info", lambda *args: None)
+ started, release, computed = Event(), Event(), Event()
+
+ def compute(*args, **kwargs):
+ started.set()
+ assert release.wait(5)
+ computed.set()
+ if name == "google":
+ return "Translated text"
+ if name == "gemini":
+ Path(service.output_file).write_text("1\n00:00:01,000 --> 00:00:02,000\nTranslated text\n")
+ return
+ return [{"position": 0, "line": "Translated text"}]
+
+ transport = {"google": "_translate_text", "lingarr": "_translate_content",
+ "openrouter": "_submit_and_poll", "gemini": "_translate_with_gemini"}[name]
+ monkeypatch.setattr(service, transport, compute)
+ if name == "gemini":
+ monkeypatch.setattr(service, "_get_configured_api_keys", lambda: [])
+ monkeypatch.setattr(service, "_select_next_api_key", lambda: "fixture")
+ monkeypatch.setattr(service, "_check_saved_progress", lambda: None)
+ monkeypatch.setattr(module, "get_description", lambda *args, **kwargs: "")
+ job_id = flow.queue.feed_jobs_pending_queue("Translation", "fixture", "translate", is_progress=True)
+ job = flow.queue.jobs_pending_queue.popleft()
+ job.status = "running"
+ flow.queue.jobs_running_queue.append(job)
+ errors = []
+
+ def run():
+ try:
+ service.translate(job_id=job_id)
+ except Exception as exc:
+ errors.append(exc)
+
+ worker = Thread(target=run)
+ worker.start()
+ assert started.wait(2)
+ yield SimpleNamespace(flow=flow, service=service, destination=destination, release=release,
+ computed=computed, worker=worker, errors=errors, job_id=job_id)
+ release.set()
+ worker.join(5)
+ assert not worker.is_alive()
+
+
+@pytest.mark.parametrize("review_translator", ["google", "lingarr", "openrouter", "gemini"], indirect=True)
+@pytest.mark.parametrize("change", ["edit", "delete"])
+def test_review_translation_preserves_changes_made_during_remote_work(review_translator, monkeypatch, change):
+ from subtitles.tools import mods
+ from subtitles.tools.subsync_engines import SubtitleDestinationChanged
+
+ run = review_translator
+ if change == "edit":
+ edited = b"1\n00:00:01,000 --> 00:00:02,000\nLater edit\n"
+ monkeypatch.setattr(mods.Subtitle, "get_modified_content", lambda *args, **kwargs: edited)
+ mods.subtitles_apply_mods("en", str(run.destination), [], str(run.flow.video), arr_instance_id=7)
+ else:
+ assert run.flow.remove("movie")
+ run.release.set()
+ run.worker.join(3)
+ assert not run.worker.is_alive()
+ assert any(isinstance(exc, SubtitleDestinationChanged) for exc in run.errors)
+ if change == "edit":
+ assert run.destination.read_bytes() == edited
+ else:
+ assert not run.destination.exists()
+
+
+@pytest.mark.parametrize("review_translator", ["google", "lingarr", "openrouter", "gemini"], indirect=True)
+def test_review_translation_cancellation_while_waiting_to_publish_keeps_old_file(review_translator):
+ from app.jobs_queue import JobCancelled
+ from subtitles.tools.subsync_engines import subtitle_write_lock
+
+ run = review_translator
+ original = run.destination.read_bytes()
+ with subtitle_write_lock(str(run.flow.video), str(run.destination.parent)):
+ run.release.set()
+ assert run.computed.wait(2)
+ assert run.flow.queue.cancel_running_job(run.job_id)
+ run.worker.join(3)
+ assert not run.worker.is_alive()
+ assert any(isinstance(exc, JobCancelled) for exc in run.errors)
+ assert run.destination.read_bytes() == original
+
+
+@pytest.mark.parametrize("review_translator", [(name, False) for name in ["google", "lingarr", "openrouter", "gemini"]], indirect=True)
+def test_review_new_translation_preserves_process_umask(review_translator):
+ run = review_translator
+ control = run.destination.with_name("permission-control.txt")
+ control.write_text("control")
+ run.release.set()
+ run.worker.join(3)
+ assert not run.errors
+ assert run.destination.stat().st_mode & 0o777 == control.stat().st_mode & 0o777
+
+
+@pytest.mark.parametrize("failure", ["write-error", "empty-content"])
+def test_review_failed_upload_save_preserves_prior_subtitle_and_outputs(upload_flow, monkeypatch, failure):
+ import builtins
+ from subtitles import upload
+
+ flow = upload_flow
+ source = flow.video.with_suffix(".en.srt")
+ output = flow.video.with_suffix(".en.ffsubsync.srt")
+ source.write_text("Prior base bytes")
+ output.write_text("Prior generated bytes")
+ if failure == "empty-content":
+ monkeypatch.setattr(upload.Subtitle, "get_modified_content", lambda *args, **kwargs: None)
+ else:
+ original = builtins.open
+
+ def fail(file, mode="r", *args, **kwargs):
+ if "w" in mode and "b" in mode:
+ raise OSError("controlled subtitle write failure")
+ return original(file, mode, *args, **kwargs)
+
+ monkeypatch.setattr(builtins, "open", fail)
+ flow.submit("movie")
+ _, thread = flow.start()
+ thread.join(3)
+ assert source.read_text() == "Prior base bytes"
+ assert output.read_text() == "Prior generated bytes"
+ assert not flow.queue.jobs_pending_queue
+
+
+def test_review_failed_upgrade_keeps_previous_subtitle(upload_flow, monkeypatch):
+ from subtitles import download, pool
+ from subliminal_patch.subtitle import Subtitle
+ from subzero.language import Language
+
+ flow = upload_flow
+ previous = flow.video.with_suffix(".en.ass")
+ output = flow.video.with_suffix(".en.ffsubsync.ass")
+ previous.write_text("Prior base bytes")
+ output.write_text("Prior generated bytes")
+ subtitle = Subtitle(Language("eng"), original_format=True)
+ subtitle.content = b"1\n00:00:01,000 --> 00:00:02,000\nReplacement\n"
+ subtitle.matches = set()
+ video = Mock(original_path=str(flow.video))
+ monkeypatch.setattr(pool, "_update_pool", lambda *args, **kwargs: False)
+ monkeypatch.setattr(download, "get_video", lambda *args, **kwargs: video)
+ monkeypatch.setattr(download, "_get_pool", lambda *args, **kwargs: Mock(providers=["fixture"]))
+ monkeypatch.setattr(download, "_get_language_obj", lambda **kwargs: {Language("eng")})
+ monkeypatch.setattr(download, "get_profiles_list", lambda **kwargs: {"originalFormat": True})
+ monkeypatch.setattr(download, "download_best_subtitles", lambda **kwargs: {video: [subtitle]})
+ monkeypatch.setattr(download, "get_target_folder", lambda *args: None)
+ monkeypatch.setattr(download, "save_subtitles", Mock(side_effect=OSError("controlled failed replacement")))
+ list(download.generate_subtitles(str(flow.video), [("en", False, False)], [], None, "Video", "movie", 1,
+ is_upgrade=True, previous_subtitles_to_delete=str(previous), arr_instance_id=7))
+ assert previous.read_text() == "Prior base bytes"
+ assert output.read_text() == "Prior generated bytes"
+
+
+@pytest.fixture
+def review_combine(upload_flow, monkeypatch):
+ from subtitles.tools.combine import main
+ from subtitles.tools.combine.rules import SourcePaths
+
+ flow = upload_flow
+ primary = flow.video.with_suffix(".en.srt")
+ secondary = flow.video.with_suffix(".hu.srt")
+ primary.write_text("1\n00:00:01,000 --> 00:00:02,000\nFirst\n")
+ secondary.write_text("1\n00:00:01,000 --> 00:00:02,000\nSecond\n")
+ monkeypatch.setattr(main, "resolve_source_paths", lambda **kwargs: SourcePaths(str(primary), [str(secondary)]))
+ monkeypatch.setattr(main, "_post_write", lambda *args: None)
+ return SimpleNamespace(flow=flow, module=main, output=flow.video.with_suffix(".en.combined-hu.srt"),
+ run=lambda format="srt": main.try_combine_for_video(
+ str(flow.video), "movie", languages=["en", "hu"], format=format))
+
+
+def test_review_combine_cleanup_does_not_follow_sibling_symlinks(review_combine):
+ run = review_combine
+ foreign = run.flow.video.with_suffix(".fr.ass")
+ foreign.write_text("Foreign subtitle bytes")
+ run.output.with_suffix(".ass").symlink_to(foreign)
+ assert run.run().status == "built"
+ assert foreign.read_text() == "Foreign subtitle bytes"
+ assert run.output.with_suffix(".ass").is_symlink()
+
+
+def test_review_combine_format_rebuilds_cannot_delete_each_other(review_combine, monkeypatch):
+ run = review_combine
+ first_cleanup, second_cleanup = Event(), Event()
+ original = run.module._remove_stale_combined_siblings
+ results = []
+
+ def cleanup(path, video):
+ mine, other = (first_cleanup, second_cleanup) if path.endswith(".srt") else (second_cleanup, first_cleanup)
+ mine.set()
+ other.wait(0.3)
+ original(path, video)
+
+ monkeypatch.setattr(run.module, "_remove_stale_combined_siblings", cleanup)
+ workers = [Thread(target=lambda fmt=fmt: results.append(run.run(fmt))) for fmt in ("srt", "ass")]
+ for worker in workers:
+ worker.start()
+ for worker in workers:
+ worker.join(3)
+ assert not worker.is_alive()
+ assert all(result.status == "built" for result in results)
+ assert sum(run.output.with_suffix(ext).is_file() for ext in (".srt", ".ass")) == 1
+
+
+def test_review_combine_preserves_edit_during_composition(review_combine, monkeypatch):
+ from subtitles.tools import mods
+
+ run = review_combine
+ run.output.write_text("1\n00:00:01,000 --> 00:00:02,000\nOriginal combined\n")
+ entered, release = Event(), Event()
+ original = run.module.compose
+
+ def compose(**kwargs):
+ result = original(**kwargs)
+ entered.set()
+ assert release.wait(5)
+ return result
+
+ monkeypatch.setattr(run.module, "compose", compose)
+ results = []
+ worker = Thread(target=lambda: results.append(run.run()))
+ worker.start()
+ try:
+ assert entered.wait(2)
+ edited = b"1\n00:00:01,000 --> 00:00:02,000\nEdited combined\n"
+ monkeypatch.setattr(mods.Subtitle, "get_modified_content", lambda *args, **kwargs: edited)
+ mods.subtitles_apply_mods("en", str(run.output), [], str(run.flow.video), arr_instance_id=7)
+ release.set()
+ worker.join(3)
+ assert not worker.is_alive()
+ assert run.output.read_bytes() == edited
+ assert results[0].status != "built"
+ finally:
+ release.set()
+ worker.join(3)
+
+
+def test_review_postprocessing_without_a_queued_job_invalidates_exact_outputs(upload_flow, monkeypatch):
+ from subtitles import post_processing
+
+ flow = upload_flow
+ source = flow.video.with_suffix(".en.srt")
+ output = flow.video.with_suffix(".en.ffsubsync.srt")
+ source.write_text("Before processing")
+ output.write_text("Generated before processing")
+
+ def popen(*args, **kwargs):
+ source.write_text("After processing")
+ return Mock(communicate=lambda: ("", ""))
+
+ monkeypatch.setattr(post_processing.subprocess, "Popen", popen)
+ post_processing.postprocessing("fixture", str(flow.video), subtitle_path=str(source))
+ assert source.read_text() == "After processing"
+ assert not output.exists()
+ assert any(path.read_text() == "Generated before processing" for path in flow.video.parent.glob("*.bak"))
+
+
+def test_review_partial_multiformat_save_records_each_actual_write(upload_flow):
+ from functools import partial
+ from subliminal_patch.core import save_subtitles
+ from subliminal_patch.subtitle import Subtitle
+ from subzero.language import Language
+ from subtitles.tools.subsync_engines import write_subtitle_file, SubtitlePublication, subtitle_source_version
+
+ flow = upload_flow
+ source = flow.video.with_suffix(".en.srt")
+ output = flow.video.with_suffix(".en.ffsubsync.srt")
+ source.write_text("Prior source")
+ output.write_text("Prior generated output")
+ publication = SubtitlePublication(str(flow.video), str(source), subtitle_source_version(source))
+ subtitle = Subtitle(Language("eng"), original_format=True)
+ subtitle.content = b"1\n00:00:01,000 --> 00:00:02,000\nReplacement\n"
+
+ def content(format, **kwargs):
+ if format == "ass":
+ raise ValueError("controlled second format failure")
+ return b"First format succeeded"
+
+ subtitle.get_modified_content = content
+ written_paths = []
+ try:
+ with pytest.raises(ValueError, match="second format"):
+ save_subtitles(str(flow.video), [subtitle], formats=("srt", "ass"),
+ write_subtitle=partial(write_subtitle_file, str(flow.video), written_paths=written_paths))
+ assert written_paths == [str(source)]
+ assert source.read_text() == "First format succeeded"
+ assert not publication.source_unchanged()
+ assert not output.exists()
+ finally:
+ publication.release()
+
+
+def test_review_index_failure_does_not_suppress_refresh_of_published_output(upload_flow):
+ flow = upload_flow
+ flow.submit("movie")
+ _, thread = flow.start()
+ thread.join(2)
+ job = flow.queue.jobs_pending_queue[0]
+ job.kwargs["callback"] = Mock(side_effect=RuntimeError("controlled final index failure"))
+ flow.release_engine.set()
+ _, thread = flow.start()
+ thread.join(3)
+ assert "Synced" in flow.video.with_suffix(".en.srt").read_text()
+ assert sum("arr_client" in kwargs for _, kwargs in flow.notifications) == 2
+ assert job.kwargs["source_version"].state is None
+
+
+def test_review_deleting_one_engine_destination_preserves_other_engine_publication(upload_flow, monkeypatch):
+ from app.config import settings
+ from subtitles.tools import subsyncer, delete
+
+ flow = upload_flow
+ monkeypatch.setattr(settings.subsync, "enabled_engines", ["ffsubsync", "alass"])
+ monkeypatch.setattr(settings.subsync, "output_mode", "keep_all")
+ monkeypatch.setattr(subsyncer.SubSyncer, "_run_external_engine", lambda self, engine, output_path, video_path:
+ (output_path.write_text("Other engine output") and {"offset_seconds": 0}))
+ flow.submit("movie")
+ _, thread = flow.start()
+ thread.join(2)
+ deleted = flow.video.with_suffix(".en.ffsubsync.srt")
+ assert delete.delete_subtitles("movie", "en", False, False, str(flow.video), str(deleted),
+ radarr_id=30, arr_instance_id=7) is False
+ _, thread = flow.start()
+ thread.join(3)
+ assert not flow.engine_calls
+ assert not deleted.exists()
+ assert flow.video.with_suffix(".en.alass.srt").read_text() == "Other engine output"
+
+
+def test_review_quarantine_moves_only_exact_regular_variants(upload_flow):
+ from subtitles.tools.subsync_engines import quarantine_sync_outputs, SubtitlePublication, subtitle_source_version
+
+ flow = upload_flow
+ source = flow.video.with_suffix(".en.hi.ass")
+ source.write_text("Source")
+ exact = flow.video.with_suffix(".en.hi.ffsubsync.ass")
+ exact.write_text("Owned generated bytes")
+ foreign = flow.video.with_suffix(".hu.srt")
+ foreign.write_text("Foreign bytes")
+ symlink = flow.video.with_suffix(".en.hi.alass.ass")
+ symlink.symlink_to(foreign)
+ untouched = [flow.video.with_suffix(suffix) for suffix in
+ (".en.ffsubsync.ass", ".en.hi.ffsubsync.srt", ".en.forced.ffsubsync.ass")]
+ for path in untouched:
+ path.write_text("Other variant bytes")
+ quarantine_sync_outputs(str(flow.video), str(source))
+ assert not exact.exists()
+ assert symlink.is_symlink() and foreign.read_text() == "Foreign bytes"
+ assert all(path.read_text() == "Other variant bytes" for path in untouched)
+ assert any(path.read_text() == "Owned generated bytes" for path in flow.video.parent.glob("*.bak"))
+ publication = SubtitlePublication(str(flow.video), str(source), subtitle_source_version(source))
+ try:
+ assert not publication.destination_unchanged(symlink)
+ finally:
+ publication.release()
+
+
+def test_review_failed_quarantine_retains_bytes_and_destination_revision(upload_flow, monkeypatch):
+ from subtitles.tools import subsync_engines
+
+ flow = upload_flow
+ source = flow.video.with_suffix(".en.srt")
+ source.write_text("Source")
+ output = flow.video.with_suffix(".en.ffsubsync.srt")
+ output.write_text("Prior generated bytes")
+ publication = subsync_engines.SubtitlePublication(
+ str(flow.video), str(source), subsync_engines.subtitle_source_version(source))
+ monkeypatch.setattr(subsync_engines.os, "replace", Mock(side_effect=PermissionError("controlled move rejection")))
+ try:
+ with pytest.raises(PermissionError, match="move rejection"):
+ subsync_engines.quarantine_sync_outputs(str(flow.video), str(source))
+ assert output.read_text() == "Prior generated bytes"
+ assert publication.destination_unchanged(output)
+ assert not list(flow.video.parent.glob(".bazarr-sync-obsolete-*.bak"))
+ finally:
+ publication.release()
+
+
+@pytest.fixture
+def rejected_quarantine(upload_flow, monkeypatch):
+ from subtitles.tools import subsync_engines
+
+ flow = upload_flow
+ source = flow.video.with_suffix(".en.srt")
+ source.write_text("Previous subtitle")
+ output = flow.video.with_suffix(".en.ffsubsync.srt")
+ output.write_text("Previous generated output")
+ other = flow.video.with_suffix(".hu.ffsubsync.srt")
+ other.write_text("Other language output")
+ publication = subsync_engines.SubtitlePublication(
+ str(flow.video), str(source), subsync_engines.subtitle_source_version(source))
+ other_revision = publication.state.revision(other)
+ real_replace = subsync_engines.os.replace
+ rejected = []
+
+ def replace(src, dst, *args, **kwargs):
+ if Path(src) == output and Path(dst).name.startswith(".bazarr-sync-obsolete-"):
+ rejected.append(str(src))
+ raise PermissionError("controlled quarantine failure after publication")
+ return real_replace(src, dst, *args, **kwargs)
+
+ monkeypatch.setattr(subsync_engines.os, "replace", replace)
+ yield SimpleNamespace(flow=flow, source=source, output=output, other=other, publication=publication,
+ other_revision=other_revision, rejected=rejected)
+ publication.release()
+
+
+def _assert_reported_quarantine_failure(probe, caplog):
+ assert probe.rejected == [str(probe.output)]
+ assert not probe.publication.source_unchanged()
+ assert probe.publication.state.revision(probe.source) > probe.publication.source_revision
+ assert probe.output.read_text() == "Previous generated output"
+ assert probe.publication.destination_unchanged(probe.output)
+ assert probe.other.read_text() == "Other language output"
+ assert probe.publication.state.revision(probe.other) == probe.other_revision
+ assert not list(probe.source.parent.glob(".bazarr-sync-obsolete-*.bak"))
+ assert any("cleanup failed" in record.message and "may remain available" in record.message
+ and str(probe.source) in record.message for record in caplog.records)
+
+
+@pytest.mark.parametrize("media_type", ["movie", "series"])
+def test_review_published_upload_is_accounted_when_quarantine_fails(rejected_quarantine, caplog, media_type):
+ probe = rejected_quarantine
+ flow = probe.flow
+ flow.submit(media_type, content="Replacement uploaded text")
+ job, thread = flow.start()
+ thread.join(3)
+ assert not thread.is_alive()
+ assert "Replacement uploaded text" in probe.source.read_text()
+ assert flow.indexes, "durable upload publication was not indexed"
+ assert flow.indexes[0][0] == 7
+ assert flow.indexes[0][1][probe.output.name] == "Previous generated output"
+ assert len(flow.history) == 1
+ assert len(flow.notifications) == 2
+ assert job.status == "completed"
+ assert len(flow.queue.jobs_pending_queue) == 1
+ _assert_reported_quarantine_failure(probe, caplog)
+
+
+@pytest.mark.parametrize("writer", ["manual", "automatic"])
+def test_review_published_provider_subtitle_is_accounted_when_quarantine_fails(
+ rejected_quarantine, monkeypatch, caplog, writer):
+ from subtitles import manual, download, pool
+ from subliminal_patch.subtitle import Subtitle
+ from subzero.language import Language
+
+ probe = rejected_quarantine
+ flow = probe.flow
+ subtitle = Subtitle(Language("eng"), original_format=True)
+ subtitle.content = b"1\n00:00:01,000 --> 00:00:02,000\nReplacement provider text\n"
+ subtitle.provider_name = "fixture"
+ subtitle.matches = set()
+ video = Mock(original_path=str(flow.video))
+ provider_pool = Mock(providers=["fixture"], discarded_providers=[])
+ module = manual if writer == "manual" else download
+ monkeypatch.setattr(pool, "_update_pool", lambda *args, **kwargs: False)
+ monkeypatch.setattr(module, "get_video", lambda *args, **kwargs: video)
+ monkeypatch.setattr(module, "_get_pool", lambda *args, **kwargs: provider_pool)
+ monkeypatch.setattr(module, "get_target_folder", lambda *args, **kwargs: None)
+ monkeypatch.setattr(module.subliminal, "region", Mock())
+ processed = []
+ monkeypatch.setattr(module, "process_subtitle", lambda **kwargs: processed.append(kwargs) or "saved")
+ if writer == "manual":
+ monkeypatch.setattr(manual.subtitle_cache, "get", lambda *args: subtitle)
+ monkeypatch.setattr(manual, "download_subtitles", lambda *args: None)
+ manual.manual_download_subtitle(str(flow.video), [], False, False, "cached", "fixture", None,
+ "Video", "movie", True, 1, arr_instance_id=7)
+ else:
+ monkeypatch.setattr(download, "_get_language_obj", lambda **kwargs: {Language("eng")})
+ monkeypatch.setattr(download, "get_profiles_list", lambda **kwargs: {"originalFormat": True})
+ monkeypatch.setattr(download, "download_best_subtitles", lambda **kwargs: {video: [subtitle]})
+ monkeypatch.setattr(download, "clear_mismatch_for_video", lambda *args, **kwargs: None)
+ list(download.generate_subtitles(str(flow.video), [("en", False, False)], [], None,
+ "Video", "movie", 1, arr_instance_id=7))
+ assert "Replacement provider text" in probe.source.read_text()
+ assert len(processed) == 1, "durable provider publication was not passed to processing"
+ assert processed[0]["subtitle"].storage_path == str(probe.source)
+ assert processed[0]["path"] == str(flow.video)
+ assert processed[0]["media_type"] == "movie"
+ _assert_reported_quarantine_failure(probe, caplog)
+
+
+@pytest.mark.parametrize("operation", ["delete", "manual-sync"])
+def test_review_completed_mutation_keeps_success_when_quarantine_fails(rejected_quarantine, caplog, operation):
+ from subtitles import sync
+
+ probe = rejected_quarantine
+ flow = probe.flow
+ if operation == "delete":
+ assert flow.remove("movie") is True
+ assert not probe.source.exists()
+ assert flow.indexes
+ else:
+ flow.release_engine.set()
+ assert sync.sync_subtitles(str(flow.video), str(probe.source), "en", False, False, 100,
+ radarr_id=30, force_sync=True, track_job_progress=False,
+ arr_instance_id=7) is True
+ assert "Synced" in probe.source.read_text()
+ assert flow.sync_history
+ _assert_reported_quarantine_failure(probe, caplog)