@datarecce/ui 0.1.30 → 0.1.31

package/recce-source/tests/test_server.py

@@ -0,0 +1,202 @@
+import os
+from datetime import datetime, timezone
+
+import pytest
+from fastapi.testclient import TestClient
+
+from recce.core import default_context
+from recce.server import app
+
+# noinspection PyUnresolvedReferences
+from tests.adapter.dbt_adapter.conftest import dbt_test_helper  # noqa: F401
+
+
+@pytest.fixture
+def temp_folder():
+    import tempfile
+
+    temp_dir = tempfile.mkdtemp()
+    yield temp_dir
+
+    import shutil
+
+    shutil.rmtree(temp_dir)
+
+
+@pytest.fixture(autouse=True)
+def init_app_state():
+    """Initialize app.state.last_activity for all tests to prevent middleware errors."""
+    app.state.last_activity = None
+    yield
+    # Cleanup after test
+    app.state.last_activity = None
+
+
+def test_health():
+    client = TestClient(app)
+    response = client.get("/api/health")
+    assert response.status_code == 200
+    assert response.json() == {"status": "ok"}
+
+
+def test_stateless(dbt_test_helper):
+    context = default_context()
+    from recce.state import FileStateLoader
+
+    context.state_loader = FileStateLoader()
+    client = TestClient(app)
+    response = client.get("/api/info")
+    assert response.status_code == 200
+    info = response.json()
+    assert info["file_mode"] is False
+    assert info["cloud_mode"] is False
+
+
+def test_file_mode(dbt_test_helper):
+    context = default_context()
+    from recce.state import FileStateLoader
+
+    context.state_loader = FileStateLoader(state_file="/tmp/recce_state.json")
+    client = TestClient(app)
+    response = client.get("/api/info")
+    assert response.status_code == 200
+    info = response.json()
+    assert info["file_mode"] is True
+    assert info["filename"] == "recce_state.json"
+    assert info["cloud_mode"] is False
+
+
+def test_saveas_and_rename(dbt_test_helper, temp_folder):
+    context = default_context()
+    state_file = os.path.join(temp_folder, "recce_state.json")
+    state_file2 = os.path.join(temp_folder, "recce_state2.json")
+    state_file3 = os.path.join(temp_folder, "recce_state3.json")
+    os.makedirs(os.path.join(temp_folder, "dir.json"))
+
+    from recce.state import FileStateLoader
+
+    context.state_loader = FileStateLoader(state_file=state_file)
+    client = TestClient(app)
+
+    response = client.post("/api/save", json={"filename": "recce_state2.json"})
+    assert response.status_code == 200
+    assert os.path.exists(state_file)
+
+    response = client.post("/api/save-as", json={"filename": "recce_state2.json"})
+    assert response.status_code == 200
+    assert os.path.exists(state_file2)
+    assert context.state_loader.state_file == os.path.join(temp_folder, "recce_state2.json")
+
+    # Same file
+    response = client.post("/api/save-as", json={"filename": "recce_state2.json"})
+    assert response.status_code == 400
+
+    # folder
+    response = client.post("/api/save-as", json={"filename": "dir.json"})
+    assert response.status_code == 400
+
+    # Rename
+    response = client.post("/api/rename", json={"filename": "recce_state3.json"})
+    assert response.status_code == 200
+    assert not os.path.exists(state_file2)
+    assert os.path.exists(state_file3)
+    assert context.state_loader.state_file == os.path.join(temp_folder, "recce_state3.json")
+
+    # Conflict
+    response = client.post("/api/save-as", json={"filename": "recce_state.json"})
+    assert response.status_code == 409
+    response = client.post("/api/rename", json={"filename": "recce_state.json"})
+    assert response.status_code == 409
+
+    # Overwrite
+    response = client.post("/api/save-as", json={"filename": "recce_state.json", "overwrite": True})
+    assert response.status_code == 200
+    assert context.state_loader.state_file == os.path.join(temp_folder, "recce_state.json")
+
+
+def test_keep_alive_without_idle_timeout():
+    """Test keep-alive endpoint when idle timeout is not configured"""
+    client = TestClient(app)
+
+    # Ensure last_activity is None (idle timeout not configured)
+    app.state.last_activity = None
+
+    response = client.post("/api/keep-alive")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "ok"
+    assert data["idle_timeout_enabled"] is False
+
+
+def test_keep_alive_with_idle_timeout():
+    """Test keep-alive endpoint resets idle timer when idle timeout is configured"""
+    client = TestClient(app)
+
+    # Set up idle timeout state
+    initial_time = datetime.now(timezone.utc)
+    app.state.last_activity = {"time": initial_time}
+
+    # Call keep-alive
+    response = client.post("/api/keep-alive")
+    assert response.status_code == 200
+    data = response.json()
+    assert data["status"] == "ok"
+    assert data["idle_timeout_enabled"] is True
+
+    # Verify timer was reset (should be newer than initial time)
+    assert app.state.last_activity["time"] >= initial_time
+
+    # Cleanup
+    app.state.last_activity = None
+
+
+def test_spa_route_checks():
+    """Test that /checks route serves index.html correctly via StaticFiles"""
+    client = TestClient(app)
+    response = client.get("/checks")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "text/html; charset=utf-8"
+    assert b"<!DOCTYPE html>" in response.content
+
+
+def test_spa_route_lineage():
+    """Test that /lineage route serves index.html correctly via StaticFiles"""
+    client = TestClient(app)
+    response = client.get("/lineage")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "text/html; charset=utf-8"
+    assert b"<!DOCTYPE html>" in response.content
+
+
+def test_spa_route_query():
+    """Test that /query route serves index.html correctly via StaticFiles"""
+    client = TestClient(app)
+    response = client.get("/query")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "text/html; charset=utf-8"
+    assert b"<!DOCTYPE html>" in response.content
+
+
+def test_spa_route_with_query_parameters():
+    """Test that query parameters work with SPA routes"""
+    client = TestClient(app)
+    # StaticFiles serves the index.html regardless of query params
+    # The actual routing happens client-side in the SPA
+    response = client.get("/checks?id=abc-123")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "text/html; charset=utf-8"
+    assert b"<!DOCTYPE html>" in response.content
+
+    response = client.get("/lineage?node=model.my_model")
+    assert response.status_code == 200
+    assert response.headers["content-type"] == "text/html; charset=utf-8"
+    assert b"<!DOCTYPE html>" in response.content
+
+
+def test_nonexistent_route_returns_404():
+    """Test that non-existent routes return 404.html with 404 status code"""
+    client = TestClient(app)
+    response = client.get("/nonexistent-page")
+    assert response.status_code == 404
+    assert response.headers["content-type"] == "text/html; charset=utf-8"
+    assert b"<!DOCTYPE html>" in response.content

