@datarecce/ui 0.1.40 → 0.2.0

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

@@ -1,204 +0,0 @@
-"""
-Tests for recce.util.cloud.checks module.
-
-These tests verify the ChecksCloud client functionality for managing
-checks in Recce Cloud sessions.
-"""
-
-import unittest
-from unittest.mock import Mock, patch
-
-import pytest
-
-from recce.util.cloud.checks import ChecksCloud
-from recce.util.recce_cloud import RecceCloudException
-
-
-class TestChecksCloud(unittest.TestCase):
-    """Test suite for ChecksCloud class."""
-
-    def setUp(self):
-        """Test ChecksCloud initialization."""
-        self.token = "test-token"
-        self.client = ChecksCloud(self.token)
-
-    def test_init_no_token(self):
-        """Test ChecksCloud initialization without token raises ValueError."""
-        with pytest.raises(ValueError, match="Token cannot be None"):
-            ChecksCloud(token=None)
-
-    @patch("recce.util.cloud.checks.ChecksCloud._request")
-    def test_list_checks_success(self, mock_request):
-        """Test successful listing of checks."""
-        # Arrange
-        expected_checks = [
-            {"id": "check1", "name": "Schema Check"},
-            {"id": "check2", "name": "Value Check"},
-        ]
-        mock_response = Mock()
-        mock_response.ok = True
-        mock_response.status_code = 200
-        mock_response.json.return_value = {"checks": expected_checks}
-        mock_request.return_value = mock_response
-
-        # Act
-        result = self.client.list_checks("org1", "proj1", "sess1")
-
-        # Assert
-        assert result == expected_checks
-        self.assertEqual(len(result), len(expected_checks))
-
-    @patch("recce.util.cloud.ChecksCloud._request")
-    def test_list_checks_error(self, mock_request):
-        """Test list_checks with API error."""
-        # Arrange
-        mock_response = Mock()
-        mock_response.ok = False
-        mock_response.status_code = 500
-        mock_response.text = "Internal Server Error"
-        mock_request.return_value = mock_response
-
-        # Test method and expect exception
-        with self.assertRaises(RecceCloudException) as context:
-            self.client.list_checks("org1", "proj1", "sess1")
-
-        # Assertions
-        self.assertIn("Failed to list checks from Recce Cloud.", str(context.exception))
-        self.assertEqual(context.exception.status_code, 500)
-
-    @patch("recce.util.cloud.ChecksCloud._request")
-    def test_create_check_success(self, mock_request):
-        """Test successful check creation."""
-        # Arrange
-        check_data = {"name": "New Check", "type": "schema_diff", "params": {"model": "customers"}}
-        created_check = {"check": {**check_data, "id": "check123"}}
-        mock_response = Mock()
-        mock_response.ok = True
-        mock_response.status_code = 201
-        mock_response.json.return_value = created_check
-        mock_request.return_value = mock_response
-
-        # Act
-        result = self.client.create_check("org1", "proj1", "sess1", check_data)
-
-        # Assert
-        assert result == created_check["check"]
-
-    @patch("recce.util.cloud.ChecksCloud._request")
-    def test_get_check_success(self, mock_request):
-        """Test successful retrieval of a specific check."""
-        # Arrange
-        expected_check = {"check": {"id": "check123", "name": "Schema Check", "status": "approved"}}
-        mock_response = Mock()
-        mock_response.ok = True
-        mock_response.status_code = 200
-        mock_response.json.return_value = expected_check
-        mock_request.return_value = mock_response
-
-        # Act
-        result = self.client.get_check("org1", "proj1", "sess1", "check123")
-
-        # Assert
-        assert result == expected_check["check"]
-
-    @patch("recce.util.cloud.ChecksCloud._request")
-    def test_get_check_not_found(self, mock_request):
-        """Test get_check when check doesn't exist."""
-        # Arrange
-        mock_response = Mock()
-        mock_response.ok = False
-        mock_response.status_code = 404
-        mock_response.text = "Check not found"
-        mock_request.return_value = mock_response
-        not_real_check_id = "not_real_404"
-
-        # Act & Assert
-        with self.assertRaises(RecceCloudException) as context:
-            self.client.get_check("org1", "proj1", "sess1", not_real_check_id)
-
-        self.assertIn(f"Failed to get check {not_real_check_id} from Recce Cloud.", str(context.exception))
-        self.assertEqual(context.exception.status_code, 404)
-
-    @patch("recce.util.cloud.ChecksCloud._request")
-    def test_update_check_success(self, mock_request):
-        """Test successful check update."""
-        # Arrange
-        update_data = {"status": "approved", "notes": "Looks good"}
-        updated_check = {"check": {"id": "check123", "name": "Schema Check", **update_data}}
-        mock_response = Mock()
-        mock_response.ok = True
-        mock_response.status_code = 200
-        mock_response.json.return_value = updated_check
-        mock_request.return_value = mock_response
-
-        # Act
-        result = self.client.update_check("org1", "proj1", "sess1", "check123", update_data)
-
-        # Assert
-        assert result == updated_check["check"]
-
-    @patch("recce.util.cloud.ChecksCloud._request")
-    def test_delete_check_success_204(self, mock_request):
-        """Test successful check deletion with 204 No Content."""
-        # Arrange
-        mock_response = Mock()
-        mock_response.ok = True
-        mock_response.status_code = 204
-        mock_request.return_value = mock_response
-
-        # Act
-        self.client.delete_check("org1", "proj1", "sess1", "check123")
-
-        # Assert
-        self.assertEqual(self.client._request.return_value.status_code, 204)
-
-    @patch("recce.util.cloud.ChecksCloud._request")
-    def test_delete_check_success_200(self, mock_request):
-        """Test successful check deletion with 200 OK."""
-        # Arrange
-        mock_response = Mock()
-        mock_response.ok = True
-        mock_response.status_code = 200
-        mock_request.return_value = mock_response
-
-        # Act
-        self.client.delete_check("org1", "proj1", "sess1", "check123")
-
-        # Assert - should not raise an exception
-        self.assertEqual(self.client._request.call_count, 1)
-
-    @patch("recce.util.cloud.ChecksCloud._request")
-    def test_delete_check_error(self, mock_request):
-        """Test delete_check with API error."""
-        # Arrange
-        mock_response = Mock()
-        mock_response.ok = False
-        mock_response.status_code = 403
-        mock_response.text = "Forbidden"
-        mock_request.return_value = mock_response
-        check_id = "check123"
-
-        # Act & Assert
-        with self.assertRaises(RecceCloudException) as context:
-            self.client.delete_check("org1", "proj1", "sess1", check_id)
-
-        # Assertions
-        self.assertIn(f"Failed to delete check {check_id} from Recce Cloud.", str(context.exception))
-        self.assertEqual(context.exception.status_code, 403)
-
-
-class TestIntegrationWithRecceCloud:
-    """Test integration between ChecksCloud and RecceCloud."""
-
-    def test_recce_cloud_checks_property(self):
-        """Test that RecceCloud can access checks client."""
-        from recce.util.recce_cloud import RecceCloud
-
-        cloud = RecceCloud(token="test-token")
-
-        # Access checks property
-        checks_client = cloud.checks
-
-        # Verify it's a ChecksCloud instance
-        assert isinstance(checks_client, ChecksCloud)
-        assert checks_client.token == cloud.token

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

