fix: correct test imports, patch targets, and async usage

- Add # noqa: E402 to document that env setup before import is
  required by the module's top-level code (same pattern as existing
  test_gitlab_webhook_port.py)
- Fix mock.patch targets to use sys.modules injection instead of
  patching non-existent pr_agent.servers.gitlab_webhook.gitlab path
- Use AsyncMock for _get_bot_user_id and asyncio.run() for calling
  now-async is_bot_assigned_as_reviewer and _get_bot_user_id

Assisted-by: opencode:deepseek-v4-pro

Author: igoraj

tests/unittest/test_gitlab_reviewer_assignment.py

@@ -1,15 +1,17 @@
+import asyncio
 import os
 from unittest import mock
 
 os.environ.setdefault("GITLAB__URL", "https://gitlab.example.com")
-import pr_agent.servers.gitlab_webhook as gitlab_webhook
+import pr_agent.servers.gitlab_webhook as gitlab_webhook  # noqa: E402
 
 
 class TestIsBotAssignedAsReviewer:
     BOT_ID = 516
 
-    @mock.patch.object(gitlab_webhook, "_get_bot_user_id", return_value=BOT_ID)
-    def test_detects_new_assignment(self, _mock_bot_id):
+    @mock.patch.object(gitlab_webhook, "_get_bot_user_id", new_callable=mock.AsyncMock)
+    def test_detects_new_assignment(self, mock_bot_id):
+        mock_bot_id.return_value = self.BOT_ID
         data = {
             "changes": {
                 "reviewers": {
@@ -18,10 +20,11 @@ def test_detects_new_assignment(self, _mock_bot_id):
                 }
             }
         }
-        assert gitlab_webhook.is_bot_assigned_as_reviewer(data) is True
+        assert asyncio.run(gitlab_webhook.is_bot_assigned_as_reviewer(data)) is True
 
-    @mock.patch.object(gitlab_webhook, "_get_bot_user_id", return_value=BOT_ID)
-    def test_ignores_already_assigned(self, _mock_bot_id):
+    @mock.patch.object(gitlab_webhook, "_get_bot_user_id", new_callable=mock.AsyncMock)
+    def test_ignores_already_assigned(self, mock_bot_id):
+        mock_bot_id.return_value = self.BOT_ID
         data = {
             "changes": {
                 "reviewers": {
@@ -30,28 +33,31 @@ def test_ignores_already_assigned(self, _mock_bot_id):
                 }
             }
         }
-        assert gitlab_webhook.is_bot_assigned_as_reviewer(data) is False
+        assert asyncio.run(gitlab_webhook.is_bot_assigned_as_reviewer(data)) is False
 
-    @mock.patch.object(gitlab_webhook, "_get_bot_user_id", return_value=BOT_ID)
-    def test_no_reviewers_key(self, _mock_bot_id):
+    @mock.patch.object(gitlab_webhook, "_get_bot_user_id", new_callable=mock.AsyncMock)
+    def test_no_reviewers_key(self, mock_bot_id):
+        mock_bot_id.return_value = self.BOT_ID
         data = {"changes": {"updated_at": {"previous": "old", "current": "new"}}}
-        assert gitlab_webhook.is_bot_assigned_as_reviewer(data) is False
+        assert asyncio.run(gitlab_webhook.is_bot_assigned_as_reviewer(data)) is False
 
     def test_changes_not_dict(self):
         data = {"changes": "not-a-dict"}
-        assert gitlab_webhook.is_bot_assigned_as_reviewer(data) is False
+        assert asyncio.run(gitlab_webhook.is_bot_assigned_as_reviewer(data)) is False
 
-    @mock.patch.object(gitlab_webhook, "_get_bot_user_id", return_value=BOT_ID)
-    def test_reviewers_not_dict(self, _mock_bot_id):
+    @mock.patch.object(gitlab_webhook, "_get_bot_user_id", new_callable=mock.AsyncMock)
+    def test_reviewers_not_dict(self, mock_bot_id):
+        mock_bot_id.return_value = self.BOT_ID
         data = {"changes": {"reviewers": "not-a-dict"}}
-        assert gitlab_webhook.is_bot_assigned_as_reviewer(data) is False
+        assert asyncio.run(gitlab_webhook.is_bot_assigned_as_reviewer(data)) is False
 
     def test_no_changes_key(self):
         data = {"object_kind": "merge_request"}
-        assert gitlab_webhook.is_bot_assigned_as_reviewer(data) is False
+        assert asyncio.run(gitlab_webhook.is_bot_assigned_as_reviewer(data)) is False
 
