Increase client test coverage

Author: hoijnet

terminusdb_client/tests/test_errors.py

@@ -0,0 +1,234 @@
+"""Tests for errors.py module."""
+import json
+from unittest.mock import Mock
+from terminusdb_client.errors import (
+    Error,
+    InterfaceError,
+    DatabaseError,
+    OperationalError,
+    AccessDeniedError,
+    APIError,
+    InvalidURIError
+)
+
+
+def test_base_error_class():
+    """Test base Error class can be instantiated."""
+    error = Error()
+    assert isinstance(error, Exception)
+
+
+def test_interface_error():
+    """Test InterfaceError with message."""
+    message = "Database interface error occurred"
+    error = InterfaceError(message)
+    
+    assert isinstance(error, Error)
+    assert error.message == message
+
+
+def test_interface_error_string_representation():
+    """Test InterfaceError has message attribute."""
+    message = "Connection failed"
+    error = InterfaceError(message)
+    
+    assert hasattr(error, 'message')
+    assert error.message == message
+
+
+def test_database_error_with_empty_response():
+    """Test DatabaseError with empty response text."""
+    mock_response = Mock()
+    mock_response.text = ""
+    mock_response.status_code = 500
+    
+    error = DatabaseError(mock_response)
+    
+    assert "Unknown Error" in error.message
+    assert error.status_code == 500
+
+
+def test_database_error_with_json_api_message():
+    """Test DatabaseError with JSON response containing api:message."""
+    mock_response = Mock()
+    mock_response.text = "Error response"
+    mock_response.headers = {"content-type": "application/json"}
+    mock_response.json.return_value = {
+        "api:message": "Database operation failed",
+        "details": "Additional context"
+    }
+    mock_response.status_code = 400
+    
+    error = DatabaseError(mock_response)
+    
+    assert "Database operation failed" in error.message
+    assert error.status_code == 400
+    assert error.error_obj == mock_response.json()
+
+
+def test_database_error_with_vio_message():
+    """Test DatabaseError with JSON response containing vio:message."""
+    mock_response = Mock()
+    mock_response.text = "Error response"
+    mock_response.headers = {"content-type": "application/json"}
+    mock_response.json.return_value = {
+        "api:error": {
+            "vio:message": "Validation failed"
+        }
+    }
+    mock_response.status_code = 422
+    
+    error = DatabaseError(mock_response)
+    
+    assert "Validation failed" in error.message
+    assert error.status_code == 422
+
+
+def test_database_error_with_unknown_json():
+    """Test DatabaseError with JSON response without known message fields."""
+    mock_response = Mock()
+    mock_response.text = "Error response"
+    mock_response.headers = {"content-type": "application/json"}
+    mock_response.json.return_value = {
+        "unknown_field": "some value"
+    }
+    mock_response.status_code = 500
+    
+    error = DatabaseError(mock_response)
+    
+    assert "Unknown Error" in error.message
+    assert error.status_code == 500
+
+
+def test_database_error_with_non_json_response():
+    """Test DatabaseError with non-JSON response."""
+    mock_response = Mock()
+    mock_response.text = "Plain text error message"
+    mock_response.headers = {"content-type": "text/plain"}
+    mock_response.status_code = 503
+    
+    error = DatabaseError(mock_response)
+    
+    assert error.message == "Plain text error message"
+    assert error.error_obj is None
+    assert error.status_code == 503
+
+
+def test_database_error_string_representation():
+    """Test DatabaseError __str__ method."""
+    mock_response = Mock()
+    mock_response.text = "Error message"
+    mock_response.headers = {"content-type": "text/plain"}
+    mock_response.status_code = 500
+    
+    error = DatabaseError(mock_response)
+    
+    assert str(error) == error.message
+
+
+def test_operational_error():
+    """Test OperationalError inherits from DatabaseError."""
+    mock_response = Mock()
+    mock_response.text = "Operational error"
+    mock_response.headers = {"content-type": "text/plain"}
+    mock_response.status_code = 500
+    
+    error = OperationalError(mock_response)
+    
+    assert isinstance(error, DatabaseError)
+    assert isinstance(error, Error)
+    assert error.message == "Operational error"
+
+
+def test_access_denied_error():
+    """Test AccessDeniedError inherits from DatabaseError."""
+    mock_response = Mock()
+    mock_response.text = "Access denied"
+    mock_response.headers = {"content-type": "text/plain"}
+    mock_response.status_code = 403
+    
+    error = AccessDeniedError(mock_response)
+    
+    assert isinstance(error, DatabaseError)
+    assert isinstance(error, Error)
+    assert error.message == "Access denied"
+    assert error.status_code == 403
+
+
+def test_api_error_class_exists():
+    """Test that APIError class exists and inherits from DatabaseError."""
+    # APIError has a design issue where it calls super().__init__() without response
+    # Just verify the class exists and has correct inheritance
+    assert issubclass(APIError, DatabaseError)
+    assert issubclass(APIError, Error)
+
+
+def test_invalid_uri_error():
+    """Test InvalidURIError can be instantiated."""
+    error = InvalidURIError()
+    
+    assert isinstance(error, Error)
+    assert isinstance(error, Exception)
+
+
+def test_invalid_uri_error_is_simple_error():
+    """Test InvalidURIError is a simple pass-through error."""
+    # InvalidURIError is a simple pass class, no custom __init__
+    error = InvalidURIError()
+    
+    assert isinstance(error, Error)
+    assert isinstance(error, Exception)
+
+
+def test_database_error_json_formatting():
+    """Test that DatabaseError includes formatted JSON details."""
+    mock_response = Mock()
+    mock_response.text = "Error"
+    mock_response.headers = {"content-type": "application/json"}
+    error_data = {
+        "api:message": "Error message",
+        "code": "ERR_001"
+    }
+    mock_response.json.return_value = error_data
+    mock_response.status_code = 400
+    
+    error = DatabaseError(mock_response)
+    
+    # Check that formatted JSON is in the message
+    formatted = json.dumps(error_data, indent=4, sort_keys=True)
+    assert formatted in error.message
+
+
+def test_all_error_classes_are_exceptions():
+    """Test that all error classes inherit from Exception."""
+    errors = [
+        Error(),
+        InterfaceError("test"),
+        InvalidURIError()
+    ]
+    
+    for error in errors:
+        assert isinstance(error, Exception)
+
+
+def test_error_inheritance_chain():
+    """Test proper inheritance chain for database errors."""
+    mock_response = Mock()
+    mock_response.text = "test"
+    mock_response.headers = {"content-type": "text/plain"}
+    mock_response.status_code = 500
+    
+    operational = OperationalError(mock_response)
+    access_denied = AccessDeniedError(mock_response)
+    
+    # All should be DatabaseError
+    assert isinstance(operational, DatabaseError)
+    assert isinstance(access_denied, DatabaseError)
+    
+    # All should be Error
+    assert isinstance(operational, Error)
+    assert isinstance(access_denied, Error)
+    
+    # All should be Exception
+    assert isinstance(operational, Exception)
+    assert isinstance(access_denied, Exception)

