Monitor media before issue repair searches

backend/tests/test_backend_quality.py

@@ -1307,6 +1307,7 @@ class MediaReplacementTests(unittest.IsolatedAsyncioTestCase):
         )
         radarr = SimpleNamespace(
             configured=lambda: True,
+            monitor_movie=AsyncMock(return_value={"id": 44, "monitored": True}),
             delete_movie_file=AsyncMock(return_value=None),
             search=AsyncMock(return_value={"id": 1}),
         )
@@ -1341,6 +1342,7 @@ class MediaReplacementTests(unittest.IsolatedAsyncioTestCase):
             )
 
         self.assertEqual(result["status"], "ok")
+        radarr.monitor_movie.assert_awaited_once_with(44, True)
         radarr.delete_movie_file.assert_awaited_once_with(77)
         radarr.search.assert_awaited_once_with(44)
         add_activity.assert_called_once()
@@ -1422,6 +1424,16 @@ class MediaReplacementTests(unittest.IsolatedAsyncioTestCase):
                     "episodeFileId": 0,
                     "airDateUtc": "2020-01-08T00:00:00Z",
                 },
+                {
+                    "id": 103,
+                    "seasonNumber": 1,
+                    "episodeNumber": 3,
+                    "title": "Missing and unmonitored",
+                    "monitored": False,
+                    "hasFile": False,
+                    "episodeFileId": 0,
+                    "airDateUtc": "2020-01-15T00:00:00Z",
+                },
             ]),
         )
         runtime = SimpleNamespace(
@@ -1440,11 +1452,15 @@ class MediaReplacementTests(unittest.IsolatedAsyncioTestCase):
                 {"username": "viewer", "role": "user", "auto_search_enabled": True},
             )
 
-        self.assertEqual(result["seasons"][0]["missing_count"], 1)
+        self.assertEqual(result["seasons"][0]["missing_count"], 2)
         self.assertTrue(result["seasons"][0]["best_fit"])
         missing = next(item for item in result["episodes"] if item["id"] == 102)
         self.assertTrue(missing["missing"])
         self.assertTrue(missing["best_fit"])
+        unmonitored = next(item for item in result["episodes"] if item["id"] == 103)
+        self.assertFalse(unmonitored["monitored"])
+        self.assertTrue(unmonitored["missing"])
+        self.assertTrue(unmonitored["best_fit"])
         collected = next(item for item in result["episodes"] if item["id"] == 101)
         self.assertEqual(collected["file_id"], 88)
         self.assertNotIn("file_name", collected)
@@ -1468,6 +1484,7 @@ class MediaReplacementTests(unittest.IsolatedAsyncioTestCase):
                 {"id": 101, "episodeFileId": 88},
                 {"id": 102, "episodeFileId": 89},
             ]),
+            monitor_episodes=AsyncMock(return_value={"monitored": True}),
             delete_episode_file=AsyncMock(return_value=None),
             search_episodes=AsyncMock(return_value={"id": 1}),
         )
@@ -1498,9 +1515,87 @@ class MediaReplacementTests(unittest.IsolatedAsyncioTestCase):
             )
 
         self.assertEqual(result["file_ids"], [88, 89])
+        sonarr.monitor_episodes.assert_awaited_once_with([101, 102], True)
         self.assertEqual(sonarr.delete_episode_file.await_count, 2)
         sonarr.search_episodes.assert_awaited_once_with([101, 102])
 
+    async def test_missing_episode_search_monitors_explicit_unmonitored_episode(self) -> None:
+        snapshot = Snapshot(
+            request_id="113",
+            title="Family Guy",
+            request_type=RequestType.tv,
+            state=NormalizedState.available,
+            raw={"arr": {"item": {"id": 540}}},
+        )
+        sonarr = SimpleNamespace(
+            configured=lambda: True,
+            get_episodes=AsyncMock(return_value=[{
+                "id": 36899,
+                "seasonNumber": 5,
+                "episodeNumber": 9,
+                "monitored": False,
+                "hasFile": False,
+                "episodeFileId": 0,
+                "airDateUtc": "2006-12-17T00:00:00Z",
+            }]),
+            monitor_episodes=AsyncMock(return_value={"monitored": True}),
+            search_episodes=AsyncMock(return_value={"id": 9001}),
+            search=AsyncMock(return_value={"id": 9002}),
+        )
+        runtime = SimpleNamespace(
+            sonarr_base_url="http://sonarr",
+            sonarr_api_key="secret",
+        )
+        with (
+            patch.object(requests_router, "get_runtime_settings", return_value=runtime),
+            patch.object(requests_router, "build_snapshot", new=AsyncMock(return_value=snapshot)),
+            patch.object(requests_router, "SonarrClient", return_value=sonarr),
+            patch.object(requests_router, "save_action"),
+        ):
+            result = await requests_router.action_search_missing_media(
+                "113",
+                {"episode_ids": [36899], "season_numbers": [5]},
+                {"username": "admin", "role": "admin", "auto_search_enabled": True},
+            )
+
+        self.assertEqual(result["episode_ids"], [36899])
+        sonarr.monitor_episodes.assert_awaited_once_with([36899], True)
+        sonarr.search_episodes.assert_awaited_once_with([36899])
+        sonarr.search.assert_not_awaited()
+
+    async def test_missing_movie_search_monitors_movie_before_search(self) -> None:
+        snapshot = Snapshot(
+            request_id="3914",
+            title="Missing Movie",
+            request_type=RequestType.movie,
+            state=NormalizedState.available,
+            raw={"arr": {"item": {"id": 44}}},
+        )
+        radarr = SimpleNamespace(
+            configured=lambda: True,
+            monitor_movie=AsyncMock(return_value={"id": 44, "monitored": True}),
+            search=AsyncMock(return_value={"id": 9003}),
+        )
+        runtime = SimpleNamespace(
+            radarr_base_url="http://radarr",
+            radarr_api_key="secret",
+        )
+        with (
+            patch.object(requests_router, "get_runtime_settings", return_value=runtime),
+            patch.object(requests_router, "build_snapshot", new=AsyncMock(return_value=snapshot)),
+            patch.object(requests_router, "RadarrClient", return_value=radarr),
+            patch.object(requests_router, "save_action"),
+        ):
+            result = await requests_router.action_search_missing_media(
+                "3914",
+                {"episode_ids": [], "season_numbers": []},
+                {"username": "admin", "role": "admin", "auto_search_enabled": True},
+            )
+
+        self.assertEqual(result["status"], "ok")
+        radarr.monitor_movie.assert_awaited_once_with(44, True)
+        radarr.search.assert_awaited_once_with(44)
+
     async def test_movie_subtitle_issue_starts_bazarr_search_without_replacement(self) -> None:
         snapshot = Snapshot(
             request_id="3914",