domainforge 0.13.0

package/tests/test_expression.py

@@ -0,0 +1,256 @@
+"""Tests for Expression and NormalizedExpression bindings."""
+
+from domainforge import (
+    Expression,
+    NormalizedExpression,
+    BinaryOp,
+    UnaryOp,
+    Quantifier,
+    AggregateFunction,
+    WindowSpec,
+)
+
+
+class TestExpressionFactoryMethods:
+    """Tests for Expression factory methods."""
+
+    def test_literal_bool(self):
+        """Test creating boolean literal expressions."""
+        expr = Expression.literal(True)
+        assert str(expr) == "true"
+
+        expr_false = Expression.literal(False)
+        assert str(expr_false) == "false"
+
+    def test_literal_number(self):
+        """Test creating number literal expressions."""
+        expr = Expression.literal(42)
+        assert str(expr) == "42"
+
+        expr_float = Expression.literal(3.14)
+        assert "3.14" in str(expr_float)
+
+    def test_literal_string(self):
+        """Test creating string literal expressions."""
+        expr = Expression.literal("hello")
+        assert "hello" in str(expr)
+
+    def test_variable(self):
+        """Test creating variable expressions."""
+        expr = Expression.variable("x")
+        assert str(expr) == "x"
+
+    def test_quantity(self):
+        """Test creating quantity literal expressions."""
+        expr = Expression.quantity("100", "USD")
+        assert "100" in str(expr)
+        assert "USD" in str(expr)
+
+    def test_time(self):
+        """Test creating time literal expressions."""
+        expr = Expression.time("2025-01-01T00:00:00Z")
+        assert "2025-01-01" in str(expr)
+
+    def test_interval(self):
+        """Test creating interval literal expressions."""
+        expr = Expression.interval("2025-01-01T09:00:00Z", "2025-01-01T17:00:00Z")
+        assert "09:00:00" in str(expr)
+        assert "17:00:00" in str(expr)
+
+    def test_binary(self):
+        """Test creating binary expressions."""
+        left = Expression.variable("a")
+        right = Expression.variable("b")
+        expr = Expression.binary(BinaryOp.And, left, right)
+        result = str(expr)
+        assert "AND" in result
+        assert "a" in result
+        assert "b" in result
+
+    def test_unary_not(self):
+        """Test creating unary NOT expressions."""
+        operand = Expression.variable("x")
+        expr = Expression.unary(UnaryOp.Not, operand)
+        result = str(expr)
+        assert "NOT" in result
+        assert "x" in result
+
+    def test_unary_negate(self):
+        """Test creating unary negation expressions."""
+        operand = Expression.variable("x")
+        expr = Expression.unary(UnaryOp.Negate, operand)
+        assert "x" in str(expr)
+
+    def test_member_access(self):
+        """Test creating member access expressions."""
+        expr = Expression.member_access("user", "name")
+        result = str(expr)
+        assert "user" in result
+        assert "name" in result
+
+    def test_cast(self):
+        """Test creating cast expressions."""
+        operand = Expression.variable("x")
+        expr = Expression.cast(operand, "Money")
+        result = str(expr)
+        assert "x" in result
+        assert "Money" in result
+
+    def test_quantifier_forall(self):
+        """Test creating ForAll quantifier expressions."""
+        collection = Expression.variable("items")
+        condition = Expression.variable("valid")
+        expr = Expression.quantifier(Quantifier.ForAll, "x", collection, condition)
+        result = str(expr)
+        assert "ForAll" in result or "forall" in result.lower()
+
+    def test_aggregation(self):
+        """Test creating aggregation expressions."""
+        collection = Expression.variable("items")
+        expr = Expression.aggregation(AggregateFunction.Count, collection)
+        result = str(expr)
+        assert "COUNT" in result or "count" in result.lower()
+
+
+class TestNormalization:
+    """Tests for expression normalization."""
+
+    def test_normalize_returns_normalized_expression(self):
+        """Test that normalize() returns a NormalizedExpression."""
+        expr = Expression.variable("x")
+        normalized = expr.normalize()
+        assert isinstance(normalized, NormalizedExpression)
+
+    def test_identity_elimination_and_true(self):
+        """Test that `true AND x` normalizes to `x`."""
+        true_expr = Expression.literal(True)
+        x_expr = Expression.variable("x")
+        expr = Expression.binary(BinaryOp.And, true_expr, x_expr)
+        normalized = expr.normalize()
+        assert str(normalized) == "x"
+
+    def test_identity_elimination_or_false(self):
+        """Test that `false OR x` normalizes to `x`."""
+        false_expr = Expression.literal(False)
+        x_expr = Expression.variable("x")
+        expr = Expression.binary(BinaryOp.Or, false_expr, x_expr)
+        normalized = expr.normalize()
+        assert str(normalized) == "x"
+
+    def test_commutative_sorting(self):
+        """Test that commutative operators sort operands."""
+        b = Expression.variable("b")
+        a = Expression.variable("a")
+        expr = Expression.binary(BinaryOp.And, b, a)
+        normalized = expr.normalize()
+        # After normalization, should be (a AND b)
+        result = str(normalized)
+        assert result == "(a AND b)"
+
+    def test_idempotence(self):
+        """Test that `a AND a` normalizes to `a`."""
+        a = Expression.variable("a")
+        expr = Expression.binary(BinaryOp.And, a, a)
+        normalized = expr.normalize()
+        assert str(normalized) == "a"
+
+    def test_double_negation_elimination(self):
+        """Test that `NOT NOT x` normalizes to `x`."""
+        x = Expression.variable("x")
+        not_x = Expression.unary(UnaryOp.Not, x)
+        not_not_x = Expression.unary(UnaryOp.Not, not_x)
+        normalized = not_not_x.normalize()
+        assert str(normalized) == "x"
+
+
+class TestEquivalence:
+    """Tests for expression equivalence checking."""
+
+    def test_equivalent_expressions(self):
+        """Test that equivalent expressions are recognized as equivalent."""
+        a1 = Expression.variable("a")
+        b1 = Expression.variable("b")
+        expr1 = Expression.binary(BinaryOp.And, a1, b1)
+
+        a2 = Expression.variable("a")
+        b2 = Expression.variable("b")
+        expr2 = Expression.binary(BinaryOp.And, b2, a2)
+
+        assert expr1.is_equivalent(expr2)
+
+    def test_non_equivalent_expressions(self):
+        """Test that non-equivalent expressions are recognized as non-equivalent."""
+        a = Expression.variable("a")
+        b = Expression.variable("b")
+        c = Expression.variable("c")
+
+        expr1 = Expression.binary(BinaryOp.And, a, b)
+        expr2 = Expression.binary(BinaryOp.And, a, c)
+
+        assert not expr1.is_equivalent(expr2)
+
+
+class TestStableHash:
+    """Tests for stable hash functionality."""
+
+    def test_stable_hash_is_deterministic(self):
+        """Test that stable hash is deterministic."""
+        expr = Expression.variable("x")
+        hash1 = expr.normalize().stable_hash()
+        hash2 = expr.normalize().stable_hash()
+        assert hash1 == hash2
+
+    def test_equivalent_expressions_have_same_hash(self):
+        """Test that equivalent expressions have the same hash."""
+        a1 = Expression.variable("a")
+        b1 = Expression.variable("b")
+        expr1 = Expression.binary(BinaryOp.And, a1, b1)
+
+        a2 = Expression.variable("a")
+        b2 = Expression.variable("b")
+        expr2 = Expression.binary(BinaryOp.And, b2, a2)
+
+        assert expr1.normalize().stable_hash() == expr2.normalize().stable_hash()
+
+
+class TestNormalizedExpressionMethods:
+    """Tests for NormalizedExpression methods."""
+
+    def test_inner_expression(self):
+        """Test that inner_expression returns an Expression."""
+        expr = Expression.variable("x")
+        normalized = expr.normalize()
+        inner = normalized.inner_expression()
+        assert isinstance(inner, Expression)
+        assert str(inner) == "x"
+
+    def test_str_representation(self):
+        """Test string representation of NormalizedExpression."""
+        expr = Expression.variable("x")
+        normalized = expr.normalize()
+        assert str(normalized) == "x"
+
+    def test_repr_includes_hash(self):
+        """Test that repr includes hash information."""
+        expr = Expression.variable("x")
+        normalized = expr.normalize()
+        repr_str = repr(normalized)
+        assert "NormalizedExpression" in repr_str
+        assert "hash" in repr_str.lower()
+
+
+class TestWindowSpec:
+    """Tests for WindowSpec."""
+
+    def test_window_spec_creation(self):
+        """Test WindowSpec creation."""
+        ws = WindowSpec(30, "days")
+        assert ws.duration == 30
+        assert ws.unit == "days"
+
+    def test_window_spec_repr(self):
+        """Test WindowSpec repr."""
+        ws = WindowSpec(24, "hours")
+        repr_str = repr(ws)
+        assert "24" in repr_str
+        assert "hours" in repr_str

