@ripla/godd-mcp 1.0.4-canary.8 → 1.0.4

package/{notes-api → notes/api}/tests/test_github_service.py

@@ -6,6 +6,7 @@ from unittest.mock import AsyncMock, MagicMock, patch
 import pytest
 
 from app.services.github import _is_binary, fetch_file_content
+from app.services.github_issues import create_issue
 from app.services.github_pr import _paginate_pulls, compare_branches
 
 
@@ -214,3 +215,44 @@ class TestPaginatePullsDedup:
 
         assert len(result) == 2
         assert [pr["id"] for pr in result] == [10, 20]
+
+
+class TestCreateIssuePatWarning:
+    @pytest.fixture
+    def github_config(self):
+        return {
+            "owner": "testorg",
+            "repo": "testrepo",
+            "branch": "main",
+            "token": "ghp_test",
+        }
+
+    async def test_create_issue_warns_when_pat_fallback(self, github_config):
+        mock_resp = MagicMock()
+        mock_resp.raise_for_status = MagicMock()
+        mock_resp.json.return_value = {
+            "number": 1,
+            "title": "Test",
+            "state": "open",
+            "body": "",
+            "labels": [],
+            "user": {"login": "test-user"},
+            "created_at": "2026-01-01T00:00:00Z",
+            "updated_at": "2026-01-01T00:00:00Z",
+            "html_url": "https://github.com/testorg/testrepo/issues/1",
+        }
+        mock_client = AsyncMock()
+        mock_client.post.return_value = mock_resp
+
+        with (
+            patch("app.services.github_issues.get_github_client", return_value=mock_client),
+            patch(
+                "app.services.github_issues.resolve_token",
+                new_callable=AsyncMock,
+                return_value="ghp_test",
+            ),
+            patch("app.services.github_issues.warn_if_pat_used_for_write") as mock_warn,
+        ):
+            await create_issue(github_config, title="Test")
+
+        mock_warn.assert_called_once_with("Issue")

package/notes/api/tests/test_health.py

@@ -0,0 +1,52 @@
+"""Test health endpoint."""
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+
+@pytest.mark.asyncio
+async def test_health(client):
+    """Health check returns ok with GitHub author diagnostics."""
+    resp = await client.get("/api/health")
+    assert resp.status_code == 200
+    body = resp.json()
+    assert body["status"] == "ok"
+    assert body["github_app_configured"] is False
+    assert body["github_write_author"] == "mock"
+
+
+@pytest.mark.asyncio
+@patch("app.main.github_write_author_mode", return_value="bot")
+@patch("app.main.is_app_configured", return_value=True)
+async def test_health_when_github_app_configured(
+    _mock_configured,
+    _mock_mode,
+    client,
+):
+    resp = await client.get("/api/health")
+    assert resp.status_code == 200
+    body = resp.json()
+    assert body["github_app_configured"] is True
+    assert body["github_write_author"] == "bot"
+
+
+@pytest.mark.asyncio
+@patch("app.main.get_installation_token", new_callable=AsyncMock, return_value="ghs_test")
+@patch("app.main.is_app_configured", return_value=True)
+async def test_github_app_health_refresh_success(
+    _mock_configured,
+    _mock_token,
+    client,
+):
+    resp = await client.get("/api/health/github-app")
+    assert resp.status_code == 200
+    assert resp.json()["token_refresh"] == "success"
+    assert resp.json()["github_write_author"] == "bot"
+
+
+@pytest.mark.asyncio
+@patch("app.main.is_app_configured", return_value=False)
+async def test_github_app_health_not_configured(_mock_configured, client):
+    resp = await client.get("/api/health/github-app")
+    assert resp.status_code == 503

package/{notes-api → notes/api}/tests/test_issues.py

@@ -36,6 +36,49 @@ class TestListIssues:
         assert resp.status_code == 200
         assert resp.json()["issues"] == mock_issues
 
