fixed tests

Author: Venkatakrishnan774

tests/outputmanagement/unit/test_basic.py

@@ -27,24 +27,28 @@ def test_client_provider_import(self):
     def test_constants_import(self):
         """Test that constants can be imported."""
         from sap_cloud_sdk.outputmanagement.constants import (
-            DEFAULT_DESTINATION_NAME,
-            OUTPUT_MANAGEMENT_SERVICE_PATH,
-            EMAIL_SERVICE_PATH,
+            Constants,
+            FileFormat,
+            Channel,
+            Status,
         )
-        assert DEFAULT_DESTINATION_NAME is not None
-        assert OUTPUT_MANAGEMENT_SERVICE_PATH is not None
-        assert EMAIL_SERVICE_PATH is not None
+        assert Constants.API_OUTPUT_CONTROL is not None
+        assert FileFormat.PDF is not None
+        assert Channel.EMAIL is not None
+        assert Status.PENDING is not None
 
     def test_exceptions_import(self):
         """Test that exceptions can be imported."""
         from sap_cloud_sdk.outputmanagement.exceptions import (
-            OutputManagementError,
-            OutputManagementValidationError,
-            OutputManagementClientError,
+            OutputManagementException,
+            ValidationException,
+            AuthenticationException,
+            NetworkException,
         )
-        assert OutputManagementError is not None
-        assert OutputManagementValidationError is not None
-        assert OutputManagementClientError is not None
+        assert OutputManagementException is not None
+        assert ValidationException is not None
+        assert AuthenticationException is not None
+        assert NetworkException is not None
 
     def test_models_import(self):
         """Test that models can be imported."""

tests/outputmanagement/unit/test_comprehensive.py

@@ -13,9 +13,9 @@
     PreGeneratedAttachment,
 )
 from sap_cloud_sdk.outputmanagement.exceptions import (
-    OutputManagementError,
-    OutputManagementValidationError,
-    OutputManagementClientError,
+    OutputManagementException,
+    ValidationException,
+    AuthenticationException,
 )
 
 
@@ -176,27 +176,27 @@ def test_exception_with_nested_message(self):
         try:
             raise ValueError("Inner error")
         except ValueError as e:
-            error = OutputManagementError(f"Outer error: {str(e)}")
-            assert "Inner error" in str(error)
-            assert "Outer error" in str(error)
+            error = OutputManagementException(f"Outer error: {str(e)}")
+            assert "Inner error" in error.message
+            assert "Outer error" in error.message
 
     def test_multiple_exception_types(self):
         """Test catching different exception types."""
         errors = [
-            OutputManagementError("General error"),
-            OutputManagementValidationError("Validation error"),
-            OutputManagementClientError("Client error"),
+            OutputManagementException("General error"),
+            ValidationException("Validation error"),
+            AuthenticationException("Authentication error"),
         ]
 
         for error in errors:
-            assert isinstance(error, OutputManagementError)
+            assert isinstance(error, OutputManagementException)
             assert isinstance(error, Exception)
 
     def test_exception_repr(self):
         """Test exception representation."""
-        error = OutputManagementError("Test error")
+        error = OutputManagementException("Test error")
         repr_str = repr(error)
-        assert "OutputManagementError" in repr_str or "Test error" in repr_str
+        assert "OutputManagementException" in repr_str or "Test error" in repr_str
 
 
 class TestModelComparisons:

tests/outputmanagement/unit/test_constants.py

@@ -6,54 +6,63 @@
 import pytest
 
 from sap_cloud_sdk.outputmanagement.constants import (
-    DEFAULT_DESTINATION_NAME,
-    OUTPUT_MANAGEMENT_SERVICE_PATH,
-    EMAIL_SERVICE_PATH,
+    Constants,
+    FileFormat,
+    Channel,
+    Status,
 )
 
 
 class TestConstants:
     """Test output management constants."""
 