package/recce-source/tests/test_server_lifespan.py

@@ -0,0 +1,138 @@
+"""Tests for the FastAPI lifespan context manager in recce/server.py"""
+
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from recce.server import AppState, app, lifespan
+
+
+@pytest.fixture
+def mock_app_state():
+    """Create a mock AppState for testing."""
+    state = AppState()
+    state.command = "server"
+    state.state_loader = MagicMock()
+    state.kwargs = {"debug": False}
+    state.flag = {}
+    state.lifetime = None
+    state.idle_timeout = None
+    return state
+
+
+@pytest.fixture
+def setup_app_state(mock_app_state):
+    """Set up app.state for lifespan tests."""
+    original_state = getattr(app, "state", None)
+    app.state = mock_app_state
+    yield mock_app_state
+    app.state = original_state
+
+
+class TestLifespan:
+    """Tests for lifespan setup and teardown."""
+
+    @pytest.mark.parametrize(
+        "command,setup_fn,teardown_fn",
+        [
+            ("server", "setup_server", "teardown_server"),
+            ("preview", "setup_preview", "teardown_preview"),
+            ("read-only", "setup_ready_only", "teardown_ready_only"),
+        ],
+    )
+    @pytest.mark.asyncio
+    async def test_setup_and_teardown_called_for_command(
+        self,
+        setup_app_state,
+        command,
+        setup_fn,
+        teardown_fn,
+    ):
+        """Test that correct setup and teardown are called for each command."""
+        setup_app_state.command = command
+
+        with patch(f"recce.server.{setup_fn}") as mock_setup, patch(f"recce.server.{teardown_fn}") as mock_teardown:
+            mock_ctx = MagicMock()
+            mock_setup.return_value = mock_ctx
+
+            async with lifespan(app):
+                mock_setup.assert_called_once_with(setup_app_state)
+
+            if command == "read-only":
+                mock_teardown.assert_called_once_with(setup_app_state)
+            else:
+                mock_teardown.assert_called_once_with(setup_app_state, mock_ctx)
+
+    @pytest.mark.parametrize(
+        "lifetime,idle_timeout,expect_lifetime,expect_idle",
+        [
+            (3600, 300, True, True),  # both set
+            (None, None, False, False),  # neither set
+            (0, 0, False, False),  # zero = disabled
+        ],
+    )
+    @pytest.mark.asyncio
+    @patch("recce.server.setup_server")
+    @patch("recce.server.teardown_server")
+    @patch("recce.server.schedule_lifetime_termination")
+    @patch("recce.server.schedule_idle_timeout_check")
+    async def test_timeout_scheduling(
+        self,
+        mock_idle_check,
+        mock_lifetime,
+        mock_teardown,
+        mock_setup,
+        setup_app_state,
+        lifetime,
+        idle_timeout,
+        expect_lifetime,
+        expect_idle,
+    ):
+        """Test lifetime and idle_timeout scheduling."""
+        setup_app_state.command = "server"
+        setup_app_state.lifetime = lifetime
+        setup_app_state.idle_timeout = idle_timeout
+
+        async with lifespan(app):
+            pass
+
+        assert mock_lifetime.called == expect_lifetime
+        assert mock_idle_check.called == expect_idle
+
+    @pytest.mark.asyncio
+    @patch("recce.server.setup_server")
+    @patch("recce.server.teardown_server")
+    async def test_debug_logging_enabled(
+        self,
+        mock_teardown,
+        mock_setup,
+        setup_app_state,
+    ):
+        """Test logger set to DEBUG when debug=True."""
+        import logging
+
+        setup_app_state.kwargs = {"debug": True}
+
+        uvicorn_logger = logging.getLogger("uvicorn")
+        original_level = uvicorn_logger.level
+
+        try:
+            async with lifespan(app):
+                assert uvicorn_logger.level == logging.DEBUG
+        finally:
+            uvicorn_logger.setLevel(original_level)
+
+    @pytest.mark.asyncio
+    @patch("recce.server.setup_server")
+    @patch("recce.server.teardown_server")
+    async def test_kwargs_none_handled(
+        self,
+        mock_teardown,
+        mock_setup,
+        setup_app_state,
+    ):
+        """Test kwargs=None doesn't crash."""
+        setup_app_state.kwargs = None
+
+        async with lifespan(app):
+            pass  # Should not raise

