Use celery tasks instead of systemd timers for periodic work; and add more tests

twitch/tests/test_tasks.py

@@ -0,0 +1,575 @@
+from pathlib import Path
+from types import SimpleNamespace
+from unittest.mock import MagicMock
+from unittest.mock import call
+from unittest.mock import patch
+
+import httpx
+import pytest
+
+from twitch.models import DropBenefit
+from twitch.models import DropCampaign
+from twitch.models import RewardCampaign
+from twitch.tasks import _convert_to_modern_formats
+from twitch.tasks import _download_and_save
+from twitch.tasks import backup_database
+from twitch.tasks import download_all_images
+from twitch.tasks import download_benefit_image
+from twitch.tasks import download_campaign_image
+from twitch.tasks import download_game_image
+from twitch.tasks import download_reward_campaign_image
+from twitch.tasks import import_chat_badges
+from twitch.tasks import import_twitch_file
+from twitch.tasks import scan_pending_twitch_files
+
+
+def test_scan_pending_twitch_files_dispatches_json_files(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> None:
+    """It should dispatch an import task for each JSON file in the pending directory."""
+    first = tmp_path / "one.json"
+    second = tmp_path / "two.json"
+    ignored = tmp_path / "notes.txt"
+    first.write_text("{}", encoding="utf-8")
+    second.write_text("{}", encoding="utf-8")
+    ignored.write_text("ignored", encoding="utf-8")
+    monkeypatch.setenv("TTVDROPS_PENDING_DIR", str(tmp_path))
+
+    with patch("twitch.tasks.import_twitch_file.delay") as delay_mock:
+        scan_pending_twitch_files.run()
+
+    delay_mock.assert_has_calls([call(str(first)), call(str(second))], any_order=True)
+    assert delay_mock.call_count == 2
+
+
+def test_scan_pending_twitch_files_skips_when_env_missing(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """It should do nothing when TTVDROPS_PENDING_DIR is not configured."""
+    monkeypatch.delenv("TTVDROPS_PENDING_DIR", raising=False)
+
+    with patch("twitch.tasks.import_twitch_file.delay") as delay_mock:
+        scan_pending_twitch_files.run()
+
+    delay_mock.assert_not_called()
+
+
+def test_import_twitch_file_calls_importer_for_existing_file(tmp_path: Path) -> None:
+    """It should run BetterImportDrops with the provided path when the file exists."""
+    source = tmp_path / "drops.json"
+    source.write_text("{}", encoding="utf-8")
+
+    with patch(
+        "twitch.management.commands.better_import_drops.Command.handle",
+    ) as handle_mock:
+        import_twitch_file.run(str(source))
+
+    assert handle_mock.call_count == 1
+    assert handle_mock.call_args.kwargs["path"] == source
+
+
+def test_import_twitch_file_retries_on_import_error(tmp_path: Path) -> None:
+    """It should retry when the importer raises an exception."""
+    source = tmp_path / "drops.json"
+    source.write_text("{}", encoding="utf-8")
+    error = RuntimeError("boom")
+
+    with (
+        patch(
+            "twitch.management.commands.better_import_drops.Command.handle",
+            side_effect=error,
+        ),
+        patch.object(
+            import_twitch_file,
+            "retry",
+            side_effect=RuntimeError("retried"),
+        ) as retry_mock,
+        pytest.raises(RuntimeError, match="retried"),
+    ):
+        import_twitch_file.run(str(source))
+
+    retry_mock.assert_called_once_with(exc=error)
+
+
+def test_download_and_save_skips_when_image_already_cached() -> None:
+    """It should not download when the target ImageField already has a file name."""
+    file_field = MagicMock()
+    file_field.name = "already-there.jpg"
+
+    with patch("twitch.tasks.httpx.Client") as client_mock:
+        result = _download_and_save(
+            url="https://example.com/test.jpg",
+            name="game-1",
+            file_field=file_field,
+        )
+
+    assert result is False
+    client_mock.assert_not_called()
+
+
+def test_download_and_save_saves_downloaded_content() -> None:
+    """It should save downloaded bytes and trigger modern format conversion."""
+    file_field = MagicMock()
+    file_field.name = ""
+    file_field.path = "C:/cache/game-1.png"
+
+    response = MagicMock()
+    response.content = b"img-bytes"
+    response.raise_for_status.return_value = None
+
+    client = MagicMock()
+    client.get.return_value = response
+    client_cm = MagicMock()
+    client_cm.__enter__.return_value = client
+
+    with (
+        patch("twitch.tasks.httpx.Client", return_value=client_cm),
+        patch("twitch.tasks._convert_to_modern_formats") as convert_mock,
+    ):
+        result = _download_and_save(
+            url="https://example.com/path/picture.png",
+            name="game-1",
+            file_field=file_field,
+        )
+
+    assert result is True
+    file_field.save.assert_called_once()
+    assert file_field.save.call_args.args[0] == "game-1.png"
+    assert file_field.save.call_args.kwargs["save"] is True
+    convert_mock.assert_called_once_with(Path("C:/cache/game-1.png"))
+
+
+def test_download_and_save_returns_false_on_http_error() -> None:
+    """It should return False when HTTP requests fail."""
+    file_field = MagicMock()
+    file_field.name = ""
+
+    client = MagicMock()
+    client.get.side_effect = httpx.HTTPError("network down")
+    client_cm = MagicMock()
+    client_cm.__enter__.return_value = client
+
+    with patch("twitch.tasks.httpx.Client", return_value=client_cm):
+        result = _download_and_save(
+            url="https://example.com/path/picture.png",
+            name="game-1",
+            file_field=file_field,
+        )
+
+    assert result is False
+    file_field.save.assert_not_called()
+
+
+def test_download_game_image_downloads_normalized_twitch_url() -> None:
+    """It should normalize Twitch box art URLs before downloading."""
+    game = SimpleNamespace(
+        box_art="https://static-cdn.jtvnw.net/ttv-boxart/1-{width}x{height}.jpg",
+        twitch_id="123",
+        box_art_file=MagicMock(),
+    )
+
+    with (
+        patch("twitch.models.Game.objects.get", return_value=game),
+        patch(
+            "twitch.utils.is_twitch_box_art_url",
+            return_value=True,
+        ) as is_twitch_mock,
+        patch(
+            "twitch.utils.normalize_twitch_box_art_url",
+            return_value="https://cdn.example.com/box.jpg",
+        ) as normalize_mock,
+        patch("twitch.tasks._download_and_save") as save_mock,
+    ):
+        download_game_image.run(1)
+
+    is_twitch_mock.assert_called_once_with(game.box_art)
+    normalize_mock.assert_called_once_with(game.box_art)
+    save_mock.assert_called_once_with(
+        "https://cdn.example.com/box.jpg",
+        "123",
+        game.box_art_file,
+    )
+
+
+def test_download_game_image_retries_on_download_error() -> None:
+    """It should retry when the image download helper fails unexpectedly."""
+    game = SimpleNamespace(
+        box_art="https://static-cdn.jtvnw.net/ttv-boxart/1-{width}x{height}.jpg",
+        twitch_id="123",
+        box_art_file=MagicMock(),
+    )
+    error = RuntimeError("boom")
+
+    with (
+        patch("twitch.models.Game.objects.get", return_value=game),
+        patch("twitch.utils.is_twitch_box_art_url", return_value=True),
+        patch(
+            "twitch.utils.normalize_twitch_box_art_url",
+            return_value="https://cdn.example.com/box.jpg",
+        ),
+        patch("twitch.tasks._download_and_save", side_effect=error),
+        patch.object(
+            download_game_image,
+            "retry",
+            side_effect=RuntimeError("retried"),
+        ) as retry_mock,
+        pytest.raises(RuntimeError, match="retried"),
+    ):
+        download_game_image.run(1)
+
+    retry_mock.assert_called_once_with(exc=error)
+
+
+def test_download_all_images_calls_expected_commands() -> None:
+    """It should invoke both image import management commands."""
+    with patch("twitch.tasks.call_command") as call_command_mock:
+        download_all_images.run()
+
+    call_command_mock.assert_has_calls([
+        call("download_box_art"),
+        call("download_campaign_images", model="all"),
+    ])
+
+
+def test_import_chat_badges_retries_on_error() -> None:
+    """It should retry when import_chat_badges command execution fails."""
+    error = RuntimeError("boom")
+
+    with (
+        patch("twitch.tasks.call_command", side_effect=error),
+        patch.object(
+            import_chat_badges,
+            "retry",
+            side_effect=RuntimeError("retried"),
+        ) as retry_mock,
+        pytest.raises(RuntimeError, match="retried"),
+    ):
+        import_chat_badges.run()
+
+    retry_mock.assert_called_once_with(exc=error)
+
+
+def test_backup_database_calls_backup_command() -> None:
+    """It should invoke the backup_db management command."""
+    with patch("twitch.tasks.call_command") as call_command_mock:
+        backup_database.run()
+
+    call_command_mock.assert_called_once_with("backup_db")
+
+
+def test_convert_to_modern_formats_skips_non_image_files(tmp_path: Path) -> None:
+    """It should skip files that are not jpg, jpeg, or png."""
+    text_file = tmp_path / "document.txt"
+    text_file.write_text("Not an image", encoding="utf-8")
+
+    with patch("PIL.Image.open") as open_mock:
+        _convert_to_modern_formats(text_file)
+
+    open_mock.assert_not_called()
+
+
+def test_convert_to_modern_formats_skips_missing_files(tmp_path: Path) -> None:
+    """It should skip files that do not exist."""
+    missing_file = tmp_path / "nonexistent.jpg"
+
+    with patch("PIL.Image.open") as open_mock:
+        _convert_to_modern_formats(missing_file)
+
+    open_mock.assert_not_called()
+
+
+def test_convert_to_modern_formats_converts_rgb_image(tmp_path: Path) -> None:
+    """It should save image in WebP and AVIF formats for RGB images."""
+    original = tmp_path / "image.jpg"
+    original.write_bytes(b"fake-jpeg")
+
+    mock_image = MagicMock()
+    mock_image.mode = "RGB"
+    mock_copy = MagicMock()
+    mock_image.copy.return_value = mock_copy
+
+    with (
+        patch("PIL.Image.open") as open_mock,
+    ):
+        open_mock.return_value.__enter__.return_value = mock_image
+        _convert_to_modern_formats(original)
+
+    open_mock.assert_called_once_with(original)
+    assert mock_copy.save.call_count == 2
+    webp_call = [c for c in mock_copy.save.call_args_list if "webp" in str(c)]
+    avif_call = [c for c in mock_copy.save.call_args_list if "avif" in str(c)]
+    assert len(webp_call) == 1
+    assert len(avif_call) == 1
+
+
+def test_convert_to_modern_formats_converts_rgba_image_with_background(
+    tmp_path: Path,
+) -> None:
+    """It should create RGB background and paste RGBA image onto it."""
+    original = tmp_path / "image.png"
+    original.write_bytes(b"fake-png")
+
+    mock_rgba = MagicMock()
+    mock_rgba.mode = "RGBA"
+    mock_rgba.split.return_value = [MagicMock(), MagicMock(), MagicMock(), MagicMock()]
+    mock_rgba.size = (100, 100)
+    mock_rgba.convert.return_value = mock_rgba
+
+    mock_bg = MagicMock()
+
+    with (
+        patch("PIL.Image.open") as open_mock,
+        patch("PIL.Image.new", return_value=mock_bg) as new_mock,
+    ):
+        open_mock.return_value.__enter__.return_value = mock_rgba
+        _convert_to_modern_formats(original)
+
+    new_mock.assert_called_once_with("RGB", (100, 100), (255, 255, 255))
+    mock_bg.paste.assert_called_once()
+    assert mock_bg.save.call_count == 2
+
+
+def test_convert_to_modern_formats_handles_conversion_error(tmp_path: Path) -> None:
+    """It should gracefully handle format conversion failures."""
+    original = tmp_path / "image.jpg"
+    original.write_bytes(b"fake-jpeg")
+
+    mock_image = MagicMock()
+    mock_image.mode = "RGB"
+    mock_image.copy.return_value = MagicMock()
+    mock_image.copy.return_value.save.side_effect = Exception("PIL error")
+
+    with (
+        patch("PIL.Image.open") as open_mock,
+    ):
+        open_mock.return_value.__enter__.return_value = mock_image
+        _convert_to_modern_formats(original)  # Should not raise
+
+
+def test_download_campaign_image_downloads_when_url_exists() -> None:
+    """It should download and save campaign image when image_url is present."""
+    campaign = SimpleNamespace(
+        image_url="https://example.com/campaign.jpg",
+        twitch_id="camp123",
+        image_file=MagicMock(),
+    )
+
+    with (
+        patch("twitch.models.DropCampaign.objects.get", return_value=campaign),
+        patch("twitch.tasks._download_and_save", return_value=True) as save_mock,
+    ):
+        download_campaign_image.run(1)
+
+    save_mock.assert_called_once_with(
+        "https://example.com/campaign.jpg",
+        "camp123",
+        campaign.image_file,
+    )
+
+
+def test_download_campaign_image_skips_when_no_url() -> None:
+    """It should skip when campaign has no image_url."""
+    campaign = SimpleNamespace(
+        image_url=None,
+        twitch_id="camp123",
+        image_file=MagicMock(),
+    )
+
+    with (
+        patch("twitch.models.DropCampaign.objects.get", return_value=campaign),
+        patch("twitch.tasks._download_and_save") as save_mock,
+    ):
+        download_campaign_image.run(1)
+
+    save_mock.assert_not_called()
+
+
+def test_download_campaign_image_skips_when_not_found() -> None:
+    """It should skip when campaign does not exist."""
+    with (
+        patch(
+            "twitch.models.DropCampaign.objects.get",
+            side_effect=DropCampaign.DoesNotExist(),
+        ),
+        patch("twitch.tasks._download_and_save") as save_mock,
+    ):
+        download_campaign_image.run(1)
+
+    save_mock.assert_not_called()
+
+
+def test_download_campaign_image_retries_on_error() -> None:
+    """It should retry when image download fails unexpectedly."""
+    campaign = SimpleNamespace(
+        image_url="https://example.com/campaign.jpg",
+        twitch_id="camp123",
+        image_file=MagicMock(),
+    )
+    error = RuntimeError("boom")
+
+    with (
+        patch("twitch.models.DropCampaign.objects.get", return_value=campaign),
+        patch("twitch.tasks._download_and_save", side_effect=error),
+        patch.object(
+            download_campaign_image,
+            "retry",
+            side_effect=RuntimeError("retried"),
+        ) as retry_mock,
+        pytest.raises(RuntimeError, match="retried"),
+    ):
+        download_campaign_image.run(1)
+
+    retry_mock.assert_called_once_with(exc=error)
+
+
+def test_download_benefit_image_downloads_when_url_exists() -> None:
+    """It should download and save benefit image when image_asset_url is present."""
+    benefit = SimpleNamespace(
+        image_asset_url="https://example.com/benefit.png",
+        twitch_id="benefit123",
+        image_file=MagicMock(),
+    )
+
+    with (
+        patch("twitch.models.DropBenefit.objects.get", return_value=benefit),
+        patch("twitch.tasks._download_and_save", return_value=True) as save_mock,
+    ):
+        download_benefit_image.run(1)
+
+    save_mock.assert_called_once_with(
+        url="https://example.com/benefit.png",
+        name="benefit123",
+        file_field=benefit.image_file,
+    )
+
+
+def test_download_benefit_image_skips_when_no_url() -> None:
+    """It should skip when benefit has no image_asset_url."""
+    benefit = SimpleNamespace(
+        image_asset_url=None,
+        twitch_id="benefit123",
+        image_file=MagicMock(),
+    )
+
+    with (
+        patch("twitch.models.DropBenefit.objects.get", return_value=benefit),
+        patch("twitch.tasks._download_and_save") as save_mock,
+    ):
+        download_benefit_image.run(1)
+
+    save_mock.assert_not_called()
+
+
+def test_download_benefit_image_skips_when_not_found() -> None:
+    """It should skip when benefit does not exist."""
+    with (
+        patch(
+            "twitch.models.DropBenefit.objects.get",
+            side_effect=DropBenefit.DoesNotExist(),
+        ),
+        patch("twitch.tasks._download_and_save") as save_mock,
+    ):
+        download_benefit_image.run(1)
+
+    save_mock.assert_not_called()
+
+
+def test_download_benefit_image_retries_on_error() -> None:
+    """It should retry when image download fails unexpectedly."""
+    benefit = SimpleNamespace(
+        image_asset_url="https://example.com/benefit.png",
+        twitch_id="benefit123",
+        image_file=MagicMock(),
+    )
+    error = RuntimeError("boom")
+
+    with (
+        patch("twitch.models.DropBenefit.objects.get", return_value=benefit),
+        patch("twitch.tasks._download_and_save", side_effect=error),
+        patch.object(
+            download_benefit_image,
+            "retry",
+            side_effect=RuntimeError("retried"),
+        ) as retry_mock,
+        pytest.raises(RuntimeError, match="retried"),
+    ):
+        download_benefit_image.run(1)
+
+    retry_mock.assert_called_once_with(exc=error)
+
+
+def test_download_reward_campaign_image_downloads_when_url_exists() -> None:
+    """It should download and save reward campaign image when image_url is present."""
+    reward = SimpleNamespace(
+        image_url="https://example.com/reward.jpg",
+        twitch_id="reward123",
+        image_file=MagicMock(),
+    )
+
+    with (
+        patch("twitch.models.RewardCampaign.objects.get", return_value=reward),
+        patch("twitch.tasks._download_and_save", return_value=True) as save_mock,
+    ):
+        download_reward_campaign_image.run(1)
+
+    save_mock.assert_called_once_with(
+        "https://example.com/reward.jpg",
+        "reward123",
+        reward.image_file,
+    )
+
+
+def test_download_reward_campaign_image_skips_when_no_url() -> None:
+    """It should skip when reward has no image_url."""
+    reward = SimpleNamespace(
+        image_url=None,
+        twitch_id="reward123",
+        image_file=MagicMock(),
+    )
+
+    with (
+        patch("twitch.models.RewardCampaign.objects.get", return_value=reward),
+        patch("twitch.tasks._download_and_save") as save_mock,
+    ):
+        download_reward_campaign_image.run(1)
+
+    save_mock.assert_not_called()
+
+
+def test_download_reward_campaign_image_skips_when_not_found() -> None:
+    """It should skip when reward does not exist."""
+    with (
+        patch(
+            "twitch.models.RewardCampaign.objects.get",
+            side_effect=RewardCampaign.DoesNotExist(),
+        ),
+        patch("twitch.tasks._download_and_save") as save_mock,
+    ):
+        download_reward_campaign_image.run(1)
+
+    save_mock.assert_not_called()
+
+
+def test_download_reward_campaign_image_retries_on_error() -> None:
+    """It should retry when image download fails unexpectedly."""
+    reward = SimpleNamespace(
+        image_url="https://example.com/reward.jpg",
+        twitch_id="reward123",
+        image_file=MagicMock(),
+    )
+    error = RuntimeError("boom")
+
+    with (
+        patch("twitch.models.RewardCampaign.objects.get", return_value=reward),
+        patch("twitch.tasks._download_and_save", side_effect=error),
+        patch.object(
+            download_reward_campaign_image,
+            "retry",
+            side_effect=RuntimeError("retried"),
+        ) as retry_mock,
+        pytest.raises(RuntimeError, match="retried"),
+    ):
+        download_reward_campaign_image.run(1)
+
+    retry_mock.assert_called_once_with(exc=error)