+    async def test_list_issues_with_assignee_filter(self, client: AsyncClient, admin_token):
+        mock_issues = [
+            {"number": 1, "title": "Assigned Issue", "state": "open", "labels": []},
+        ]
+        with (
+            patch("app.routers.issues.settings") as mock_settings,
+            patch("app.routers.issues.get_github_config") as mock_config,
+            patch("app.routers.issues.list_issues", new_callable=AsyncMock) as mock_list,
+        ):
+            mock_settings.is_mock_mode.return_value = False
+            mock_config.return_value = {"token": "t", "owner": "o", "repo": "r", "branch": "main"}
+            mock_list.return_value = mock_issues
+            resp = await client.get(
+                "/api/issues?assignee=octocat",
+                headers=auth_headers(admin_token),
+            )
+        assert resp.status_code == 200
+        mock_list.assert_awaited_once()
+        assert mock_list.await_args.kwargs["assignee"] == "octocat"
+
+    async def test_list_issues_with_assignee_none_filter(self, client: AsyncClient, admin_token):
+        with (
+            patch("app.routers.issues.settings") as mock_settings,
+            patch("app.routers.issues.get_github_config") as mock_config,
+            patch("app.routers.issues.list_issues", new_callable=AsyncMock) as mock_list,
+        ):
+            mock_settings.is_mock_mode.return_value = False
+            mock_config.return_value = {"token": "t", "owner": "o", "repo": "r", "branch": "main"}
+            mock_list.return_value = []
+            resp = await client.get(
+                "/api/issues?assignee=none",
+                headers=auth_headers(admin_token),
+            )
+        assert resp.status_code == 200
+        assert mock_list.await_args.kwargs["assignee"] == "none"
+
+    async def test_list_issues_invalid_assignee(self, client: AsyncClient, admin_token):
+        resp = await client.get(
+            "/api/issues?assignee=invalid-",
+            headers=auth_headers(admin_token),
+        )
+        assert resp.status_code == 422
+
     async def test_list_issues_github_auth_error(self, client: AsyncClient, admin_token):
         mock_resp = httpx.Response(401, request=httpx.Request("GET", "https://api.github.com"))
         with (
@@ -235,3 +278,176 @@ class TestListLabels:
             resp = await client.get("/api/issues/labels", headers=auth_headers(admin_token))
         assert resp.status_code == 200
         assert resp.json()["labels"][0]["name"] == "bug"
+
+
+class TestLabelMutations:
+    async def test_update_label_success(self, client: AsyncClient, admin_token):
+        mock_updated = {"name": "bug-fixed", "color": "ff0000", "description": "fixed"}
+        with (
+            patch("app.routers.issues.settings") as mock_settings,
+            patch("app.routers.issues.get_github_config") as mock_config,
+            patch("app.routers.issues.update_label", new_callable=AsyncMock) as mock_update,
+        ):
+            mock_settings.is_mock_mode.return_value = False
+            mock_config.return_value = {"token": "t", "owner": "o", "repo": "r", "branch": "main"}
+            mock_update.return_value = mock_updated
+            resp = await client.patch(
+                "/api/issues/labels/bug",
+                json={"new_name": "bug-fixed", "color": "ff0000"},
+                headers=auth_headers(admin_token),
+            )
+        assert resp.status_code == 200
+        assert resp.json()["name"] == "bug-fixed"
+        mock_update.assert_awaited_once()
+
+    async def test_update_label_empty_body(self, client: AsyncClient, admin_token):
+        with patch("app.routers.issues.settings") as mock_settings:
+            mock_settings.is_mock_mode.return_value = False
+            resp = await client.patch(
+                "/api/issues/labels/bug",
+                json={},
+                headers=auth_headers(admin_token),
+            )
+        assert resp.status_code == 422
+
+    async def test_update_label_viewer_forbidden(
+        self, client: AsyncClient, viewer_token,
+    ):
+        resp = await client.patch(
+            "/api/issues/labels/bug",
+            json={"color": "ff0000"},
+            headers=auth_headers(viewer_token),
+        )
+        assert resp.status_code == 403
+
+    async def test_update_label_mock_mode(self, client: AsyncClient, admin_token):
+        with patch("app.routers.issues.settings") as mock_settings:
+            mock_settings.is_mock_mode.return_value = True
+            resp = await client.patch(
+                "/api/issues/labels/bug",
+                json={"color": "ff0000"},
+                headers=auth_headers(admin_token),
+            )
+        assert resp.status_code == 400
+
+    async def test_delete_label_success(self, client: AsyncClient, admin_token):
+        with (
+            patch("app.routers.issues.settings") as mock_settings,
+            patch("app.routers.issues.get_github_config") as mock_config,
+            patch("app.routers.issues.delete_label", new_callable=AsyncMock) as mock_delete,
+        ):
+            mock_settings.is_mock_mode.return_value = False
+            mock_config.return_value = {"token": "t", "owner": "o", "repo": "r", "branch": "main"}
+            resp = await client.delete(
+                "/api/issues/labels/bug",
+                headers=auth_headers(admin_token),
+            )
+        assert resp.status_code == 204
+        mock_delete.assert_awaited_once()
+
+    async def test_delete_label_viewer_forbidden(
+        self, client: AsyncClient, viewer_token,
+    ):
+        resp = await client.delete(
+            "/api/issues/labels/bug",
+            headers=auth_headers(viewer_token),
+        )
+        assert resp.status_code == 403
+
+    async def test_delete_label_mock_mode(self, client: AsyncClient, admin_token):
+        with patch("app.routers.issues.settings") as mock_settings:
+            mock_settings.is_mock_mode.return_value = True
+            resp = await client.delete(
+                "/api/issues/labels/bug",
+                headers=auth_headers(admin_token),
+            )
+        assert resp.status_code == 400
+
+
+class TestIssueComments:
+    async def test_list_comments_mock_mode(self, client: AsyncClient, admin_token):
+        with patch("app.routers.issues.settings") as mock_settings:
+            mock_settings.is_mock_mode.return_value = True
+            resp = await client.get(
+                "/api/issues/42/comments",
+                headers=auth_headers(admin_token),
+            )
+        assert resp.status_code == 200
+        assert resp.json() == {"comments": []}
+
+    async def test_list_comments_success(self, client: AsyncClient, admin_token):
+        mock_comments = [
+            {
+                "id": 1,
+                "body": "First comment",
+                "author": "alice",
+                "createdAt": "2026-05-19T00:00:00Z",
+                "updatedAt": "2026-05-19T00:00:00Z",
+                "url": "https://github.com/o/r/issues/42#issuecomment-1",
+            },
+        ]
+        with (
+            patch("app.routers.issues.settings") as mock_settings,
+            patch("app.routers.issues.get_github_config") as mock_config,
+            patch(
+                "app.routers.issues.list_issue_comments",
+                new_callable=AsyncMock,
+            ) as mock_list,
+        ):
+            mock_settings.is_mock_mode.return_value = False
+            mock_config.return_value = {"token": "t", "owner": "o", "repo": "r", "branch": "main"}
+            mock_list.return_value = mock_comments
+            resp = await client.get(
+                "/api/issues/42/comments",
+                headers=auth_headers(admin_token),
+            )
+        assert resp.status_code == 200
+        assert resp.json()["comments"] == mock_comments
+
+    async def test_create_comment_success(self, client: AsyncClient, admin_token):
+        mock_created = {
+            "id": 2,
+            "body": "New comment",
+            "author": "bot",
+            "createdAt": "2026-05-20T00:00:00Z",
+            "updatedAt": "2026-05-20T00:00:00Z",
+            "url": "https://github.com/o/r/issues/42#issuecomment-2",
+        }
+        with (
+            patch("app.routers.issues.settings") as mock_settings,
+            patch("app.routers.issues.get_github_config") as mock_config,
+            patch(
+                "app.routers.issues.create_issue_comment",
+                new_callable=AsyncMock,
+            ) as mock_create,
+        ):
+            mock_settings.is_mock_mode.return_value = False
+            mock_config.return_value = {"token": "t", "owner": "o", "repo": "r", "branch": "main"}
+            mock_create.return_value = mock_created
+            resp = await client.post(
+                "/api/issues/42/comments",
+                json={"body": "New comment"},
+                headers=auth_headers(admin_token),
+            )
+        assert resp.status_code == 201
+        assert resp.json()["body"] == "New comment"
+
+    async def test_create_comment_viewer_forbidden(
+        self, client: AsyncClient, viewer_token,
+    ):
+        resp = await client.post(
+            "/api/issues/42/comments",
+            json={"body": "Forbidden"},
+            headers=auth_headers(viewer_token),
+        )
+        assert resp.status_code == 403
+
+    async def test_create_comment_mock_mode(self, client: AsyncClient, admin_token):
+        with patch("app.routers.issues.settings") as mock_settings:
+            mock_settings.is_mock_mode.return_value = True
+            resp = await client.post(
+                "/api/issues/42/comments",
+                json={"body": "test"},
+                headers=auth_headers(admin_token),
+            )
+        assert resp.status_code == 400

package/{notes-api → notes/api}/tests/test_pr.py

@@ -24,6 +24,30 @@ class TestListSessions:
         resp = await client.get("/api/pr/sessions")
         assert resp.status_code == 401
 
+    async def test_list_sessions_editor_allowed(
+        self, client: AsyncClient, mock_db, editor_token,
+    ):
+        resp = await client.get(
+            "/api/pr/sessions",
+            headers=auth_headers(editor_token),
+        )
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["sessions"] == []
+        assert data["mock"] is True
+
+    async def test_list_sessions_viewer_allowed(
+        self, client: AsyncClient, mock_db, viewer_token,
+    ):
+        resp = await client.get(
+            "/api/pr/sessions",
+            headers=auth_headers(viewer_token),
+        )
+        assert resp.status_code == 200
+        data = resp.json()
+        assert data["sessions"] == []
+        assert data["mock"] is True
+
 
 class TestMySession:
     async def test_my_session_mock_mode(

package/{notes-api → notes/api}/tests/test_pr_chain.py

@@ -529,6 +529,25 @@ class TestCreatePrDraftFlag:
         call_json = mock_client.post.call_args[1]["json"]
         assert call_json["draft"] is True
 
+    @pytest.mark.asyncio
+    async def test_create_pr_warns_when_pat_fallback(self):
+        mock_resp = MagicMock()
+        mock_resp.status_code = 201
+        mock_resp.json.return_value = {**FAKE_PR, "draft": True}
+        mock_resp.raise_for_status = MagicMock()
+
+        mock_client = AsyncMock()
+        mock_client.post = AsyncMock(return_value=mock_resp)
+
+        with (
+            patch("app.services.github_pr.get_github_client", return_value=mock_client),
+            patch("app.services.github_pr.is_app_configured", return_value=False),
+            patch("app.services.github_pr.warn_if_pat_used_for_write") as mock_warn,
+        ):
+            await create_pr("title", "head", "main", "body", [], FAKE_CONFIG)
+
+        mock_warn.assert_called_once_with("Pull request")
+
 
 class TestMarkPrReady:
     @pytest.mark.asyncio