moose-lib 0.6.90__py3-none-any.whl → 0.6.283__py3-none-any.whl

tests/test_moose_model.py

@@ -0,0 +1,153 @@
+"""Tests for MooseModel base class with column descriptors"""
+
+from pydantic import BaseModel
+from moose_lib.dmv2.moose_model import MooseModel
+from moose_lib.data_models import Column
+
+
+def test_moosemodel_inherits_from_basemodel():
+    """MooseModel should be a valid Pydantic BaseModel"""
+
+    class User(MooseModel):
+        user_id: int
+        email: str
+
+    # Should work as normal Pydantic model
+    instance = User(user_id=123, email="test@example.com")
+    assert instance.user_id == 123
+    assert instance.email == "test@example.com"
+
+
+def test_moosemodel_adds_column_descriptors():
+    """MooseModel metaclass should add Column descriptors for each field"""
+
+    class User(MooseModel):
+        user_id: int
+        email: str
+        age: int
+
+    # Check Column descriptors exist at class level
+    assert hasattr(User, "user_id")
+    assert isinstance(User.user_id, Column)
+    assert User.user_id.name == "user_id"
+
+    assert hasattr(User, "email")
+    assert isinstance(User.email, Column)
+    assert User.email.name == "email"
+
+    assert hasattr(User, "age")
+    assert isinstance(User.age, Column)
+    assert User.age.name == "age"
+
+
+def test_moosemodel_column_format_spec():
+    """Column descriptors should support format specs"""
+
+    class Product(MooseModel):
+        product_id: int
+        product_name: str
+
+    # Test format spec
+    result = f"{Product.product_id:col}"
+    assert result == "`product_id`"
+
+    result = f"{Product.product_name:c}"
+    assert result == "`product_name`"
+
+
+def test_moosemodel_adds_cols_property():
+    """MooseModel should add .cols property for backward compatibility"""
+
+    class Order(MooseModel):
+        order_id: int
+        total: float
+
+    # Check .cols property exists
+    assert hasattr(Order, "cols")
+    assert hasattr(Order.cols, "order_id")
+    assert hasattr(Order.cols, "total")
+
+    # Verify .cols.field returns Column
+    assert isinstance(Order.cols.order_id, Column)
+    assert Order.cols.order_id.name == "order_id"
+
+
+def test_moosemodel_instance_attributes_separate():
+    """Instance attributes should be separate from class Column descriptors"""
+
+    class User(MooseModel):
+        user_id: int
+        email: str
+
+    # Class level: Column objects
+    assert isinstance(User.user_id, Column)
+
+    # Instance level: actual values
+    instance = User(user_id=456, email="user@test.com")
+    assert instance.user_id == 456
+    assert isinstance(instance.user_id, int)
+    assert instance.email == "user@test.com"
+
+
+def test_moosemodel_backward_compatible_with_basemodel():
+    """MooseModel should be usable wherever BaseModel is expected"""
+
+    class User(MooseModel):
+        user_id: int
+        email: str
+
+    # Check it's a BaseModel subclass
+    assert issubclass(User, BaseModel)
+
+    # Check Pydantic features work
+    assert hasattr(User, "model_fields")
+    assert hasattr(User, "model_validate")
+    assert hasattr(User, "model_dump")
+
+    instance = User(user_id=789, email="another@test.com")
+    dumped = instance.model_dump()
+    assert dumped == {"user_id": 789, "email": "another@test.com"}
+
+
+def test_moosemodel_empty_model():
+    """MooseModel should handle models with no fields"""
+
+    class EmptyModel(MooseModel):
+        pass
+
+    # Should not crash
+    instance = EmptyModel()
+    assert instance is not None
+
+
+def test_moosemodel_cols_bracket_access():
+    """MooseModel.cols should support bracket notation"""
+
+    class User(MooseModel):
+        user_id: int
+        email: str
+
+    # Bracket access
+    col = User.cols["user_id"]
+    assert isinstance(col, Column)
+    assert col.name == "user_id"
+
+    col2 = User.cols["email"]
+    assert col2.name == "email"
+
+
+def test_moosemodel_in_sql_fstring():
+    """MooseModel columns should work in SQL f-strings"""
+
+    class Analytics(MooseModel):
+        event_id: int
+        timestamp: str
+        value: float
+
+    # Test complete SQL construction
+    query = f"SELECT {Analytics.event_id:col}, {Analytics.timestamp:col}, {Analytics.value:col} FROM analytics WHERE {Analytics.event_id:col} > 100"
+
+    expected = (
+        "SELECT `event_id`, `timestamp`, `value` FROM analytics WHERE `event_id` > 100"
+    )
+    assert query == expected

