datahike-browser-tests 1.0.0

package/pydatahike/src/datahike/edn.py

@@ -0,0 +1,311 @@
+"""EDN type helpers and common keyword constants.
+
+This module provides explicit type constructors for EDN values and
+pre-defined constants for frequently-used Datahike keywords.
+
+Use these when you need fine-grained control over EDN conversion or
+want to avoid string prefixes.
+
+Example:
+    >>> from datahike import edn, kw
+    >>>
+    >>> # Explicit types
+    >>> schema = [{
+    ...     "db/ident": edn.keyword("person/name"),
+    ...     "db/valueType": kw.STRING,
+    ...     "db/cardinality": kw.ONE,
+    ...     "db/doc": edn.string(":literal-colon-in-doc")
+    ... }]
+    >>>
+    >>> db.transact(schema)
+"""
+
+from typing import Optional
+from .database import EDNType
+
+
+# =============================================================================
+# Explicit EDN Types
+# =============================================================================
+
+class Keyword(EDNType):
+    """Explicit EDN keyword.
+
+    Use when you need to construct keywords programmatically or force
+    a value to be a keyword regardless of the string prefix rules.
+
+    Args:
+        name: Keyword name
+        namespace: Optional namespace
+
+    Examples:
+        >>> edn.keyword("name")
+        # → :name
+
+        >>> edn.keyword("name", "person")
+        # → :person/name
+    """
+
+    def __init__(self, name: str, namespace: Optional[str] = None):
+        if namespace:
+            self.value = f"{namespace}/{name}"
+        else:
+            self.value = name
+
+    def to_edn(self) -> str:
+        return f":{self.value}"
+
+    def __repr__(self):
+        return f"Keyword('{self.value}')"
+
+
+class Symbol(EDNType):
+    """Explicit EDN symbol.
+
+    Symbols are used for function names and special forms in Clojure.
+    Rarely needed in data transactions.
+
+    Args:
+        name: Symbol name
+        namespace: Optional namespace
+
+    Examples:
+        >>> edn.symbol("my-fn")
+        # → my-fn
+
+        >>> edn.symbol("assoc", "clojure.core")
+        # → clojure.core/assoc
+    """
+
+    def __init__(self, name: str, namespace: Optional[str] = None):
+        if namespace:
+            self.value = f"{namespace}/{name}"
+        else:
+            self.value = name
+
+    def to_edn(self) -> str:
+        return self.value
+
+    def __repr__(self):
+        return f"Symbol('{self.value}')"
+
+
+class UUID(EDNType):
+    """Explicit EDN UUID.
+
+    Args:
+        value: UUID string (with or without #uuid prefix)
+
+    Examples:
+        >>> edn.uuid("550e8400-e29b-41d4-a716-446655440000")
+        # → #uuid "550e8400-e29b-41d4-a716-446655440000"
+    """
+
+    def __init__(self, value: str):
+        # Strip #uuid prefix if present
+        if value.startswith('#uuid'):
+            value = value[5:].strip().strip('"')
+        self.value = value
+
+    def to_edn(self) -> str:
+        return f'#uuid "{self.value}"'
+
+    def __repr__(self):
+        return f"UUID('{self.value}')"
+
+
+class Inst(EDNType):
+    """Explicit EDN instant (timestamp).
+
+    Args:
+        value: ISO 8601 timestamp string
+
+    Examples:
+        >>> edn.inst("2024-01-01T00:00:00Z")
+        # → #inst "2024-01-01T00:00:00Z"
+    """
+
+    def __init__(self, value: str):
+        # Strip #inst prefix if present
+        if value.startswith('#inst'):
+            value = value[5:].strip().strip('"')
+        self.value = value
+
+    def to_edn(self) -> str:
+        return f'#inst "{self.value}"'
+
+    def __repr__(self):
+        return f"Inst('{self.value}')"
+
+
+# =============================================================================
+# Convenience Functions
+# =============================================================================
+
+def keyword(name: str, namespace: Optional[str] = None) -> Keyword:
+    """Create an EDN keyword.
+
+    Args:
+        name: Keyword name
+        namespace: Optional namespace
+
+    Returns:
+        Keyword instance
+
+    Examples:
+        >>> keyword("name")
+        # → :name
+
+        >>> keyword("name", "person")
+        # → :person/name
+    """
+    return Keyword(name, namespace)
+
+
+def symbol(name: str, namespace: Optional[str] = None) -> Symbol:
+    """Create an EDN symbol.
+
+    Args:
+        name: Symbol name
+        namespace: Optional namespace
+
+    Returns:
+        Symbol instance
+    """
+    return Symbol(name, namespace)
+
+
+def uuid(value: str) -> UUID:
+    """Create an EDN UUID.
+
+    Args:
+        value: UUID string
+
+    Returns:
+        UUID instance
+    """
+    return UUID(value)
+
+
+def inst(value: str) -> Inst:
+    """Create an EDN instant.
+
+    Args:
+        value: ISO 8601 timestamp string
+
+    Returns:
+        Inst instance
+    """
+    return Inst(value)
+
+
+def string(value: str) -> str:
+    """Force a value to be treated as a string.
+
+    Use this to create strings that start with ':' without them
+    becoming keywords.
+
+    Args:
+        value: String value (can start with :)
+
+    Returns:
+        Marked string that will be quoted in EDN
+
+    Examples:
+        >>> edn.string(":literal-colon")
+        # → ":literal-colon" (not :literal-colon keyword)
+    """
+    # Use special marker that database.py recognizes
+    return f"<STRING>{value}"
+
+
+# =============================================================================
+# Common Keyword Constants
+# =============================================================================
+
+class Keywords:
+    """Pre-defined Datahike keyword constants.
+
+    Use these for common Datahike schema and transaction attributes
+    to avoid typos and get IDE autocompletion.
+
+    Examples:
+        >>> from datahike import kw
+        >>>
+        >>> schema = [{
+        ...     kw.DB_IDENT: edn.keyword("person/name"),
+        ...     kw.DB_VALUE_TYPE: kw.STRING,
+        ...     kw.DB_CARDINALITY: kw.ONE
+        ... }]
+    """
+
+    # Entity attributes
+    DB_ID = ":db/id"
+    DB_IDENT = ":db/ident"
+
+    # Schema attributes
+    DB_VALUE_TYPE = ":db/valueType"
+    DB_CARDINALITY = ":db/cardinality"
+    DB_DOC = ":db/doc"
+    DB_UNIQUE = ":db/unique"
+    DB_IS_COMPONENT = ":db/isComponent"
+    DB_NO_HISTORY = ":db/noHistory"
+    DB_INDEX = ":db/index"
+    DB_FULLTEXT = ":db/fulltext"
+
+    # Value types
+    STRING = ":db.type/string"
+    BOOLEAN = ":db.type/boolean"
+    LONG = ":db.type/long"
+    BIGINT = ":db.type/bigint"
+    FLOAT = ":db.type/float"
+    DOUBLE = ":db.type/double"
+    BIGDEC = ":db.type/bigdec"
+    INSTANT = ":db.type/instant"
+    UUID_TYPE = ":db.type/uuid"
+    KEYWORD_TYPE = ":db.type/keyword"
+    SYMBOL_TYPE = ":db.type/symbol"
+    REF = ":db.type/ref"
+    BYTES = ":db.type/bytes"
+
+    # Cardinality
+    ONE = ":db.cardinality/one"
+    MANY = ":db.cardinality/many"
+
+    # Uniqueness
+    UNIQUE_VALUE = ":db.unique/value"
+    UNIQUE_IDENTITY = ":db.unique/identity"
+
+    # Transaction metadata
+    TX = ":db/tx"
+    TX_INSTANT = ":db/txInstant"
+
+    # Schema flexibility
+    SCHEMA_READ = ":read"
+    SCHEMA_WRITE = ":write"
+
+
+# Export singleton instance
+kw = Keywords()
+
+
+# =============================================================================
+# Public API
+# =============================================================================
+
+__all__ = [
+    # Types
+    'Keyword',
+    'Symbol',
+    'UUID',
+    'Inst',
+    # Functions
+    'keyword',
+    'symbol',
+    'uuid',
+    'inst',
+    'string',
+    # Constants
+    'Keywords',
+    'kw',
+]

