@datarecce/ui 0.1.30 → 0.1.32

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

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

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