package/tests/test_golden_payment_flow.py

@@ -0,0 +1,42 @@
+from domainforge import Graph
+
+PAYMENT_DSL = """
+Role "Payer"
+Role "Payee"
+
+Resource "Money" units
+
+Entity "Alice"
+Entity "Bob"
+
+Flow "Money" from "Alice" to "Bob" quantity 10
+
+Relation "Payment"
+  subject: "Payer"
+  predicate: "pays"
+  object: "Payee"
+  via: flow "Money"
+"""
+
+
+def test_payment_flow_parity_from_dsl():
+    graph = Graph.parse(PAYMENT_DSL)
+
+    assert graph.entity_count() == 2
+    assert graph.resource_count() == 1
+    assert graph.flow_count() == 1
+
+    flows = graph.all_flows()
+    assert len(flows) == 1
+    flow = flows[0]
+    # Validate flow quantity and resource name (resource API supported by Python binding)
+    assert flow.quantity == 10
+    alice_id = graph.find_entity_by_name("Alice")
+    bob_id = graph.find_entity_by_name("Bob")
+    assert alice_id is not None
+    assert bob_id is not None
+    assert flow.from_id == alice_id
+    assert flow.to_id == bob_id
+    res = graph.get_resource(flow.resource_id)
+    assert res is not None
+    assert res.name == "Money"

