add few sdk tests

Author: Deepthi-Chand

tests/test_aimodels.py

@@ -117,6 +117,112 @@ def test_graphql_error_handling(self, mock_post: MagicMock) -> None:
         with self.assertRaises(DataSpaceAPIError):
             self.client.get_by_id_graphql("123")
 
+    @patch.object(AIModelClient, "post")
+    def test_call_model(self, mock_post: MagicMock) -> None:
+        """Test calling an AI model."""
+        mock_post.return_value = {
+            "success": True,
+            "output": "Paris is the capital of France.",
+            "latency_ms": 150,
+            "provider": "OpenAI",
+        }
+
+        result = self.client.call_model(
+            model_id="123",
+            input_text="What is the capital of France?",
+            parameters={"temperature": 0.7, "max_tokens": 100},
+        )
+
+        self.assertTrue(result["success"])
+        self.assertEqual(result["output"], "Paris is the capital of France.")
+        self.assertEqual(result["latency_ms"], 150)
+        mock_post.assert_called_once()
+
+    @patch.object(AIModelClient, "post")
+    def test_call_model_async(self, mock_post: MagicMock) -> None:
+        """Test calling an AI model asynchronously."""
+        mock_post.return_value = {
+            "task_id": "task-456",
+            "status": "PENDING",
+            "created_at": "2024-01-01T00:00:00Z",
+        }
+
+        result = self.client.call_model_async(
+            model_id="123",
+            input_text="Generate a long document",
+            parameters={"max_tokens": 2000},
+        )
+
+        self.assertEqual(result["task_id"], "task-456")
+        self.assertEqual(result["status"], "PENDING")
+        mock_post.assert_called_once()
+
+    @patch.object(AIModelClient, "post")
+    def test_call_model_error(self, mock_post: MagicMock) -> None:
+        """Test AI model call with error."""
+        mock_post.return_value = {
+            "success": False,
+            "error": "Model not available",
+        }
+
+        result = self.client.call_model(
+            model_id="123",
+            input_text="Test input",
+        )
+
+        self.assertFalse(result["success"])
+        self.assertEqual(result["error"], "Model not available")
+
+    @patch.object(AIModelClient, "post")
+    def test_create_model(self, mock_post: MagicMock) -> None:
+        """Test creating an AI model."""
+        mock_post.return_value = {
+            "id": "new-model-123",
+            "displayName": "New Model",
+            "modelType": "LLM",
+        }
+
+        result = self.client.create(
+            {
+                "displayName": "New Model",
+                "modelType": "LLM",
+                "provider": "OpenAI",
+            }
+        )
+
+        self.assertEqual(result["id"], "new-model-123")
+        self.assertEqual(result["displayName"], "New Model")
+        mock_post.assert_called_once()
+
+    @patch.object(AIModelClient, "put")
+    def test_update_model(self, mock_put: MagicMock) -> None:
+        """Test updating an AI model."""
+        mock_put.return_value = {
+            "id": "123",
+            "displayName": "Updated Model",
+            "modelType": "LLM",
+        }
+
+        result = self.client.update(
+            "123",
+            {
+                "displayName": "Updated Model",
+            },
+        )
+
+        self.assertEqual(result["displayName"], "Updated Model")
+        mock_put.assert_called_once()
+
+    @patch.object(AIModelClient, "delete")
+    def test_delete_model(self, mock_delete: MagicMock) -> None:
+        """Test deleting an AI model."""
+        mock_delete.return_value = {"message": "Model deleted successfully"}
+
+        result = self.client.delete_model("123")
+
+        self.assertEqual(result["message"], "Model deleted successfully")
+        mock_delete.assert_called_once()
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_auth.py

@@ -141,6 +141,51 @@ def test_is_authenticated(self) -> None:
         self.auth_client.access_token = "test_token"
         self.assertTrue(self.auth_client.is_authenticated())
 
+    @patch("dataspace_sdk.auth.requests.post")
+    def test_login_as_service_account(self, mock_post: MagicMock) -> None:
+        """Test successful service account login."""
+        # Create auth client with client secret
+        auth_client = AuthClient(
+            self.base_url,
+            keycloak_url=self.keycloak_url,
+            keycloak_realm=self.keycloak_realm,
+            keycloak_client_id=self.keycloak_client_id,
+            keycloak_client_secret="test_secret",
+        )
+
+        # Mock Keycloak token response
+        keycloak_response = MagicMock()
+        keycloak_response.status_code = 200
+        keycloak_response.json.return_value = {
+            "access_token": "service_access_token",
+            "refresh_token": "service_refresh_token",
+            "expires_in": 300,
+        }
+
+        # Mock DataSpace backend login response
+        backend_response = MagicMock()
+        backend_response.status_code = 200
+        backend_response.json.return_value = {
+            "access": "test_access_token",
+            "refresh": "test_refresh_token",
+            "user": {"id": "service-123", "username": "service-account"},
+        }
+
+        mock_post.side_effect = [keycloak_response, backend_response]
+
+        result = auth_client.login_as_service_account()
+
+        self.assertEqual(auth_client.access_token, "test_access_token")
+        self.assertEqual(auth_client.refresh_token, "test_refresh_token")
+        self.assertIsNotNone(auth_client.user_info)
+        self.assertEqual(result["user"]["username"], "service-account")
+        self.assertEqual(mock_post.call_count, 2)
+
+    def test_login_as_service_account_no_secret(self) -> None:
+        """Test service account login without client secret."""
+        with self.assertRaises(DataSpaceAuthError):
+            self.auth_client.login_as_service_account()
+
 
 if __name__ == "__main__":
     unittest.main()

tests/test_datasets.py

@@ -89,6 +89,51 @@ def test_search_with_filters(self, mock_get: MagicMock) -> None:
         self.assertEqual(result["total"], 5)
         mock_get.assert_called_once()
 
+    @patch.object(DatasetClient, "get")
+    def test_get_resources(self, mock_get: MagicMock) -> None:
+        """Test get dataset resources."""
+        mock_get.return_value = [
+            {
+                "id": "res-1",
+                "title": "Resource 1",
+                "format": "CSV",
+                "url": "https://example.com/data.csv",
+            }
+        ]
+
+        result = self.client.get_resources("dataset-123")
+
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0]["title"], "Resource 1")
+        mock_get.assert_called_once()
+
+    @patch.object(DatasetClient, "post")
+    def test_list_by_organization(self, mock_post: MagicMock) -> None:
+        """Test list datasets by organization."""
+        mock_post.return_value = {
+            "data": {
+                "datasets": [
+                    {"id": "1", "title": "Org Dataset 1"},
+                    {"id": "2", "title": "Org Dataset 2"},
+                ]
+            }
+        }
+
+        result = self.client.list_by_organization("org-123", limit=10)
+
+        self.assertIsInstance(result, (list, dict))
+        mock_post.assert_called_once()
+
+    @patch.object(DatasetClient, "get")
+    def test_search_with_sorting(self, mock_get: MagicMock) -> None:
+        """Test dataset search with sorting."""
+        mock_get.return_value = {"total": 3, "results": []}
+
+        result = self.client.search(query="test", sort="recent", page=1, page_size=10)
+
+        self.assertEqual(result["total"], 3)
+        mock_get.assert_called_once()
+
 
 if __name__ == "__main__":
     unittest.main()