-    @mock.patch.object(gitlab_webhook, "_get_bot_user_id", return_value=None)
-    def test_bot_id_unresolvable(self, _mock_bot_id):
+    @mock.patch.object(gitlab_webhook, "_get_bot_user_id", new_callable=mock.AsyncMock)
+    def test_bot_id_unresolvable(self, mock_bot_id):
+        mock_bot_id.return_value = None
         data = {
             "changes": {
                 "reviewers": {
@@ -60,10 +66,11 @@ def test_bot_id_unresolvable(self, _mock_bot_id):
                 }
             }
         }
-        assert gitlab_webhook.is_bot_assigned_as_reviewer(data) is False
+        assert asyncio.run(gitlab_webhook.is_bot_assigned_as_reviewer(data)) is False
 
-    @mock.patch.object(gitlab_webhook, "_get_bot_user_id", return_value=BOT_ID)
-    def test_previous_with_non_dict_entries(self, _mock_bot_id):
+    @mock.patch.object(gitlab_webhook, "_get_bot_user_id", new_callable=mock.AsyncMock)
+    def test_previous_with_non_dict_entries(self, mock_bot_id):
+        mock_bot_id.return_value = self.BOT_ID
         data = {
             "changes": {
                 "reviewers": {
@@ -72,50 +79,53 @@ def test_previous_with_non_dict_entries(self, _mock_bot_id):
                 }
             }
         }
-        assert gitlab_webhook.is_bot_assigned_as_reviewer(data) is True
+        assert asyncio.run(gitlab_webhook.is_bot_assigned_as_reviewer(data)) is True
 
 
 class TestGetBotUserId:
+    @staticmethod
+    def _make_fake_gitlab(user_id):
+        fake = mock.MagicMock()
+        fake.Gitlab.return_value.auth.return_value = None
+        fake.Gitlab.return_value.user.id = user_id
+        return fake
+
+    @staticmethod
+    def _make_settings(url, token):
+        s = mock.MagicMock()
+        s.get.side_effect = lambda k, d=None: {
+            "GITLAB.URL": url,
+            "GITLAB.PERSONAL_ACCESS_TOKEN": token,
+            "GITLAB.SSL_VERIFY": True,
+            "GITLAB.AUTH_TYPE": "oauth_token",
+        }.get(k, d)
+        return s
+
     def test_caches_by_credential(self, monkeypatch):
         gitlab_webhook._bot_user_id_cache.clear()
 
-        from unittest.mock import MagicMock
-
-        def make_settings(url, token):
-            s = MagicMock()
-            s.get.side_effect = lambda k, d=None: {"GITLAB.URL": url, "GITLAB.PERSONAL_ACCESS_TOKEN": token, "GITLAB.SSL_VERIFY": True, "GITLAB.AUTH_TYPE": "oauth_token"}.get(k, d)
-            return s
-
-        gl_mock = MagicMock()
-        gl_mock.user.id = 111
-        mock_gitlab_cls = MagicMock(return_value=gl_mock)
+        with mock.patch("pr_agent.servers.gitlab_webhook.get_settings",
+                        return_value=self._make_settings("https://a.example.com", "token-a")):
+            with mock.patch.dict("sys.modules", {"gitlab": self._make_fake_gitlab(111)}):
+                assert asyncio.run(gitlab_webhook._get_bot_user_id()) == 111
 
-        with mock.patch("pr_agent.servers.gitlab_webhook.get_settings", return_value=make_settings("https://a.example.com", "token-a")):
-            with mock.patch("pr_agent.servers.gitlab_webhook.gitlab.Gitlab", mock_gitlab_cls):
-                assert gitlab_webhook._get_bot_user_id() == 111
-
-        gl_mock.user.id = 222
-        with mock.patch("pr_agent.servers.gitlab_webhook.get_settings", return_value=make_settings("https://a.example.com", "token-b")):
-            with mock.patch("pr_agent.servers.gitlab_webhook.gitlab.Gitlab", mock_gitlab_cls):
-                assert gitlab_webhook._get_bot_user_id() == 222
+        with mock.patch("pr_agent.servers.gitlab_webhook.get_settings",
+                        return_value=self._make_settings("https://a.example.com", "token-b")):
+            with mock.patch.dict("sys.modules", {"gitlab": self._make_fake_gitlab(222)}):
+                assert asyncio.run(gitlab_webhook._get_bot_user_id()) == 222
 
         assert len(gitlab_webhook._bot_user_id_cache) >= 2
 
     def test_negative_cache_on_failure(self, monkeypatch):
         gitlab_webhook._bot_user_id_cache.clear()
 
