@datarecce/ui 0.1.41 → 0.2.1-nightly.20260402

package/recce-source/tests/util/test_lineage.py

@@ -1,122 +0,0 @@
-from recce.util.lineage import find_downstream, find_upstream
-
-
-class TestFindUpstreamDownstream:
-    """Test cases that use both functions together with complementary data"""
-
-    def setup_method(self):
-        """Setup complementary parent and child maps for testing"""
-        # Tree structure:
-        #     d
-        #    / \
-        #   b   c
-        #    \ /
-        #     a
-        self.parent_map = {"a": ["b", "c"], "b": ["d"], "c": ["d"]}
-
-        self.child_map = {"d": ["b", "c"], "b": ["a"], "c": ["a"]}
-
-    def test_empty_input(self):
-        """Test with empty node_ids"""
-        result = find_upstream([], {})
-        assert result == set()
-
-        result = find_downstream([], {})
-        assert result == set()
-
-        result = find_upstream([], {"a": ["b"]})
-        assert result == set()
-
-        result = find_downstream([], {"a": ["b"]})
-        assert result == set()
-
-    def test_complementary_maps_single_node(self):
-        """Test that parent and child maps give complementary results"""
-        # From 'a', upstream should be b, c, d
-        upstream = find_upstream(["a"], self.parent_map)
-        assert upstream == {"b", "c", "d"}
-
-        # From 'd', downstream should be b, c, a
-        downstream = find_downstream(["d"], self.child_map)
-        assert downstream == {"b", "c", "a"}
-
-    def test_middle_node_both_directions(self):
-        """Test finding both upstream and downstream from middle node"""
-        # From 'b': upstream is 'd', downstream is 'a'
-        upstream = find_upstream(["b"], self.parent_map)
-        downstream = find_downstream(["b"], self.child_map)
-
-        assert upstream == {"d"}
-        assert downstream == {"a"}
-
-        # Combined should give us all nodes except 'b' itself
-        all_related = upstream | downstream
-        assert all_related == {"a", "d"}
-
-    def test_root_and_leaf_nodes(self):
-        """Test root node (no parents) and leaf node (no children)"""
-        # 'd' is root (no parents), 'a' is leaf (no children)
-        root_upstream = find_upstream(["d"], self.parent_map)
-        leaf_downstream = find_downstream(["a"], self.child_map)
-
-        assert root_upstream == set()  # No parents
-        assert leaf_downstream == set()  # No children
-
-    def test_complex_graph_both_directions(self):
-        """Test more complex graph structure"""
-        parent_map = {"a": ["b"], "b": ["d", "e"], "c": ["e", "f"], "d": ["g"], "e": ["g"], "f": ["h"]}
-
-        child_map = {"g": ["d", "e"], "d": ["b"], "e": ["b", "c"], "b": ["a"], "f": ["c"], "h": ["f"]}
-
-        # From 'a'
-        upstream_from_a = find_upstream(["a"], parent_map)
-        assert upstream_from_a == {"b", "d", "e", "g"}
-
-        # From 'g'
-        downstream_from_g = find_downstream(["g"], child_map)
-        assert downstream_from_g == {"d", "e", "b", "c", "a"}
-
-    def test_multiple_start_nodes_both_functions(self):
-        """Test both functions with multiple starting nodes"""
-        parent_map = {"a1": ["b1"], "a2": ["b2"], "b1": ["c"], "b2": ["c"], "c": ["d"]}
-
-        child_map = {"d": ["c"], "c": ["b1", "b2"], "b1": ["a1"], "b2": ["a2"]}
-
-        # Starting from leaf nodes
-        upstream_multi = find_upstream(["a1", "a2"], parent_map)
-        assert upstream_multi == {"b1", "b2", "c", "d"}
-
-        # Starting from root node
-        downstream_root = find_downstream(["d"], child_map)
-        assert downstream_root == {"c", "b1", "b2", "a1", "a2"}
-
-    def test_disconnected_components(self):
-        """Test graphs with disconnected components"""
-        parent_map = {
-            # Component 1: a1 <- b1 <- c1
-            "a1": ["b1"],
-            "b1": ["c1"],
-            # Component 2: a2 <- b2 <- c2
-            "a2": ["b2"],
-            "b2": ["c2"],
-        }
-
-        child_map = {
-            # Component 1: c1 -> b1 -> a1
-            "c1": ["b1"],
-            "b1": ["a1"],
-            # Component 2: c2 -> b2 -> a2
-            "c2": ["b2"],
-            "b2": ["a2"],
-        }
-
-        # Should only find nodes in same component
-        upstream1 = find_upstream(["a1"], parent_map)
-        downstream1 = find_downstream(["c1"], child_map)
-
-        assert upstream1 == {"b1", "c1"}
-        assert downstream1 == {"b1", "a1"}
-
-        # Cross-component queries should find nothing
-        upstream_cross = find_upstream(["a1"], {"a2": ["b2"]})
-        assert upstream_cross == set()