package/pydatahike/tests/conftest.py

@@ -0,0 +1,17 @@
+"""Pytest configuration and shared fixtures."""
+import pytest
+import uuid
+
+
+@pytest.fixture
+def mem_config():
+    """Generate a unique in-memory database config."""
+    db_id = str(uuid.uuid4())
+    return f'{{:store {{:backend :memory :id #uuid "{db_id}"}}}}'
+
+
+@pytest.fixture
+def mem_config_flexible():
+    """Generate a unique in-memory database config with schema flexibility."""
+    db_id = str(uuid.uuid4())
+    return f'{{:store {{:backend :memory :id #uuid "{db_id}"}} :schema-flexibility :read}}'

package/pydatahike/tests/test_basic.py

@@ -0,0 +1,170 @@
+"""Basic tests for Datahike Python bindings."""
+import json
+import uuid
+import sys
+import os
+
+# Add src to path for development
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+from datahike import (
+    create_database,
+    delete_database,
+    database_exists,
+    transact,
+    q,
+    pull,
+    schema,
+    DatahikeException,
+)
+
+
+def test_database_lifecycle():
+    """Test create, exists, delete database."""
+    db_id = str(uuid.uuid4())
+    config = f'{{:store {{:backend :memory :id #uuid "{db_id}"}}}}'
+
+    print(f"Using config: {config}")
+
+    # Create
+    print("Creating database...")
+    create_database(config)
+
+    # Check exists
+    print("Checking if database exists...")
+    exists = database_exists(config)
+    print(f"Database exists: {exists}")
+    assert exists == True
+
+    # Delete
+    print("Deleting database...")
+    delete_database(config)
+
+    # Check deleted
+    exists = database_exists(config)
+    print(f"Database exists after delete: {exists}")
+    assert exists == False
+
+    print("SUCCESS: Database lifecycle test passed!")
+
+
+def test_transact_and_query_with_schema_flexibility():
+    """Test transact and query with schema-flexibility :read (flexible schema)."""
+    db_id = str(uuid.uuid4())
+    config = f'{{:store {{:backend :memory :id #uuid "{db_id}"}} :schema-flexibility :read}}'
+
+    print(f"\nUsing config: {config}")
+
+    try:
+        # Create database
+        print("Creating database...")
+        create_database(config)
+
+        # Transact data using JSON format
+        print("Transacting data...")
+        tx_data = json.dumps([
+            {"name": "Alice", "age": 30},
+            {"name": "Bob", "age": 25}
+        ])
+        result = transact(config, tx_data, input_format='json')
+        print(f"Transaction result: {result}")
+
+        # Query for Alice
+        print("Querying for Alice...")
+        query_result = q(
+            '[:find ?e ?name :where [?e :name ?name] [?e :name "Alice"]]',
+            [('db', config)],
+            output_format='json'
+        )
+        print(f"Query result: {query_result}")
+        assert len(query_result) > 0, "Should find Alice"
+
+        # Pull entity
+        print("Pulling entity...")
+        # Query result is ['!set', [[eid, name], ...]]
+        actual_results = query_result[1] if query_result[0] == '!set' else query_result
+        entity_id = actual_results[0][0]
+        entity = pull(config, '[*]', entity_id, output_format='json')
+        print(f"Pulled entity: {entity}")
+        # In JSON mode, keywords don't have : prefix
+        assert entity.get('name') == 'Alice' or entity.get(':name') == 'Alice'
+
+        print("SUCCESS: Transact and query test passed!")
+
+    finally:
+        # Cleanup
+        print("Cleaning up...")
+        delete_database(config)
+
+
+def test_transact_with_explicit_schema():
+    """Test transact and query with explicit schema."""
+    db_id = str(uuid.uuid4())
+    config = f'{{:store {{:backend :memory :id #uuid "{db_id}"}}}}'
+
+    print(f"\nUsing config: {config}")
+
+    try:
+        # Create database
+        print("Creating database...")
+        create_database(config)
+
+        # First transact schema using EDN format (keywords need proper representation)
+        print("Transacting schema...")
+        schema_tx = '[{:db/ident :name :db/valueType :db.type/string :db/cardinality :db.cardinality/one} {:db/ident :age :db/valueType :db.type/long :db/cardinality :db.cardinality/one}]'
+        transact(config, schema_tx, input_format='edn')
+
+        # Check schema was added
+        print("Checking schema...")
+        db_schema = schema(config, output_format='json')
+        print(f"Schema: {db_schema}")
+
+        # Transact data using JSON - schema validates types
+        print("Transacting data...")
+        tx_data = json.dumps([
+            {"name": "Charlie", "age": 35},
+            {"name": "Diana", "age": 28}
+        ])
+        transact(config, tx_data, input_format='json')
+
+        # Query
+        print("Querying...")
+        query_result = q(
+            '[:find ?e ?name ?age :where [?e :name ?name] [?e :age ?age]]',
+            [('db', config)],
+            output_format='json'
+        )
+        print(f"Query result: {query_result}")
+        actual_results = query_result[1] if query_result[0] == '!set' else query_result
+        assert len(actual_results) == 2, f"Expected 2 results, got {len(actual_results)}"
+
+        print("SUCCESS: Explicit schema test passed!")
+
+    finally:
+        # Cleanup
+        print("Cleaning up...")
+        delete_database(config)
+
+
+def test_exception_handling():
+    """Test that exceptions are properly raised."""
+    db_id = str(uuid.uuid4())
+    config = f'{{:store {{:backend :memory :id #uuid "{db_id}"}}}}'
+
+    print("\nTesting exception handling...")
+
+    try:
+        # Try to query non-existent database
+        q('[:find ?e :where [?e :name "test"]]', [('db', config)])
+        assert False, "Should have raised exception"
+    except DatahikeException as e:
+        print(f"Caught expected exception: {e}")
+        print("SUCCESS: Exception handling test passed!")
+
+
+if __name__ == '__main__':
+    test_database_lifecycle()
+    test_transact_and_query_with_schema_flexibility()
+    test_transact_with_explicit_schema()
+    test_exception_handling()
+    print("\n=== ALL TESTS PASSED ===")