tests/test_olap_table_moosemodel.py

@@ -0,0 +1,89 @@
+"""Tests for OlapTable with MooseModel integration"""
+
+from moose_lib.dmv2 import OlapTable, OlapConfig, MooseModel
+from moose_lib.data_models import Column
+
+
+def test_olaptable_works_with_moosemodel():
+    """OlapTable should accept MooseModel types"""
+
+    class User(MooseModel):
+        user_id: int
+        email: str
+
+    table = OlapTable[User]("users", OlapConfig())
+
+    assert table.name == "users"
+    assert table.model_type == User
+
+
+def test_olaptable_moosemodel_direct_column_access():
+    """OlapTable with MooseModel should enable direct column access via model"""
+
+    class Product(MooseModel):
+        product_id: int
+        name: str
+        price: float
+
+    table = OlapTable[Product]("products")
+
+    # Access columns through the model class
+    assert isinstance(Product.product_id, Column)
+    assert Product.product_id.name == "product_id"
+
+    # Should work in f-strings
+    query = f"SELECT {Product.product_id:col}, {Product.name:col} FROM {table.name}"
+    assert query == "SELECT `product_id`, `name` FROM products"
+
+
+def test_olaptable_moosemodel_cols_backward_compat():
+    """OlapTable with MooseModel should maintain .cols backward compatibility"""
+
+    class Order(MooseModel):
+        order_id: int
+        total: float
+
+    table = OlapTable[Order]("orders")
+
+    # OLD pattern still works
+    assert hasattr(Order, "cols")
+    assert isinstance(Order.cols.order_id, Column)
+
+    # Can use in queries
+    query = f"SELECT {Order.cols.order_id} FROM orders"
+    assert "`order_id`" in query
+
+
+def test_olaptable_with_basemodel_still_works():
+    """OlapTable should still work with regular BaseModel (backward compat)"""
+
+    from pydantic import BaseModel
+
+    class LegacyModel(BaseModel):
+        legacy_id: int
+        legacy_name: str
+
+    # Should not crash
+    table = OlapTable[LegacyModel]("legacy")
+
+    # Old .cols pattern should still work
+    assert hasattr(table, "cols")
+
+    # Note: LegacyModel.legacy_id won't be a Column (no metaclass)
+    # This is expected - only MooseModel gets the new feature
+
+
+def test_olaptable_model_property():
+    """OlapTable should provide access to the model class"""
+
+    class Analytics(MooseModel):
+        event_id: int
+        timestamp: str
+
+    table = OlapTable[Analytics]("analytics")
+
+    # Should be able to access model type
+    assert table.model_type == Analytics
+
+    # Can use for column access
+    assert isinstance(table.model_type.event_id, Column)

tests/test_olap_table_versioning.py