package/recce-source/tests/util/test_onboarding_state.py

@@ -1,84 +0,0 @@
-import unittest
-from unittest.mock import patch
-
-from recce.util.onboarding_state import OnboardingState
-
-
-class OnboardingStateTest(unittest.TestCase):
-
-    @patch("recce.util.onboarding_state.set_recce_cloud_onboarding_state")
-    @patch(
-        "recce.util.onboarding_state.get_recce_cloud_onboarding_state",
-        return_value=OnboardingState.SIGNUP_SUCCESSFUL.value,
-    )
-    def test_update_onboarding_state_sanity_check(self, mock_get_onboard, mock_set_onboard):
-        from recce.util.onboarding_state import update_onboarding_state
-
-        return_value = update_onboarding_state("some_token", True)
-        self.assertEqual(True, isinstance(return_value, OnboardingState))
-
-    @patch("recce.util.onboarding_state.set_recce_cloud_onboarding_state")
-    @patch(
-        "recce.util.onboarding_state.get_recce_cloud_onboarding_state",
-        return_value=OnboardingState.SIGNUP_SUCCESSFUL.value,
-    )
-    def test_update_onboarding_state_new_single_env_user(self, mock_get_onboard, mock_set_onboard):
-        from recce.util.onboarding_state import update_onboarding_state
-
-        return_value = update_onboarding_state("some_token", True)
-        self.assertEqual(OnboardingState.LAUNCHED_WITH_TOKEN, return_value)
-
-    @patch("recce.util.onboarding_state.set_recce_cloud_onboarding_state")
-    @patch(
-        "recce.util.onboarding_state.get_recce_cloud_onboarding_state",
-        return_value=OnboardingState.SIGNUP_SUCCESSFUL.value,
-    )
-    def test_update_onboarding_state_new_dual_env_user(self, mock_get_onboard, mock_set_onboard):
-        from recce.util.onboarding_state import update_onboarding_state
-
-        return_value = update_onboarding_state("some_token", False)
-        self.assertEqual(OnboardingState.CONFIGURE_TWO_ENV, return_value)
-
-    @patch("recce.util.onboarding_state.set_recce_cloud_onboarding_state")
-    @patch(
-        "recce.util.onboarding_state.get_recce_cloud_onboarding_state",
-        return_value=OnboardingState.LAUNCHED_WITH_TOKEN.value,
-    )
-    def test_update_onboarding_state_launched_single_env_user(self, mock_get_onboard, mock_set_onboard):
-        from recce.util.onboarding_state import update_onboarding_state
-
-        return_value = update_onboarding_state("some_token", True)
-        self.assertEqual(OnboardingState.LAUNCHED_WITH_TOKEN, return_value)
-
-    @patch("recce.util.onboarding_state.set_recce_cloud_onboarding_state")
-    @patch(
-        "recce.util.onboarding_state.get_recce_cloud_onboarding_state",
-        return_value=OnboardingState.LAUNCHED_WITH_TOKEN.value,
-    )
-    def test_update_onboarding_state_launched_dual_env_user(self, mock_get_onboard, mock_set_onboard):
-        from recce.util.onboarding_state import update_onboarding_state
-
-        return_value = update_onboarding_state("some_token", False)
-        self.assertEqual(OnboardingState.CONFIGURE_TWO_ENV, return_value)
-
-    @patch("recce.util.onboarding_state.set_recce_cloud_onboarding_state")
-    @patch(
-        "recce.util.onboarding_state.get_recce_cloud_onboarding_state",
-        return_value=OnboardingState.CONFIGURE_TWO_ENV.value,
-    )
-    def test_update_onboarding_state_launched_with_two_envs_single_env_user(self, mock_get_onboard, mock_set_onboard):
-        from recce.util.onboarding_state import update_onboarding_state
-
-        return_value = update_onboarding_state("some_token", True)
-        self.assertEqual(OnboardingState.CONFIGURE_TWO_ENV, return_value)
-
-    @patch("recce.util.onboarding_state.set_recce_cloud_onboarding_state")
-    @patch(
-        "recce.util.onboarding_state.get_recce_cloud_onboarding_state",
-        return_value=OnboardingState.CONFIGURE_TWO_ENV.value,
-    )
-    def test_update_onboarding_state_launched_with_two_envs_dual_env_user(self, mock_get_onboard, mock_set_onboard):
-        from recce.util.onboarding_state import update_onboarding_state
-
-        return_value = update_onboarding_state("some_token", False)
-        self.assertEqual(OnboardingState.CONFIGURE_TWO_ENV, return_value)