terminusdb_client/tests/test_query_syntax.py

@@ -0,0 +1,80 @@
+"""Tests for query_syntax/query_syntax.py module."""
+from terminusdb_client.query_syntax import query_syntax
+from terminusdb_client.woqlquery import WOQLQuery
+
+
+def test_query_syntax_exports_var():
+    """Test that Var is exported."""
+    assert 'Var' in query_syntax.__all__
+    assert hasattr(query_syntax, 'Var')
+
+
+def test_query_syntax_exports_vars():
+    """Test that Vars is exported."""
+    assert 'Vars' in query_syntax.__all__
+    assert hasattr(query_syntax, 'Vars')
+
+
+def test_query_syntax_exports_doc():
+    """Test that Doc is exported."""
+    assert 'Doc' in query_syntax.__all__
+    assert hasattr(query_syntax, 'Doc')
+
+
+def test_barred_items_not_exported():
+    """Test that barred items (re, vars) are not exported."""
+    assert 're' not in query_syntax.__all__
+    assert 'vars' not in query_syntax.__all__
+
+
+def test_allowed_dunder_methods_exported():
+    """Test that allowed dunder methods are exported."""
+    # __and__, __or__, __add__ should be exported
+    assert '__and__' in query_syntax.__all__
+    assert '__or__' in query_syntax.__all__
+    assert '__add__' in query_syntax.__all__
+
+
+def test_dynamic_function_creation():
+    """Test that functions are dynamically created from WOQLQuery."""
+    # Check that some common WOQLQuery methods are available
+    woql_methods = ['triple', 'select', 'limit']
+    
+    for method in woql_methods:
+        assert hasattr(query_syntax, method), f"{method} should be available"
+        assert method in query_syntax.__all__, f"{method} should be in __all__"
+
+
+def test_created_functions_are_callable():
+    """Test that dynamically created functions are callable."""
+    # Test that we can call a dynamically created function
+    if hasattr(query_syntax, 'limit'):
+        func = getattr(query_syntax, 'limit')
+        assert callable(func)
+
+
+def test_created_function_returns_woqlquery():
+    """Test that created functions return WOQLQuery instances."""
+    # Test a simple function that exists on WOQLQuery
+    if hasattr(query_syntax, 'limit'):
+        func = getattr(query_syntax, 'limit')
+        result = func(10)
+        # Should return a WOQLQuery or similar object
+        assert result is not None
+
+
+def test_private_attributes_not_exported():
+    """Test that private attributes (starting with _) are not exported."""
+    for attr in query_syntax.__all__:
+        # All exported attributes should either be in __ALLOWED or not start with _
+        if attr not in ['__and__', '__or__', '__add__']:
+            assert not attr.startswith('_'), f"{attr} should not start with underscore"
+
+
+def test_module_attributes():
+    """Test module has expected attributes."""
+    # These are defined in the module
+    assert hasattr(query_syntax, '__BARRED')
+    assert hasattr(query_syntax, '__ALLOWED')
+    assert hasattr(query_syntax, '__module')
+    assert hasattr(query_syntax, '__exported')