-    def test_default_destination_name_exists(self):
-        """Test default destination name constant exists."""
-        assert DEFAULT_DESTINATION_NAME is not None
-        assert isinstance(DEFAULT_DESTINATION_NAME, str)
-        assert len(DEFAULT_DESTINATION_NAME) > 0
-
-    def test_output_management_service_path_exists(self):
-        """Test output management service path constant exists."""
-        assert OUTPUT_MANAGEMENT_SERVICE_PATH is not None
-        assert isinstance(OUTPUT_MANAGEMENT_SERVICE_PATH, str)
-        assert len(OUTPUT_MANAGEMENT_SERVICE_PATH) > 0
-
-    def test_email_service_path_exists(self):
-        """Test email service path constant exists."""
-        assert EMAIL_SERVICE_PATH is not None
-        assert isinstance(EMAIL_SERVICE_PATH, str)
-        assert len(EMAIL_SERVICE_PATH) > 0
-
-    def test_service_paths_start_with_slash(self):
-        """Test that service paths start with a slash."""
-        assert OUTPUT_MANAGEMENT_SERVICE_PATH.startswith("/")
-        assert EMAIL_SERVICE_PATH.startswith("/")
-
-    def test_constants_are_strings(self):
-        """Test that all constants are strings."""
-        assert isinstance(DEFAULT_DESTINATION_NAME, str)
-        assert isinstance(OUTPUT_MANAGEMENT_SERVICE_PATH, str)
-        assert isinstance(EMAIL_SERVICE_PATH, str)
-
-    def test_constants_not_empty(self):
-        """Test that constants are not empty strings."""
-        assert DEFAULT_DESTINATION_NAME != ""
-        assert OUTPUT_MANAGEMENT_SERVICE_PATH != ""
-        assert EMAIL_SERVICE_PATH != ""
-
-    def test_service_paths_format(self):
-        """Test service paths follow expected format."""
-        # Service paths should be valid URL paths
-        assert not OUTPUT_MANAGEMENT_SERVICE_PATH.endswith("/")
-        assert not EMAIL_SERVICE_PATH.endswith("/")
-        assert " " not in OUTPUT_MANAGEMENT_SERVICE_PATH
-        assert " " not in EMAIL_SERVICE_PATH
+    def test_api_output_control_exists(self):
+        """Test API output control constant exists."""
+        assert Constants.API_OUTPUT_CONTROL is not None
+        assert isinstance(Constants.API_OUTPUT_CONTROL, str)
+        assert len(Constants.API_OUTPUT_CONTROL) > 0
+
+    def test_api_output_control_starts_with_slash(self):
+        """Test that API path starts with a slash."""
+        assert Constants.API_OUTPUT_CONTROL.startswith("/")
+
+    def test_header_constants_exist(self):
+        """Test that header constants exist."""
+        assert Constants.CONTENT_TYPE is not None
+        assert Constants.APPLICATION_JSON is not None
+        assert Constants.AUTHORIZATION is not None
+        assert Constants.BEARER is not None
+
+    def test_header_constants_are_strings(self):
+        """Test that header constants are strings."""
+        assert isinstance(Constants.CONTENT_TYPE, str)
+        assert isinstance(Constants.APPLICATION_JSON, str)
+        assert isinstance(Constants.AUTHORIZATION, str)
+        assert isinstance(Constants.BEARER, str)
+
+    def test_content_type_constants(self):
+        """Test content type constants."""
+        assert Constants.CONTENT_TYPE_JSON == "application/json"
+        assert Constants.CONTENT_TYPE_PDF == "application/pdf"
+
+    def test_file_format_enum(self):
+        """Test FileFormat enum."""
+        assert FileFormat.PDF.value == "PDF"
+        assert FileFormat.DOCX.value == "DOCX"
+        assert FileFormat.HTML.value == "HTML"
+        assert FileFormat.XML.value == "XML"
+
+    def test_channel_enum(self):
+        """Test Channel enum."""
+        assert Channel.EMAIL.value == "EMAIL"
+        assert Channel.INTERNAL_EMAIL.value == "INTERNAL_EMAIL"
+        assert Channel.DIRECT_SHARE.value == "DIRECT_SHARE"
+        assert Channel.FORM.value == "FORM"
+
+    def test_status_enum(self):
+        """Test Status enum."""
+        assert Status.PENDING.value == "PENDING"
+        assert Status.IN_PROGRESS.value == "IN_PROGRESS"
+        assert Status.COMPLETED.value == "COMPLETED"
+        assert Status.FAILED.value == "FAILED"
+        assert Status.CANCELLED.value == "CANCELLED"

tests/outputmanagement/unit/test_exceptions.py

@@ -6,76 +6,115 @@
 import pytest
 
 from sap_cloud_sdk.outputmanagement.exceptions import (
-    OutputManagementError,
-    OutputManagementValidationError,
-    OutputManagementClientError,
+    OutputManagementException,
+    ValidationException,
+    AuthenticationException,
+    NetworkException,
+    DestinationNotFoundException,
+    DestinationAccessException,
 )
 
 
 class TestOutputManagementExceptions:
     """Test output management exception classes."""
 
-    def test_output_management_error_basic(self):
-        """Test basic OutputManagementError."""
-        error = OutputManagementError("Test error")
-        assert str(error) == "Test error"
+    def test_output_management_exception_basic(self):
+        """Test basic OutputManagementException."""
+        error = OutputManagementException("Test error")
+        assert error.message == "Test error"
         assert isinstance(error, Exception)
 
-    def test_output_management_error_with_message(self):
-        """Test OutputManagementError with custom message."""
+    def test_output_management_exception_with_message(self):
+        """Test OutputManagementException with custom message."""
         message = "Something went wrong in output management"