package/pydatahike/tests/test_database.py

@@ -0,0 +1,51 @@
+"""Tests for database lifecycle operations."""
+import pytest
+from datahike import (
+    create_database,
+    delete_database,
+    database_exists,
+    database,
+    DatahikeException,
+)
+
+
+def test_create_and_delete(mem_config):
+    """Test create and delete database."""
+    # Create
+    create_database(mem_config)
+
+    # Check exists
+    assert database_exists(mem_config) is True
+
+    # Delete
+    delete_database(mem_config)
+
+    # Check deleted
+    assert database_exists(mem_config) is False
+
+
+def test_database_context_manager(mem_config):
+    """Test database context manager for automatic cleanup."""
+    # Database should not exist before
+    assert database_exists(mem_config) is False
+
+    # Use context manager
+    with database(mem_config) as cfg:
+        # Should exist inside context
+        assert database_exists(cfg) is True
+        assert cfg == mem_config
+
+    # Should be deleted after context
+    assert database_exists(mem_config) is False
+
+
+def test_exception_on_nonexistent_database(mem_config):
+    """Test that operations on nonexistent database raise exception."""
+    from datahike import q
+
+    # Database doesn't exist
+    assert database_exists(mem_config) is False
+
+    # Try to query should raise exception
+    with pytest.raises(DatahikeException):
+        q('[:find ?e :where [?e :name "test"]]', [('db', mem_config)])