@@ -0,0 +1,210 @@
+"""
+Tests for OlapTable versioning functionality.
+
+This test module verifies that multiple versions of OlapTables with the same name
+can coexist and that the infrastructure map generation handles versioned keys correctly.
+"""
+
+import pytest
+from moose_lib import (
+    OlapTable,
+    OlapConfig,
+    ClickHouseEngines,
+    MergeTreeEngine,
+    ReplacingMergeTreeEngine,
+)
+from moose_lib.dmv2.registry import get_tables
+from moose_lib.internal import to_infra_map
+from pydantic import BaseModel
+from typing import Optional
+
+
+class UserEvent(BaseModel):
+    """Sample model for testing OlapTable versioning."""
+
+    user_id: str
+    event_type: str
+    timestamp: float
+    metadata: Optional[str] = None
+
+
+class UserEventV2(BaseModel):
+    """Updated model with additional fields for version testing."""
+
+    user_id: str
+    event_type: str
+    timestamp: float
+    metadata: Optional[str] = None
+    session_id: str
+    user_agent: Optional[str] = None
+
+
+def test_multiple_olap_table_versions_can_coexist():
+    """Test that multiple versions of the same table can be registered simultaneously."""
+    # Create version 1.0 of the table
+    table_v1 = OlapTable[UserEvent](
+        "UserEvents",
+        OlapConfig(
+            version="1.0",
+            engine=MergeTreeEngine(),
+            order_by_fields=["user_id", "timestamp"],
+        ),
+    )
+
+    # Create version 2.0 of the table with different configuration
+    table_v2 = OlapTable[UserEventV2](
+        "UserEvents",
+        OlapConfig(
+            version="2.0",
+            engine=ReplacingMergeTreeEngine(),
+            order_by_fields=["user_id", "timestamp", "session_id"],
+        ),
+    )
+
+    # Both tables should be registered successfully
+    tables = get_tables()
+    assert "UserEvents_1.0" in tables
+    assert "UserEvents_2.0" in tables
+
+    # Verify they are different instances
+    assert tables["UserEvents_1.0"] is table_v1
+    assert tables["UserEvents_2.0"] is table_v2
+
+    # Verify configurations are different
+    assert table_v1.config.version == "1.0"
+    assert table_v2.config.version == "2.0"
+    assert isinstance(table_v1.config.engine, MergeTreeEngine)
+    assert isinstance(table_v2.config.engine, ReplacingMergeTreeEngine)
+
+
+def test_unversioned_and_versioned_tables_can_coexist():
+    """Test that unversioned and versioned tables with the same name can coexist."""
+    # Create unversioned table
+    unversioned_table = OlapTable[UserEvent](
+        "EventData", OlapConfig(engine=MergeTreeEngine())
+    )
+
+    # Create versioned table with same name
+    versioned_table = OlapTable[UserEvent](
+        "EventData", OlapConfig(version="1.5", engine=MergeTreeEngine())
+    )
+
+    # Both should be registered
+    tables = get_tables()
+    assert "EventData" in tables  # Unversioned
+    assert "EventData_1.5" in tables  # Versioned
+
+    assert tables["EventData"] is unversioned_table
+    assert tables["EventData_1.5"] is versioned_table
+
+
+def test_duplicate_version_registration_fails():
+    """Test that registering the same table name and version twice fails."""
+    # Create first table
+    OlapTable[UserEvent](
+        "DuplicateTest", OlapConfig(version="1.0", engine=MergeTreeEngine())
+    )
+
+    # Attempting to create another table with same name and version should fail
+    with pytest.raises(
+        ValueError,
+        match="OlapTable with name DuplicateTest and version 1.0 already exists",
+    ):
+        OlapTable[UserEvent](
+            "DuplicateTest", OlapConfig(version="1.0", engine=MergeTreeEngine())
+        )
+
+
+def test_infrastructure_map_uses_versioned_keys():
+    """Test that infrastructure map generation uses versioned keys for tables."""
+    # Create multiple versions of tables
+    table_v1 = OlapTable[UserEvent](
+        "InfraMapTest",
+        OlapConfig(
+            version="1.0", engine=MergeTreeEngine(), order_by_fields=["user_id"]
+        ),
+    )
+
+    table_v2 = OlapTable[UserEvent](
+        "InfraMapTest",
+        OlapConfig(
+            version="2.0",
+            engine=ReplacingMergeTreeEngine(),
+            order_by_fields=["user_id", "timestamp"],
+        ),
+    )
+
+    unversioned_table = OlapTable[UserEvent](
+        "UnversionedInfraTest", OlapConfig(engine=MergeTreeEngine())
+    )
+
+    # Generate infrastructure map
+    tables_registry = get_tables()
+    infra_map = to_infra_map()
+
+    # Verify versioned keys are used in infrastructure map
+    assert "InfraMapTest_1.0" in infra_map["tables"]
+    assert "InfraMapTest_2.0" in infra_map["tables"]
+    assert "UnversionedInfraTest" in infra_map["tables"]
+
+    # Verify table configurations in infra map
+    v1_config = infra_map["tables"]["InfraMapTest_1.0"]
+    v2_config = infra_map["tables"]["InfraMapTest_2.0"]
+    unversioned_config = infra_map["tables"]["UnversionedInfraTest"]
+
+    assert v1_config["name"] == "InfraMapTest"
+    assert v1_config["version"] == "1.0"
+    assert v1_config["engineConfig"]["engine"] == "MergeTree"
+
+    assert v2_config["name"] == "InfraMapTest"
+    assert v2_config["version"] == "2.0"
+    assert v2_config["engineConfig"]["engine"] == "ReplacingMergeTree"
+
+    assert unversioned_config["name"] == "UnversionedInfraTest"
+    assert unversioned_config.get("version") is None
+
+
+def test_version_with_dots_handled_correctly():
+    """Test that versions with dots are handled correctly in keys."""
+    # Create table with semantic version
+    table = OlapTable[UserEvent](
+        "SemanticVersionTest", OlapConfig(version="1.2.3", engine=MergeTreeEngine())
+    )
+
+    # Should be registered with version in key
+    tables = get_tables()
+    assert "SemanticVersionTest_1.2.3" in tables
+    assert tables["SemanticVersionTest_1.2.3"] is table
+
+    # Verify in infrastructure map
+    infra_map = to_infra_map()
+    assert "SemanticVersionTest_1.2.3" in infra_map["tables"]
+
+    table_config = infra_map["tables"]["SemanticVersionTest_1.2.3"]
+    assert table_config["version"] == "1.2.3"
+
+
+def test_backward_compatibility_with_legacy_engines():
+    """Test that versioning works with legacy enum-based engine configuration."""
+    # Create table with legacy enum engine (should show deprecation warning)
+    table = OlapTable[UserEvent](
+        "LegacyEngineTest",
+        OlapConfig(version="1.0", engine=ClickHouseEngines.ReplacingMergeTree),
+    )
+
+    # Should still be registered correctly
+    tables = get_tables()
+    assert "LegacyEngineTest_1.0" in tables
+    assert tables["LegacyEngineTest_1.0"] is table
+
+    # Should work in infrastructure map
+    infra_map = to_infra_map()
+    assert "LegacyEngineTest_1.0" in infra_map["tables"]
+
+    table_config = infra_map["tables"]["LegacyEngineTest_1.0"]
+    assert table_config["version"] == "1.0"
+    assert table_config["engineConfig"]["engine"] == "ReplacingMergeTree"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])