-        error = OutputManagementError(message)
-        assert str(error) == message
-
-    def test_output_management_validation_error(self):
-        """Test OutputManagementValidationError."""
-        error = OutputManagementValidationError("Validation failed")
-        assert str(error) == "Validation failed"
-        assert isinstance(error, OutputManagementError)
+        error = OutputManagementException(message)
+        assert error.message == message
+
+    def test_output_management_exception_with_error_code(self):
+        """Test OutputManagementException with error code."""
+        error = OutputManagementException("Test error", error_code="ERR001")
+        assert error.message == "Test error"
+        assert error.error_code == "ERR001"
+        assert "ERR001" in str(error)
+
+    def test_output_management_exception_with_status_code(self):
+        """Test OutputManagementException with status code."""
+        error = OutputManagementException("Test error", status_code=400)
+        assert error.message == "Test error"
+        assert error.status_code == 400
+        assert "400" in str(error)
+
+    def test_validation_exception(self):
+        """Test ValidationException."""
+        error = ValidationException("Validation failed")
+        assert error.message == "Validation failed"
+        assert isinstance(error, OutputManagementException)
+        assert isinstance(error, Exception)
+
+    def test_authentication_exception(self):
+        """Test AuthenticationException."""
+        error = AuthenticationException("Authentication failed")
+        assert error.message == "Authentication failed"
+        assert isinstance(error, OutputManagementException)
         assert isinstance(error, Exception)
 
-    def test_output_management_client_error(self):
-        """Test OutputManagementClientError."""
-        error = OutputManagementClientError("Client error occurred")
-        assert str(error) == "Client error occurred"
-        assert isinstance(error, OutputManagementError)
+    def test_network_exception(self):
+        """Test NetworkException."""
+        error = NetworkException("Network error occurred")
+        assert error.message == "Network error occurred"
+        assert isinstance(error, OutputManagementException)
         assert isinstance(error, Exception)
 
+    def test_destination_not_found_exception(self):
+        """Test DestinationNotFoundException."""
+        error = DestinationNotFoundException("Destination not found")
+        assert error.message == "Destination not found"
+        assert isinstance(error, OutputManagementException)
+
+    def test_destination_access_exception(self):
+        """Test DestinationAccessException."""
+        error = DestinationAccessException("Cannot access destination")
+        assert error.message == "Cannot access destination"
+        assert isinstance(error, OutputManagementException)
+
     def test_exception_inheritance_chain(self):
         """Test exception inheritance chain."""
-        assert issubclass(OutputManagementValidationError, OutputManagementError)
-        assert issubclass(OutputManagementClientError, OutputManagementError)
-        assert issubclass(OutputManagementError, Exception)
+        assert issubclass(ValidationException, OutputManagementException)
+        assert issubclass(AuthenticationException, OutputManagementException)
+        assert issubclass(NetworkException, OutputManagementException)
+        assert issubclass(DestinationNotFoundException, OutputManagementException)
+        assert issubclass(DestinationAccessException, OutputManagementException)
+        assert issubclass(OutputManagementException, Exception)
 
     def test_exceptions_can_be_raised(self):
         """Test that exceptions can be raised and caught."""
-        with pytest.raises(OutputManagementError):
-            raise OutputManagementError("Test")
+        with pytest.raises(OutputManagementException):
+            raise OutputManagementException("Test")
 
-        with pytest.raises(OutputManagementValidationError):
-            raise OutputManagementValidationError("Test")
+        with pytest.raises(ValidationException):
+            raise ValidationException("Test")
 
-        with pytest.raises(OutputManagementClientError):
-            raise OutputManagementClientError("Test")
+        with pytest.raises(AuthenticationException):
+            raise AuthenticationException("Test")
 
     def test_validation_error_caught_as_base_error(self):
-        """Test that ValidationError can be caught as base OutputManagementError."""
-        with pytest.raises(OutputManagementError):
-            raise OutputManagementValidationError("Validation failed")
+        """Test that ValidationException can be caught as base OutputManagementException."""
+        with pytest.raises(OutputManagementException):
+            raise ValidationException("Validation failed")
 
-    def test_client_error_caught_as_base_error(self):
-        """Test that ClientError can be caught as base OutputManagementError."""
-        with pytest.raises(OutputManagementError):
-            raise OutputManagementClientError("Client failed")
+    def test_authentication_error_caught_as_base_error(self):
+        """Test that AuthenticationException can be caught as base OutputManagementException."""
+        with pytest.raises(OutputManagementException):
+            raise AuthenticationException("Auth failed")
 
     def test_exception_with_empty_message(self):
         """Test exceptions with empty message."""
-        error = OutputManagementError("")
-        assert str(error) == ""
-
-    def test_exception_with_multiline_message(self):
-        """Test exceptions with multiline message."""
-        message = "Error occurred:\nLine 1\nLine 2"
-        error = OutputManagementError(message)
-        assert str(error) == message
-        assert "\n" in str(error)
+        error = OutputManagementException("")
+        assert error.message == ""
+
+    def test_exception_with_details(self):
+        """Test exceptions with additional details."""
+        details = {"field": "email", "reason": "invalid format"}
+        error = OutputManagementException("Validation error", details=details)
+        assert error.details == details
+        assert error.details["field"] == "email"