@datarecce/ui 0.1.30 → 0.1.32

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

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

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

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

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