tests/test_query_builder.py

@@ -1,7 +1,7 @@
 from datetime import datetime
 
 from moose_lib.query_builder import Query, col
-from moose_lib.dmv2 import IngestPipeline, IngestPipelineConfig
+from moose_lib.dmv2 import IngestPipeline, IngestPipelineConfig, OlapTable, OlapConfig
 from pydantic import BaseModel
 from moose_lib.data_models import Key
 
@@ -14,15 +14,19 @@ class Bar(BaseModel):
 
 
 def test_simple_select_and_where():
-    bar_model = IngestPipeline[Bar]("Bar", IngestPipelineConfig(
-        ingest=False,
-        stream=True,
-        table=True,
-        dead_letter_queue=True
-    ))
+    bar_model = IngestPipeline[Bar](
+        "Bar",
+        IngestPipelineConfig(
+            ingest=False, stream=True, table=True, dead_letter_queue=True
+        ),
+    )
     bar_cols = bar_model.get_table().cols
 
-    q1 = Query().from_(bar_model.get_table()).select(bar_cols.has_text, bar_cols.text_length)
+    q1 = (
+        Query()
+        .from_(bar_model.get_table())
+        .select(bar_cols.has_text, bar_cols.text_length)
+    )
     assert q1.to_sql() == 'SELECT "Bar"."has_text", "Bar"."text_length" FROM Bar'
 
     q2 = (
@@ -32,7 +36,91 @@ def test_simple_select_and_where():
         .where(col(bar_cols.has_text).eq(True))
     )
     sql, params = q2.to_sql_and_params()
-    assert sql == 'SELECT "Bar"."has_text", "Bar"."text_length" FROM Bar WHERE "Bar"."has_text" = {p0: Bool}'
+    assert (
+        sql
+        == 'SELECT "Bar"."has_text", "Bar"."text_length" FROM Bar WHERE "Bar"."has_text" = {p0: Bool}'
+    )
     assert params == {"p0": True}
 
 