package/tests/test_graph.py

@@ -0,0 +1,127 @@
+import pytest
+import domainforge
+
+
+def test_graph_creation():
+    graph = domainforge.Graph()
+    assert graph.entity_count() == 0
+    assert graph.resource_count() == 0
+    assert graph.flow_count() == 0
+
+
+def test_graph_add_entity():
+    graph = domainforge.Graph()
+    entity = domainforge.Entity("Warehouse")
+    
+    graph.add_entity(entity)
+    assert graph.entity_count() == 1
+    assert graph.has_entity(entity.id)
+
+
+def test_graph_add_resource():
+    graph = domainforge.Graph()
+    resource = domainforge.Resource("Cameras", "units")
+    
+    graph.add_resource(resource)
+    assert graph.resource_count() == 1
+    assert graph.has_resource(resource.id)
+
+
+def test_graph_add_flow():
+    graph = domainforge.Graph()
+    warehouse = domainforge.Entity("Warehouse")
+    factory = domainforge.Entity("Factory")
+    cameras = domainforge.Resource("Cameras", "units")
+    
+    graph.add_entity(warehouse)
+    graph.add_entity(factory)
+    graph.add_resource(cameras)
+    
+    flow = domainforge.Flow(cameras.id, warehouse.id, factory.id, 100.0)
+    graph.add_flow(flow)
+    
+    assert graph.flow_count() == 1
+    assert graph.has_flow(flow.id)
+
+
+def test_graph_flow_validation():
+    graph = domainforge.Graph()
+    warehouse = domainforge.Entity("Warehouse")
+    factory = domainforge.Entity("Factory")
+    cameras = domainforge.Resource("Cameras", "units")
+    
+    graph.add_entity(warehouse)
+    graph.add_resource(cameras)
+    
+    flow = domainforge.Flow(cameras.id, warehouse.id, factory.id, 100.0)
+    
+    with pytest.raises(ValueError, match="Target entity not found"):
+        graph.add_flow(flow)
+
+
+def test_graph_get_entity():
+    graph = domainforge.Graph()
+    entity = domainforge.Entity("Warehouse")
+    graph.add_entity(entity)
+    
+    retrieved = graph.get_entity(entity.id)
+    assert retrieved is not None
+    assert retrieved.id == entity.id
+    assert retrieved.name == entity.name
+
+
+def test_graph_find_entity_by_name():
+    graph = domainforge.Graph()
+    entity = domainforge.Entity("Warehouse")
+    graph.add_entity(entity)
+    
+    found_id = graph.find_entity_by_name("Warehouse")
+    assert found_id == entity.id
+    
+    not_found = graph.find_entity_by_name("Nonexistent")
+    assert not_found is None
+
+
+def test_graph_flows_from():
+    graph = domainforge.Graph()
+    warehouse = domainforge.Entity("Warehouse")
+    factory1 = domainforge.Entity("Factory1")
+    factory2 = domainforge.Entity("Factory2")
+    cameras = domainforge.Resource("Cameras", "units")
+    
+    graph.add_entity(warehouse)
+    graph.add_entity(factory1)
+    graph.add_entity(factory2)
+    graph.add_resource(cameras)
+    
+    flow1 = domainforge.Flow(cameras.id, warehouse.id, factory1.id, 100.0)
+    flow2 = domainforge.Flow(cameras.id, warehouse.id, factory2.id, 50.0)
+    
+    graph.add_flow(flow1)
+    graph.add_flow(flow2)
+    
+    flows = graph.flows_from(warehouse.id)
+    assert len(flows) == 2
+
+
+def test_graph_all_methods():
+    graph = domainforge.Graph()
+    e1 = domainforge.Entity("E1")
+    e2 = domainforge.Entity("E2")
+    r1 = domainforge.Resource("R1", "units")
+    
+    graph.add_entity(e1)
+    graph.add_entity(e2)
+    graph.add_resource(r1)
+    
+    flow = domainforge.Flow(r1.id, e1.id, e2.id, 10.0)
+    graph.add_flow(flow)
+    
+    all_entities = graph.all_entities()
+    assert len(all_entities) == 2
+    
+    all_resources = graph.all_resources()
+    assert len(all_resources) == 1
+    
+    all_flows = graph.all_flows()
+    assert len(all_flows) == 1