package/recce-source/tests/util/test_recce_cloud.py

@@ -1,231 +0,0 @@
-import unittest
-from unittest.mock import Mock, patch
-
-from recce.util.recce_cloud import RecceCloud, RecceCloudException
-
-
-class TestRecceCloudListingMethods(unittest.TestCase):
-    """Test cases for the new cloud listing methods in RecceCloud class."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.token = "test-api-token"
-        self.cloud = RecceCloud(self.token)
-
-    @patch("recce.util.recce_cloud.RecceCloud._request")
-    def test_list_organizations_success(self, mock_request):
-        """Test successful list_organizations call."""
-        # Mock successful response
-        mock_response = Mock()
-        mock_response.status_code = 200
-        mock_response.json.return_value = {
-            "organizations": [
-                {"id": 1, "name": "org1", "display_name": "Organization 1"},
-                {"id": 2, "name": "org2", "display_name": "Organization 2"},
-            ]
-        }
-        mock_request.return_value = mock_response
-
-        # Test method
-        result = self.cloud.list_organizations()
-
-        # Assertions
-        self.assertEqual(len(result), 2)
-        self.assertEqual(result[0]["name"], "org1")
-        self.assertEqual(result[1]["display_name"], "Organization 2")
-
-        # Verify correct API call
-        mock_request.assert_called_once_with("GET", f"{self.cloud.base_url_v2}/organizations")
-
-    @patch("recce.util.recce_cloud.RecceCloud._request")
-    def test_list_organizations_empty_response(self, mock_request):
-        """Test list_organizations with empty response."""
-        # Mock empty response
-        mock_response = Mock()
-        mock_response.status_code = 200
-        mock_response.json.return_value = {"organizations": []}
-        mock_request.return_value = mock_response
-
-        # Test method
-        result = self.cloud.list_organizations()
-
-        # Assertions
-        self.assertEqual(len(result), 0)
-        self.assertEqual(result, [])
-
-    @patch("recce.util.recce_cloud.RecceCloud._request")
-    def test_list_organizations_missing_key(self, mock_request):
-        """Test list_organizations with missing organizations key."""
-        # Mock response without organizations key
-        mock_response = Mock()
-        mock_response.status_code = 200
-        mock_response.json.return_value = {}
-        mock_request.return_value = mock_response
-
-        # Test method
-        result = self.cloud.list_organizations()
-
-        # Assertions
-        self.assertEqual(result, [])
-
-    @patch("recce.util.recce_cloud.RecceCloud._request")
-    def test_list_organizations_error(self, mock_request):
-        """Test list_organizations with API error."""
-        # Mock error response
-        mock_response = Mock()
-        mock_response.status_code = 403
-        mock_response.text = "Forbidden"
-        mock_request.return_value = mock_response
-
-        # Test method and expect exception
-        with self.assertRaises(RecceCloudException) as context:
-            self.cloud.list_organizations()
-
-        # Assertions
-        self.assertIn("Failed to list organizations from Recce Cloud", str(context.exception))
-        self.assertEqual(context.exception.status_code, 403)
-
-    @patch("recce.util.recce_cloud.RecceCloud._request")
-    def test_list_projects_success(self, mock_request):
-        """Test successful list_projects call."""
-        # Mock successful response
-        mock_response = Mock()
-        mock_response.status_code = 200
-        mock_response.json.return_value = {
-            "projects": [
-                {"id": 1, "name": "project1", "display_name": "Project 1"},
-                {"id": 2, "name": "project2", "display_name": "Project 2"},
-            ]
-        }
-        mock_request.return_value = mock_response
-
-        org_id = "8"
-
-        # Test method
-        result = self.cloud.list_projects(org_id)
-
-        # Assertions
-        self.assertEqual(len(result), 2)
-        self.assertEqual(result[0]["name"], "project1")
-        self.assertEqual(result[1]["display_name"], "Project 2")
-
-        # Verify correct API call
-        expected_url = f"{self.cloud.base_url_v2}/organizations/{org_id}/projects"
-        mock_request.assert_called_once_with("GET", expected_url)
-
-    @patch("recce.util.recce_cloud.RecceCloud._request")
-    def test_list_projects_empty_response(self, mock_request):
-        """Test list_projects with empty response."""
-        # Mock empty response
-        mock_response = Mock()
-        mock_response.status_code = 200
-        mock_response.json.return_value = {"projects": []}
-        mock_request.return_value = mock_response
-
-        # Test method
-        result = self.cloud.list_projects("8")
-
-        # Assertions
-        self.assertEqual(len(result), 0)
-        self.assertEqual(result, [])
-
-    @patch("recce.util.recce_cloud.RecceCloud._request")
-    def test_list_projects_error(self, mock_request):
-        """Test list_projects with API error."""
-        # Mock error response
-        mock_response = Mock()
-        mock_response.status_code = 404
-        mock_response.text = "Organization not found"
-        mock_request.return_value = mock_response
-
-        # Test method and expect exception
-        with self.assertRaises(RecceCloudException) as context:
-            self.cloud.list_projects("999")
-
-        # Assertions
-        self.assertIn("Failed to list projects from Recce Cloud", str(context.exception))
-        self.assertEqual(context.exception.status_code, 404)
-
-    @patch("recce.util.recce_cloud.RecceCloud._request")
-    def test_list_sessions_success(self, mock_request):
-        """Test successful list_sessions call."""
-        # Mock successful response
-        mock_response = Mock()
-        mock_response.status_code = 200
-        mock_response.json.return_value = {
-            "sessions": [
-                {"id": "session1", "name": "PR-123", "is_base": False},
-                {"id": "session2", "name": "Base Session", "is_base": True},
-                {"id": "session3", "name": "Dev Session", "is_base": False},
-            ]
-        }
-        mock_request.return_value = mock_response
-
-        org_id = "8"
-        project_id = "7"
-
-        # Test method
-        result = self.cloud.list_sessions(org_id, project_id)
-
-        # Assertions
-        self.assertEqual(len(result), 3)
-        self.assertEqual(result[0]["name"], "PR-123")
-        self.assertFalse(result[0]["is_base"])
-        self.assertEqual(result[1]["name"], "Base Session")
-        self.assertTrue(result[1]["is_base"])
-
-        # Verify correct API call
-        expected_url = f"{self.cloud.base_url_v2}/organizations/{org_id}/projects/{project_id}/sessions"
-        mock_request.assert_called_once_with("GET", expected_url)
-
-    @patch("recce.util.recce_cloud.RecceCloud._request")
-    def test_list_sessions_empty_response(self, mock_request):
-        """Test list_sessions with empty response."""
-        # Mock empty response
-        mock_response = Mock()
-        mock_response.status_code = 200
-        mock_response.json.return_value = {"sessions": []}
-        mock_request.return_value = mock_response
-
-        # Test method
-        result = self.cloud.list_sessions("8", "7")
-
-        # Assertions
-        self.assertEqual(len(result), 0)
-        self.assertEqual(result, [])
-
-    @patch("recce.util.recce_cloud.RecceCloud._request")
-    def test_list_sessions_error(self, mock_request):
-        """Test list_sessions with API error."""
-        # Mock error response
-        mock_response = Mock()
-        mock_response.status_code = 403
-        mock_response.text = "Access denied to project"
-        mock_request.return_value = mock_response
-
-        # Test method and expect exception
-        with self.assertRaises(RecceCloudException) as context:
-            self.cloud.list_sessions("8", "999")
-
-        # Assertions
-        self.assertIn("Failed to list sessions from Recce Cloud", str(context.exception))
-        self.assertEqual(context.exception.status_code, 403)
-
-    @patch("recce.util.recce_cloud.RecceCloud._request")
-    def test_list_sessions_missing_key(self, mock_request):
-        """Test list_sessions with missing sessions key."""
-        # Mock response without sessions key
-        mock_response = Mock()
-        mock_response.status_code = 200
-        mock_response.json.return_value = {}
-        mock_request.return_value = mock_response
-
-        # Test method
-        result = self.cloud.list_sessions("8", "7")
-
-        # Assertions
-        self.assertEqual(result, [])
-
-
-if __name__ == "__main__":
-    unittest.main()

package/recce-source/tox.ini

@@ -1,40 +0,0 @@
-[tox]
-envlist = dbt1.6, dbt1.7, dbt1.8, dbt1.9, dbtlatest
-requires = tox-uv
-
-[testenv:dbt{1.6,1.7,1.8,1.9,latest}]
-basepython = python3.10
-deps =
-    pytest
-    pytest-asyncio
-    pytest-cov
-    pandas
-    duckdb
-    httpx
-
-    dbt1.6: dbt-duckdb==1.6.*
-    dbt1.7: dbt-duckdb==1.7.*
-    dbt1.8: dbt-duckdb==1.8.*
-    dbt1.9: dbt-duckdb==1.9.*
-    dbtlatest: dbt-duckdb
-    # only test mcp for the latest dbt version
-    dbtlatest: mcp>=1.0.0
-commands =
-    pytest --cov --cov-append --cov-report=xml {posargs:./tests}
-
-[testenv:{3.9,3.10,3.11,3.12,3.13}]
-deps =
-    pytest
-    pytest-asyncio
-    pytest-cov
-    pandas
-    duckdb
-    httpx
-    dbt-duckdb
-commands =
-    pytest {posargs:./tests}
-
-[testenv:clean]
-deps = coverage
-skip_install = true
-commands = coverage erase