+def test_table_with_database_config():
+    """Test that tables with database config generate correct SQL with two identifiers"""
+
+    class TestModel(BaseModel):
+        id: int
+        name: str
+
+    # Table without database
+    table_without_db = OlapTable[TestModel]("my_table_no_db", OlapConfig())
+
+    # Table with database
+    table_with_db = OlapTable[TestModel](
+        "my_table_with_db", OlapConfig(database="my_database")
+    )
+
+    # Test Query builder with table that has database
+    q1 = (
+        Query()
+        .from_(table_with_db)
+        .select(table_with_db.cols.id, table_with_db.cols.name)
+    )
+    sql1 = q1.to_sql()
+    # The Query builder should handle the database-qualified table reference
+    assert "my_database" in sql1 or "my_table" in sql1
+
+    # Test string interpolation format for QueryClient.execute()
+    # When a table with database is used, it should generate two separate Identifier parameters
+    from string import Formatter
+
+    # Simulate what happens in QueryClient.execute() with a table that has database
+    template = "SELECT * FROM {table}"
+    variables = {"table": table_with_db}
+
+    params = {}
+    values = {}
+    i = 0
+
+    for _, variable_name, _, _ in Formatter().parse(template):
+        if variable_name:
+            value = variables[variable_name]
+            if isinstance(value, OlapTable) and value.config.database:
+                # Should use two separate Identifier parameters
+                params[variable_name] = f"{{p{i}: Identifier}}.{{p{i + 1}: Identifier}}"
+                values[f"p{i}"] = value.config.database
+                values[f"p{i + 1}"] = value.name
+                i += 2
+            else:
+                params[variable_name] = f"{{p{i}: Identifier}}"
+                values[f"p{i}"] = value.name
+                i += 1
+
+    clickhouse_query = template.format_map(params)
+
+    assert clickhouse_query == "SELECT * FROM {p0: Identifier}.{p1: Identifier}"
+    assert values == {"p0": "my_database", "p1": "my_table_with_db"}
+
+    # Test with table without database
+    variables_no_db = {"table": table_without_db}
+    params_no_db = {}
+    values_no_db = {}
+    i = 0
+
+    for _, variable_name, _, _ in Formatter().parse(template):
+        if variable_name:
+            value = variables_no_db[variable_name]
+            if isinstance(value, OlapTable) and value.config.database:
+                params_no_db[variable_name] = (
+                    f"{{p{i}: Identifier}}.{{p{i + 1}: Identifier}}"
+                )
+                values_no_db[f"p{i}"] = value.config.database
+                values_no_db[f"p{i + 1}"] = value.name
+                i += 2
+            else:
+                params_no_db[variable_name] = f"{{p{i}: Identifier}}"
+                values_no_db[f"p{i}"] = value.name
+                i += 1
+
+    clickhouse_query_no_db = template.format_map(params_no_db)
+
+    assert clickhouse_query_no_db == "SELECT * FROM {p0: Identifier}"
+    assert values_no_db == {"p0": "my_table_no_db"}

tests/test_redis_client.py

@@ -6,10 +6,12 @@ import pytest
 from pydantic import BaseModel
 from moose_lib import MooseCache
 
+
 class Config(BaseModel):
     baz: int
     qux: bool
 
+
 @pytest.mark.integration
 def test_cache_strings():
     cache = MooseCache()
@@ -26,6 +28,7 @@ def test_cache_strings():
     # Clean up
     cache.clear_keys("test")
 
+
 @pytest.mark.integration
 def test_cache_pydantic():
     cache = MooseCache()
@@ -47,6 +50,7 @@ def test_cache_pydantic():
     # Clean up
     cache.clear_keys("test")
 
+
 @pytest.mark.integration
 def test_cache_ttl():
     cache = MooseCache()
@@ -66,6 +70,7 @@ def test_cache_ttl():
     # Clean up
     cache.clear_keys("test")
 
+
 @pytest.mark.integration
 def test_cache_nonexistent():
     cache = MooseCache()
@@ -75,6 +80,7 @@ def test_cache_nonexistent():
     assert cache.get("nonexistent", str) is None
     assert cache.get("nonexistent", Config) is None
 
+
 @pytest.mark.integration
 def test_cache_invalid_type():
     cache = MooseCache()
@@ -86,6 +92,7 @@ def test_cache_invalid_type():
     with pytest.raises(TypeError):
         cache.get("test", dict)
 
+
 @pytest.mark.integration
 def test_atexit_cleanup():
     # Create a test script that will be run in a separate process
@@ -107,9 +114,9 @@ sys.exit(0)
 
     try:
         # Run the script and capture output
-        result = subprocess.run([sys.executable, "test_atexit.py"],
-                              capture_output=True,
-                              text=True)
+        result = subprocess.run(
+            [sys.executable, "test_atexit.py"], capture_output=True, text=True
+        )
 
         # Check if we see both the connection and disconnection messages
         output = result.stdout + result.stderr