-        from unittest.mock import MagicMock
-
-        def make_settings():
-            s = MagicMock()
-            s.get.side_effect = lambda k, d=None: {"GITLAB.URL": "https://x.example.com", "GITLAB.PERSONAL_ACCESS_TOKEN": "fail-token", "GITLAB.SSL_VERIFY": True, "GITLAB.AUTH_TYPE": "oauth_token"}.get(k, d)
-            return s
+        fake = self._make_fake_gitlab(0)
+        fake.Gitlab.side_effect = RuntimeError("auth failed")
 
-        mock_gitlab_cls = MagicMock(side_effect=RuntimeError("auth failed"))
-
-        with mock.patch("pr_agent.servers.gitlab_webhook.get_settings", return_value=make_settings()):
-            with mock.patch("pr_agent.servers.gitlab_webhook.gitlab.Gitlab", mock_gitlab_cls):
-                assert gitlab_webhook._get_bot_user_id() is None
+        with mock.patch("pr_agent.servers.gitlab_webhook.get_settings",
+                        return_value=self._make_settings("https://x.example.com", "fail-token")):
+            with mock.patch.dict("sys.modules", {"gitlab": fake}):
+                assert asyncio.run(gitlab_webhook._get_bot_user_id()) is None
 
         assert len(gitlab_webhook._bot_user_id_cache) == 1
         cached_val = next(iter(gitlab_webhook._bot_user_id_cache.values()))
@@ -124,32 +134,34 @@ def make_settings():
     def test_respects_auth_type_private_token(self):
         gitlab_webhook._bot_user_id_cache.clear()
 
-        from unittest.mock import MagicMock
-
-        def make_settings():
-            s = MagicMock()
-            s.get.side_effect = lambda k, d=None: {"GITLAB.URL": "https://x.example.com", "GITLAB.PERSONAL_ACCESS_TOKEN": "tok", "GITLAB.SSL_VERIFY": True, "GITLAB.AUTH_TYPE": "private_token"}.get(k, d)
-            return s
+        s = mock.MagicMock()
+        s.get.side_effect = lambda k, d=None: {
+            "GITLAB.URL": "https://x.example.com",
+            "GITLAB.PERSONAL_ACCESS_TOKEN": "tok",
+            "GITLAB.SSL_VERIFY": True,
+            "GITLAB.AUTH_TYPE": "private_token",
+        }.get(k, d)
 
-        gl_mock = MagicMock()
-        gl_mock.user.id = 99
-        mock_gitlab_cls = MagicMock(return_value=gl_mock)
+        fake_gitlab = self._make_fake_gitlab(99)
 
-        with mock.patch("pr_agent.servers.gitlab_webhook.get_settings", return_value=make_settings()):
-            with mock.patch("pr_agent.servers.gitlab_webhook.gitlab.Gitlab", mock_gitlab_cls):
-                assert gitlab_webhook._get_bot_user_id() == 99
+        with mock.patch("pr_agent.servers.gitlab_webhook.get_settings", return_value=s):
+            with mock.patch.dict("sys.modules", {"gitlab": fake_gitlab}):
+                assert asyncio.run(gitlab_webhook._get_bot_user_id()) == 99
 
-        call_kwargs = mock_gitlab_cls.call_args.kwargs
+        call_kwargs = fake_gitlab.Gitlab.call_args.kwargs
         assert "private_token" in call_kwargs
         assert call_kwargs["private_token"] == "tok"
 
     def test_no_token_returns_none(self, monkeypatch):
         gitlab_webhook._bot_user_id_cache.clear()
 
-        from unittest.mock import MagicMock
-
-        s = MagicMock()
-        s.get.side_effect = lambda k, d=None: {"GITLAB.URL": "https://x.example.com", "GITLAB.PERSONAL_ACCESS_TOKEN": None, "GITLAB.SSL_VERIFY": True, "GITLAB.AUTH_TYPE": "oauth_token"}.get(k, d)
+        s = mock.MagicMock()
+        s.get.side_effect = lambda k, d=None: {
+            "GITLAB.URL": "https://x.example.com",
+            "GITLAB.PERSONAL_ACCESS_TOKEN": None,
+            "GITLAB.SSL_VERIFY": True,
+            "GITLAB.AUTH_TYPE": "oauth_token",
+        }.get(k, d)
 
         with mock.patch("pr_agent.servers.gitlab_webhook.get_settings", return_value=s):
-            assert gitlab_webhook._get_bot_user_id() is None
+            assert asyncio.run(gitlab_webhook._get_bot_user_id()) is None