@@ -1,119 +0,0 @@
-import unittest
-from unittest.mock import patch
-
-from recce.exceptions import RecceConfigException
-
-
-class PrepareApiTokenTest(unittest.TestCase):
-
-    @patch("recce.util.api_token.console.print")
-    def test_show_invalid_api_token_message(self, mock_print):
-        from recce.util.api_token import (
-            show_invalid_api_token_message,
-        )
-
-        show_invalid_api_token_message()
-        mock_print.assert_any_call("[[red]Error[/red]] Invalid Recce Cloud API token.")
-
-    @patch("recce.util.api_token.get_recce_api_token", return_value=None)
-    def test_no_token_provided_no_interaction(self, mock_get_token):
-        from recce.util.api_token import prepare_api_token
-
-        token = prepare_api_token(interaction=False)
-        self.assertIsNone(token)
-
-    @patch("recce.util.api_token.update_recce_api_token")
-    @patch("recce.util.api_token.RecceCloud")
-    @patch("recce.util.api_token.get_recce_api_token", return_value="old-token")
-    def test_new_token_invalid(self, mock_get_token, mock_recce_cloud, mock_update_token):
-        from recce.util.api_token import prepare_api_token
-
-        mock_recce_cloud.return_value.verify_token.return_value = False
-        with self.assertRaises(RecceConfigException):
-            prepare_api_token(api_token="new-invalid-token")
-
-    @patch("recce.util.api_token.update_recce_api_token")
-    @patch("recce.util.api_token.RecceCloud")
-    @patch("recce.util.api_token.get_recce_api_token", return_value="old-token")
-    def test_new_token_valid(self, mock_get_token, mock_recce_cloud, mock_update_token):
-        from recce.util.api_token import prepare_api_token
-
-        mock_recce_cloud.return_value.verify_token.return_value = True
-        token = prepare_api_token(api_token="new-valid-token")
-        self.assertEqual(token, "new-valid-token")
-        mock_update_token.assert_called_once()
-
-    @patch("recce.util.api_token.console.print")
-    @patch("recce.util.api_token.RecceCloud")
-    @patch("recce.util.api_token.get_recce_api_token", return_value="valid-token")
-    def test_existing_token_valid(self, mock_get_token, mock_recce_cloud, mock_print):
-        from recce.util.api_token import prepare_api_token
-
-        mock_recce_cloud.return_value.verify_token.return_value = True
-        token = prepare_api_token()
-        self.assertEqual(token, "valid-token")
-
-    @patch("recce.util.api_token.console.print")
-    @patch("recce.util.api_token.RecceCloud")
-    @patch("recce.util.api_token.get_recce_api_token", return_value="invalid-token")
-    def test_existing_token_invalid(self, mock_get_token, mock_recce_cloud, mock_print):
-        from recce.util.api_token import prepare_api_token
-
-        mock_recce_cloud.return_value.verify_token.return_value = False
-        token = prepare_api_token()
-        self.assertIsNone(token)
-        mock_print.assert_any_call("[[yellow]Warning[/yellow]] Invalid Recce Cloud API token. Skipping the share link.")
-
-    @patch("recce.util.api_token.update_recce_api_token")
-    @patch("recce.util.api_token.click.prompt", return_value="token")
-    @patch("recce.util.api_token.console.print")
-    @patch("recce.util.api_token.RecceCloud")
-    @patch("recce.util.api_token.get_recce_api_token", return_value=None)
-    def test_interactive_token_flow(self, mock_get_token, mock_recce_cloud, mock_print, mock_prompt, mock_update_token):
-        from recce.util.api_token import prepare_api_token
-
-        mock_recce_cloud.return_value.verify_token.return_value = True
-        token = prepare_api_token(interaction=True)
-        self.assertEqual(token, "token")
-        mock_prompt.assert_called_once()
-        mock_update_token.assert_called_once()
-
-    @patch("recce.util.api_token.update_recce_api_token")
-    @patch("recce.util.api_token.click.prompt", return_value="token")
-    @patch("recce.util.api_token.console.print")
-    @patch("recce.util.api_token.RecceCloud")
-    @patch("recce.util.api_token.get_recce_api_token", return_value=None)
-    def test_interactive_token_invalid_flow(
-        self, mock_get_token, mock_recce_cloud, mock_print, mock_prompt, mock_update_token
-    ):
-        from recce.util.api_token import prepare_api_token
-
-        mock_recce_cloud.return_value.verify_token.return_value = False
-        mock_prompt.return_value = "invalid-token"
-        with self.assertRaises(RecceConfigException):
-            prepare_api_token(interaction=True)
-            mock_prompt.assert_called_once()
-
-    @patch("recce.util.recce_cloud.is_anonymous_tracking", return_value=True)
-    @patch("recce.util.recce_cloud.get_user_id", return_value="unittest-user")
-    @patch("recce.util.recce_cloud.get_version", return_value="unittest-version")
-    def test_verify_token_append_tracking_data(self, mock_is_anonymous_tracking, mock_get_user_id, mock_get_version):
-        from recce.util.api_token import RecceCloud
-
-        recce_cloud = RecceCloud("valid-token")
-        with patch.object(recce_cloud, "_request") as mock_request:
-            mock_request.return_value.status_code = 200
-            mock_request.return_value.json.return_value = {"status": "success"}
-
-            result = recce_cloud.verify_token()
-            called_kwargs = mock_request.call_args.kwargs
-            self.assertDictEqual(
-                called_kwargs,
-                {
-                    "headers": {
-                        "X-Recce-Oss-User-Id": "unittest-user",
-                        "X-Recce-Oss-Version": "unittest-version",
-                    }
-                },
-            )
-            self.assertTrue(result)