package/tests/test_instance.py

@@ -0,0 +1,136 @@
+"""
+Additional Python tests for SEA DSL bindings - ResourceInstance support
+"""
+
+import pytest
+import domainforge
+
+
+def test_instance_creation():
+    """Test creating a ResourceInstance"""
+    entity = domainforge.Entity("Warehouse")
+    resource = domainforge.Resource("Camera", "units")
+
+    instance = domainforge.ResourceInstance(resource.id, entity.id)
+    assert instance.resource_id == resource.id
+    assert instance.entity_id == entity.id
+    assert len(instance.id) == 36
+
+
+def test_instance_with_namespace():
+    """Test creating a ResourceInstance with namespace"""
+    entity = domainforge.Entity("Warehouse", "logistics")
+    resource = domainforge.Resource("Camera", "units", "inventory")
+
+    instance = domainforge.ResourceInstance(resource.id, entity.id, "inventory")
+    assert instance.namespace == "inventory"
+
+
+def test_instance_attributes():
+    """Test ResourceInstance attributes"""
+    entity = domainforge.Entity("Warehouse")
+    resource = domainforge.Resource("Camera", "units")
+
+    instance = domainforge.ResourceInstance(resource.id, entity.id)
+    instance.set_attribute("serial_number", "CAM-12345")
+    assert instance.get_attribute("serial_number") == "CAM-12345"
+
+
+def test_graph_add_instance():
+    """Test adding a ResourceInstance to a Graph"""
+    graph = domainforge.Graph()
+    entity = domainforge.Entity("Warehouse")
+    resource = domainforge.Resource("Camera", "units")
+
+    graph.add_entity(entity)
+    graph.add_resource(resource)
+
+    instance = domainforge.ResourceInstance(resource.id, entity.id)
+    graph.add_instance(instance)
+
+    assert graph.instance_count() == 1
+
+
+def test_graph_instance_validation():
+    """Test Graph validates ResourceInstance references"""
+    graph = domainforge.Graph()
+    entity = domainforge.Entity("Warehouse")
+    resource = domainforge.Resource("Camera", "units")
+
+    graph.add_entity(entity)
+    # Not adding resource
+
+    instance = domainforge.ResourceInstance(resource.id, entity.id)
+
+    with pytest.raises(ValueError, match="Resource not found"):
+        graph.add_instance(instance)
+
+
+def test_round_trip_serialization():
+    """Test that primitives can be serialized and remain valid"""
+    graph = domainforge.Graph()
+
+    # Create a complete model
+    warehouse = domainforge.Entity("Warehouse", "logistics")
+    warehouse.set_attribute("location", "NYC")
+
+    factory = domainforge.Entity("Factory", "manufacturing")
+    factory.set_attribute("capacity", 10000)
+
+    cameras = domainforge.Resource("Camera", "units", "inventory")
+    cameras.set_attribute("model", "X100")
+
+    graph.add_entity(warehouse)
+    graph.add_entity(factory)
+    graph.add_resource(cameras)
+
+    flow = domainforge.Flow(cameras.id, warehouse.id, factory.id, 500.0)
+    flow.set_attribute("priority", "high")
+    graph.add_flow(flow)
+
+    instance = domainforge.ResourceInstance(cameras.id, warehouse.id, "inventory")
+    instance.set_attribute("serial", "SN-001")
+    graph.add_instance(instance)
+
+    # Verify the graph state
+    assert graph.entity_count() == 2
+    assert graph.resource_count() == 1
+    assert graph.flow_count() == 1
+    assert graph.instance_count() == 1
+
+    # Verify we can retrieve and check attributes
+    retrieved_entity = graph.get_entity(warehouse.id)
+    assert retrieved_entity.get_attribute("location") == "NYC"
+
+
+def test_error_handling_invalid_references():
+    """Test that proper errors are raised for invalid references"""
+    graph = domainforge.Graph()
+    warehouse = domainforge.Entity("Warehouse")
+    graph.add_entity(warehouse)
+
+    # Try to create flow with non-existent IDs
+    fake_resource_id = "00000000-0000-0000-0000-000000000000"
+    fake_entity_id = "11111111-1111-1111-1111-111111111111"
+
+    flow = domainforge.Flow(fake_resource_id, warehouse.id, fake_entity_id, 100.0)
+
+    with pytest.raises(ValueError):
+        graph.add_flow(flow)
+
+
+def test_namespace_isolation():
+    """Test that namespaces properly isolate entities"""
+    graph = domainforge.Graph()
+
+    warehouse_logistics = domainforge.Entity("Warehouse", "logistics")
+    warehouse_storage = domainforge.Entity("Warehouse", "storage")
+
+    graph.add_entity(warehouse_logistics)
+    graph.add_entity(warehouse_storage)
+
+    assert graph.entity_count() == 2
+
+    # Both should exist independently
+    assert graph.has_entity(warehouse_logistics.id)
+    assert graph.has_entity(warehouse_storage.id)

