@datarecce/ui 0.1.40 → 0.2.0

package/recce-source/tests/test_server.py

@@ -1,202 +0,0 @@
-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

@@ -1,138 +0,0 @@
-"""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

@@ -1,73 +0,0 @@
-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

@@ -1,255 +0,0 @@
-"""
-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()