package/recce-source/tests/test_summary.py

@@ -0,0 +1,73 @@
+import os
+
+import pytest
+
+from recce.adapter.dbt_adapter import DbtAdapter, DbtVersion, load_manifest
+from recce.core import RecceContext, set_default_context
+from recce.summary import (
+    _build_lineage_graph,
+    generate_mermaid_lineage_graph,
+    generate_summary_metadata,
+)
+
+current_dir = os.path.dirname(os.path.abspath(__file__))
+base_manifest_dir = os.path.join(current_dir, "data", "manifest", "base")
+pr2_manifest_dir = os.path.join(current_dir, "data", "manifest", "pr2")  # Pull Request 2l
+
+
+def test_generate_summary_metadata():
+    dbt_version = DbtVersion()
+    if dbt_version < "1.8.1":
+        pytest.skip("Dbt version is less than 1.8.1")
+
+    manifest = load_manifest(path=os.path.join(current_dir, "manifest.json"))
+    assert manifest is not None
+    dbt_adapter = DbtAdapter(curr_manifest=manifest)
+    curr_lineage = dbt_adapter.get_lineage()
+    base_lineage = dbt_adapter.get_lineage()
+
+    # Summary with no changes
+    generate_summary_metadata(curr_lineage, base_lineage)
+
+    base_manifest = load_manifest(path=os.path.join(base_manifest_dir, "manifest.json"))
+    curr_manifest = load_manifest(path=os.path.join(pr2_manifest_dir, "manifest.json"))
+    dbt_adapter = DbtAdapter(curr_manifest=curr_manifest, base_manifest=base_manifest)
+    curr_lineage = dbt_adapter.get_lineage()
+    base_lineage = dbt_adapter.get_lineage(base=True)
+    generate_summary_metadata(curr_lineage, base_lineage)
+
+
+def test_build_lineage_graph():
+    dbt_version = DbtVersion()
+    if dbt_version < "1.8.1":
+        pytest.skip("Dbt version is less than 1.8.1")
+
+    base_manifest = load_manifest(path=os.path.join(base_manifest_dir, "manifest.json"))
+    curr_manifest = load_manifest(path=os.path.join(pr2_manifest_dir, "manifest.json"))
+    dbt_adapter = DbtAdapter(curr_manifest=curr_manifest, base_manifest=base_manifest)
+    curr_lineage = dbt_adapter.get_lineage()
+    base_lineage = dbt_adapter.get_lineage(base=True)
+
+    lineage_graph = _build_lineage_graph(curr_lineage, base_lineage)
+    # Modified nodes: 3
+    # - int_customer_orders: added
+    # - int_customer_payments: added
+    # - customers: modified
+    assert len(lineage_graph.modified_set) == 3
+
+
+def test_generate_mermaid_lineage_graph():
+    dbt_version = DbtVersion()
+    if dbt_version < "1.8.1":
+        pytest.skip("Dbt version is less than 1.8.1")
+
+    set_default_context(RecceContext())
+    base_manifest = load_manifest(path=os.path.join(base_manifest_dir, "manifest.json"))
+    curr_manifest = load_manifest(path=os.path.join(pr2_manifest_dir, "manifest.json"))
+    dbt_adapter = DbtAdapter(curr_manifest=curr_manifest, base_manifest=base_manifest)
+    curr_lineage = dbt_adapter.get_lineage()
+    base_lineage = dbt_adapter.get_lineage(base=True)
+    graph = _build_lineage_graph(curr_lineage, base_lineage)
+    mermaid_content, is_empty_graph, is_partial_graph = generate_mermaid_lineage_graph(graph)
+    assert is_empty_graph is False
+    assert is_partial_graph is False