package/tests/test_parser.py

@@ -0,0 +1,82 @@
+import pytest
+import domainforge
+
+
+def test_parse_basic():
+    source = '''
+        Entity "Warehouse" in logistics
+        Entity "Factory" in logistics
+        Resource "Cameras" units
+    '''
+    
+    graph = domainforge.Graph.parse(source)
+    assert graph.entity_count() == 2
+    assert graph.resource_count() == 1
+
+
+def test_parse_with_flow():
+    source = '''
+        Entity "Warehouse"
+        Entity "Factory"
+        Resource "Cameras" units
+        Flow "Cameras" from "Warehouse" to "Factory" quantity 100
+    '''
+    
+    graph = domainforge.Graph.parse(source)
+    assert graph.entity_count() == 2
+    assert graph.resource_count() == 1
+    assert graph.flow_count() == 1
+
+
+def test_parse_complex():
+    source = '''
+        Entity "Supplier" in supply_chain
+        Entity "Warehouse" in supply_chain
+        Entity "Store" in retail
+        
+        Resource "Widgets" units
+        Resource "Gadgets" units
+        
+        Flow "Widgets" from "Supplier" to "Warehouse" quantity 500
+        Flow "Widgets" from "Warehouse" to "Store" quantity 300
+        Flow "Gadgets" from "Supplier" to "Warehouse" quantity 200
+    '''
+    
+    graph = domainforge.Graph.parse(source)
+    assert graph.entity_count() == 3
+    assert graph.resource_count() == 2
+    assert graph.flow_count() == 3
+
+
+def test_parse_invalid_syntax():
+    source = '''
+        Entity "Warehouse"
+        Invalid syntax here
+    '''
+    
+    with pytest.raises(ValueError, match="Parse error"):
+        domainforge.Graph.parse(source)
+
+
+def test_parse_empty():
+    source = ""
+    graph = domainforge.Graph.parse(source)
+    assert graph.entity_count() == 0
+
+
+def test_parsed_graph_query():
+    source = '''
+        Entity "Warehouse"
+        Entity "Factory"
+        Resource "Steel" tons
+        Flow "Steel" from "Warehouse" to "Factory" quantity 50
+    '''
+    
+    graph = domainforge.Graph.parse(source)
+    
+    warehouse_id = graph.find_entity_by_name("Warehouse")
+    assert warehouse_id is not None
+    
+    flows = graph.flows_from(warehouse_id)
+    assert len(flows) == 1
+    assert flows[0].quantity == 50.0