package/recce-source/tests/util/cloud/test_check_events.py

@@ -0,0 +1,255 @@
+"""
+Unit tests for CheckEventsCloud client.
+
+Tests the cloud API client for check event operations including
+list, get, create, update, and delete operations.
+"""
+
+import unittest
+from unittest.mock import MagicMock, patch
+
+from recce.util.cloud.check_events import CheckEventsCloud
+
+
+class TestCheckEventsCloud(unittest.TestCase):
+    """Tests for CheckEventsCloud client."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.token = "test-api-token"
+        self.client = CheckEventsCloud(self.token)
+        self.org_id = "org-123"
+        self.project_id = "proj-456"
+        self.session_id = "sess-789"
+        self.check_id = "check-001"
+        self.event_id = "event-001"
+
+    def test_init_with_api_token(self):
+        """Test initialization with API token."""
+        client = CheckEventsCloud("test-api-token")
+        self.assertEqual(client.token, "test-api-token")
+        self.assertEqual(client.token_type, "api_token")
+
+    def test_init_with_github_token(self):
+        """Test initialization with GitHub token."""
+        client = CheckEventsCloud("ghp_test123")
+        self.assertEqual(client.token, "ghp_test123")
+        self.assertEqual(client.token_type, "github_token")
+
+    def test_init_with_none_token_raises(self):
+        """Test initialization with None token raises ValueError."""
+        with self.assertRaises(ValueError) as ctx:
+            CheckEventsCloud(None)
+        self.assertIn("Token cannot be None", str(ctx.exception))
+
+    def test_build_events_url(self):
+        """Test URL building for events endpoint."""
+        url = self.client._build_events_url(self.org_id, self.project_id, self.session_id, self.check_id)
+        expected = (
+            f"{self.client.base_url_v2}/organizations/{self.org_id}"
+            f"/projects/{self.project_id}/sessions/{self.session_id}"
+            f"/checks/{self.check_id}/events"
+        )
+        self.assertEqual(url, expected)
+
+
+class TestCheckEventsCloudListEvents(unittest.TestCase):
+    """Tests for list_events method."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.client = CheckEventsCloud("test-token")
+        self.org_id = "org-123"
+        self.project_id = "proj-456"
+        self.session_id = "sess-789"
+        self.check_id = "check-001"
+
+    @patch.object(CheckEventsCloud, "_request")
+    @patch.object(CheckEventsCloud, "_raise_for_status")
+    def test_list_events_success(self, mock_raise, mock_request):
+        """Test successful list_events call."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "events": [
+                {"id": "event-1", "event_type": "comment", "content": "Test"},
+                {"id": "event-2", "event_type": "approval_change"},
+            ]
+        }
+        mock_request.return_value = mock_response
+
+        result = self.client.list_events(self.org_id, self.project_id, self.session_id, self.check_id)
+
+        self.assertEqual(len(result), 2)
+        self.assertEqual(result[0]["id"], "event-1")
+        mock_request.assert_called_once()
+        mock_raise.assert_called_once()
+
+    @patch.object(CheckEventsCloud, "_request")
+    @patch.object(CheckEventsCloud, "_raise_for_status")
+    def test_list_events_empty(self, mock_raise, mock_request):
+        """Test list_events with no events."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"events": []}
+        mock_request.return_value = mock_response
+
+        result = self.client.list_events(self.org_id, self.project_id, self.session_id, self.check_id)
+
+        self.assertEqual(result, [])
+
+    @patch.object(CheckEventsCloud, "_request")
+    @patch.object(CheckEventsCloud, "_raise_for_status")
+    def test_list_events_includes_deleted(self, mock_raise, mock_request):
+        """Test that list_events includes deleted events."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {"events": []}
+        mock_request.return_value = mock_response
+
+        self.client.list_events(self.org_id, self.project_id, self.session_id, self.check_id)
+
+        # Verify include_deleted=True is passed
+        call_args = mock_request.call_args
+        self.assertIn("params", call_args.kwargs)
+        self.assertTrue(call_args.kwargs["params"]["include_deleted"])
+
+
+class TestCheckEventsCloudGetEvent(unittest.TestCase):
+    """Tests for get_event method."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.client = CheckEventsCloud("test-token")
+        self.org_id = "org-123"
+        self.project_id = "proj-456"
+        self.session_id = "sess-789"
+        self.check_id = "check-001"
+        self.event_id = "event-001"
+
+    @patch.object(CheckEventsCloud, "_request")
+    @patch.object(CheckEventsCloud, "_raise_for_status")
+    def test_get_event_success(self, mock_raise, mock_request):
+        """Test successful get_event call."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "event": {
+                "id": self.event_id,
+                "event_type": "comment",
+                "content": "Test comment",
+            }
+        }
+        mock_request.return_value = mock_response
+
+        result = self.client.get_event(self.org_id, self.project_id, self.session_id, self.check_id, self.event_id)
+
+        self.assertEqual(result["id"], self.event_id)
+        self.assertEqual(result["content"], "Test comment")
+        mock_request.assert_called_once_with("GET", unittest.mock.ANY)
+
+
+class TestCheckEventsCloudCreateComment(unittest.TestCase):
+    """Tests for create_comment method."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.client = CheckEventsCloud("test-token")
+        self.org_id = "org-123"
+        self.project_id = "proj-456"
+        self.session_id = "sess-789"
+        self.check_id = "check-001"
+
+    @patch.object(CheckEventsCloud, "_request")
+    @patch.object(CheckEventsCloud, "_raise_for_status")
+    def test_create_comment_success(self, mock_raise, mock_request):
+        """Test successful comment creation."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "event": {
+                "id": "new-event-id",
+                "event_type": "comment",
+                "content": "New comment",
+            }
+        }
+        mock_request.return_value = mock_response
+
+        result = self.client.create_comment(self.org_id, self.project_id, self.session_id, self.check_id, "New comment")
+
+        self.assertEqual(result["id"], "new-event-id")
+        self.assertEqual(result["content"], "New comment")
+        mock_request.assert_called_once_with("POST", unittest.mock.ANY, json={"content": "New comment"})
+
+
+class TestCheckEventsCloudUpdateComment(unittest.TestCase):
+    """Tests for update_comment method."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.client = CheckEventsCloud("test-token")
+        self.org_id = "org-123"
+        self.project_id = "proj-456"
+        self.session_id = "sess-789"
+        self.check_id = "check-001"
+        self.event_id = "event-001"
+
+    @patch.object(CheckEventsCloud, "_request")
+    @patch.object(CheckEventsCloud, "_raise_for_status")
+    def test_update_comment_success(self, mock_raise, mock_request):
+        """Test successful comment update."""
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "event": {
+                "id": self.event_id,
+                "event_type": "comment",
+                "content": "Updated content",
+                "is_edited": True,
+            }
+        }
+        mock_request.return_value = mock_response
+
+        result = self.client.update_comment(
+            self.org_id,
+            self.project_id,
+            self.session_id,
+            self.check_id,
+            self.event_id,
+            "Updated content",
+        )
+
+        self.assertEqual(result["content"], "Updated content")
+        self.assertTrue(result["is_edited"])
+        mock_request.assert_called_once_with("PATCH", unittest.mock.ANY, json={"content": "Updated content"})
+
+
+class TestCheckEventsCloudDeleteComment(unittest.TestCase):
+    """Tests for delete_comment method."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.client = CheckEventsCloud("test-token")
+        self.org_id = "org-123"
+        self.project_id = "proj-456"
+        self.session_id = "sess-789"
+        self.check_id = "check-001"
+        self.event_id = "event-001"
+
+    @patch.object(CheckEventsCloud, "_request")
+    @patch.object(CheckEventsCloud, "_raise_for_status")
+    def test_delete_comment_success(self, mock_raise, mock_request):
+        """Test successful comment deletion."""
+        mock_response = MagicMock()
+        mock_request.return_value = mock_response
+
+        # Should not raise, returns None
+        result = self.client.delete_comment(
+            self.org_id,
+            self.project_id,
+            self.session_id,
+            self.check_id,
+            self.event_id,
+        )
+
+        self.assertIsNone(result)
+        mock_request.assert_called_once_with("DELETE", unittest.mock.ANY)
+        mock_raise.assert_called_once()
+
+
+if __name__ == "__main__":
+    unittest.main()