test(model,ir,mapping,rules): handle nested container ids in validator and add v2 coverage

- Fix validator to compare local container id against dot-qualified nested ids
- Add IR serialization backward-compat tests for v1 snapshots and v2 fields
- Add enrichment tests for v2 nested containers, service/kind propagation, and unmatched nodes
- Add v2 loader/resolver/validator tests (versioning, kinds, nested containers, relations)
- Add built-in rule field access tests for new node/edge service and kind fields

Author: akhundMurad

pacta/model/validator.py

@@ -142,7 +142,9 @@ def _validate_container(
                     details={"container_id": cid},
                 )
             )
-        if c.id != cid:
+        # For nested containers, cid is dot-qualified (e.g. "svc.mod") but c.id is the local id ("mod")
+        expected_local_id = cid.rsplit(".", 1)[-1]
+        if c.id != expected_local_id:
             errors.append(
                 EngineError(
                     type="config_error",

tests/ir/test_serialization.py

@@ -0,0 +1,102 @@
+"""Tests for IR serialization backward compatibility (v1 snapshots with v2 code)."""
+
+from pacta.ir.types import (
+    CanonicalId,
+    DepType,
+    IREdge,
+    IRNode,
+    Language,
+    SymbolKind,
+)
+
+
+def cid(fqname: str) -> CanonicalId:
+    return CanonicalId(language=Language.PYTHON, code_root="repo", fqname=fqname)
+
+
+def test_node_from_dict_without_v2_fields():
+    """v1 snapshot data (no service, container_kind) deserializes with None defaults."""
+    data = {
+        "id": {"language": "python", "code_root": "repo", "fqname": "a.b"},
+        "kind": "module",
+        "name": "b",
+        "path": "a/b.py",
+        "loc": None,
+        "container": "svc",
+        "layer": "domain",
+        "context": "billing",
+        "tags": ["internal"],
+        "attributes": {},
+    }
+    node = IRNode.from_dict(data)
+    assert node.container == "svc"
+    assert node.service is None
+    assert node.container_kind is None
+
+
+def test_node_roundtrip_with_v2_fields():
+    """v2 node serializes and deserializes with new fields."""
+    node = IRNode(
+        id=cid("a.b"),
+        kind=SymbolKind.MODULE,
+        name="b",
+        path="a/b.py",
+        container="billing-service.invoice-module",
+        layer="domain",
+        context="billing",
+        service="billing-service",
+        container_kind="module",
+    )
+    data = node.to_dict()
+    assert data["service"] == "billing-service"
+    assert data["container_kind"] == "module"
+
+    restored = IRNode.from_dict(data)
+    assert restored.service == "billing-service"
+    assert restored.container_kind == "module"
+
+
+def test_edge_from_dict_without_v2_fields():
+    """v1 snapshot edge data deserializes with None for new fields."""
+    data = {
+        "src": {"language": "python", "code_root": "repo", "fqname": "a"},
+        "dst": {"language": "python", "code_root": "repo", "fqname": "b"},
+        "dep_type": "import",
+        "loc": None,
+        "confidence": 1.0,
+        "details": {},
+        "src_container": "svc",
+        "src_layer": "domain",
+        "src_context": "billing",
+        "dst_container": "svc",
+        "dst_layer": "infra",
+        "dst_context": "billing",
+    }
+    edge = IREdge.from_dict(data)
+    assert edge.src_container == "svc"
+    assert edge.src_service is None
+    assert edge.dst_service is None
+    assert edge.src_container_kind is None
+    assert edge.dst_container_kind is None
+
+
+def test_edge_roundtrip_with_v2_fields():
+    """v2 edge serializes and deserializes with new fields."""
+    edge = IREdge(
+        src=cid("a"),
+        dst=cid("b"),
+        dep_type=DepType.IMPORT,
+        src_service="billing-service",
+        dst_service="shared-utils",
+        src_container_kind="service",
+        dst_container_kind="library",
+    )
+    data = edge.to_dict()
+    assert data["src_service"] == "billing-service"
+    assert data["dst_container_kind"] == "library"
+
+    restored = IREdge.from_dict(data)
+    assert restored.src_service == "billing-service"
+    assert restored.dst_service == "shared-utils"
+    assert restored.src_container_kind == "service"
+    assert restored.dst_container_kind == "library"

tests/mapping/test_enricher.py

@@ -13,6 +13,7 @@
     ArchitectureModel,
     CodeMapping,
     Container,
+    ContainerKind,
     Context,
     Layer,
 )
@@ -637,3 +638,181 @@ def test_enricher_exact_root_match():
 
     # node3: prefix but not subdirectory - should NOT match
     assert enriched.nodes[2].container is None
+
+
+# ----------------------------
+# v2: Nested container enrichment
+# ----------------------------
+
+
+def build_v2_test_model() -> ArchitectureModel:
+    """Build a v2 model with nested containers for enrichment tests."""
+    contexts = {
+        "billing": Context(id="billing", name="Billing Context"),
+    }
+    containers = {
+        "billing-service": Container(
+            id="billing-service",
+            kind=ContainerKind.SERVICE,
+            context="billing",
+            code=CodeMapping(
+                roots=("services/billing",),
+                layers={
+                    "api": Layer(id="api", patterns=("services/billing/api/**",)),
+                    "domain": Layer(id="domain", patterns=("services/billing/domain/**",)),
+                },
+            ),
+            tags=("critical",),
+            children={
+                "invoice-module": Container(
+                    id="invoice-module",
+                    kind=ContainerKind.MODULE,
+                    code=CodeMapping(
+                        roots=("services/billing/domain/invoice",),
+                        layers={
+                            "model": Layer(id="model", patterns=("services/billing/domain/invoice/model/**",)),
+                            "repo": Layer(id="repo", patterns=("services/billing/domain/invoice/repo/**",)),
+                        },
+                    ),
+                ),
+            },
+        ),
+        "shared-utils": Container(
+            id="shared-utils",
+            kind=ContainerKind.LIBRARY,
+            code=CodeMapping(
+                roots=("libs/shared",),
+                layers={},
+            ),
+        ),
+    }
+    model = ArchitectureModel(
+        version=2,
+        contexts=contexts,
+        containers=containers,
+        relations=(),
+        metadata={},
+    )
+    return DefaultModelResolver().resolve(model)
+
+
+def test_enricher_v2_nested_container_deepest_match():
+    """Nested container with more specific root wins over parent."""
+    model = build_v2_test_model()
+
+    node = IRNode(
+        id=CanonicalId(language=Language.PYTHON, code_root="billing", fqname="invoice.model.entity"),
+        kind=SymbolKind.MODULE,
+        path="services/billing/domain/invoice/model/entity.py",
+    )
+    ir = ArchitectureIR(
+        schema_version=2, produced_by="test", repo_root="/test",
+        nodes=(node,), edges=(), metadata={},
+    )
+
+    enriched = DefaultArchitectureEnricher().enrich(ir, model)
+    n = enriched.nodes[0]
+
+    # Should match the nested container (longer root)
+    assert n.container == "billing-service.invoice-module"
+    assert n.layer == "model"
+    assert n.context == "billing"  # inherited from parent
+    assert n.service == "billing-service"
+    assert n.container_kind == "module"
+
+
+def test_enricher_v2_parent_container_match():
+    """Node under parent root but not nested child root matches parent."""
+    model = build_v2_test_model()
+
+    node = IRNode(
+        id=CanonicalId(language=Language.PYTHON, code_root="billing", fqname="billing.api.routes"),
+        kind=SymbolKind.MODULE,
+        path="services/billing/api/routes.py",
+    )
+    ir = ArchitectureIR(
+        schema_version=2, produced_by="test", repo_root="/test",
+        nodes=(node,), edges=(), metadata={},
+    )
+
+    enriched = DefaultArchitectureEnricher().enrich(ir, model)
+    n = enriched.nodes[0]
+
+    assert n.container == "billing-service"
+    assert n.layer == "api"
+    assert n.service == "billing-service"
+    assert n.container_kind == "service"
+
+
+def test_enricher_v2_library_container():
+    """Library container sets container_kind correctly."""
+    model = build_v2_test_model()
+
+    node = IRNode(
+        id=CanonicalId(language=Language.PYTHON, code_root="shared", fqname="libs.shared.util"),
+        kind=SymbolKind.MODULE,
+        path="libs/shared/util.py",
+    )
+    ir = ArchitectureIR(
+        schema_version=2, produced_by="test", repo_root="/test",
+        nodes=(node,), edges=(), metadata={},
+    )
+
+    enriched = DefaultArchitectureEnricher().enrich(ir, model)
+    n = enriched.nodes[0]
+
+    assert n.container == "shared-utils"
+    assert n.service == "shared-utils"
+    assert n.container_kind == "library"
+
+
+def test_enricher_v2_edge_service_and_kind():
+    """Edges get src/dst service and container_kind from enriched nodes."""
+    model = build_v2_test_model()
+
+    src_node = IRNode(
+        id=CanonicalId(language=Language.PYTHON, code_root="billing", fqname="billing.api.routes"),
+        kind=SymbolKind.MODULE,
+        path="services/billing/api/routes.py",
+    )
+    dst_node = IRNode(
+        id=CanonicalId(language=Language.PYTHON, code_root="shared", fqname="libs.shared.util"),
+        kind=SymbolKind.MODULE,
+        path="libs/shared/util.py",
+    )
+    edge = IREdge(src=src_node.id, dst=dst_node.id, dep_type=DepType.IMPORT)
+
+    ir = ArchitectureIR(
+        schema_version=2, produced_by="test", repo_root="/test",
+        nodes=(src_node, dst_node), edges=(edge,), metadata={},
+    )
+
+    enriched = DefaultArchitectureEnricher().enrich(ir, model)
+    e = enriched.edges[0]
+
+    assert e.src_service == "billing-service"
+    assert e.src_container_kind == "service"
+    assert e.dst_service == "shared-utils"
+    assert e.dst_container_kind == "library"
+
+
+def test_enricher_v2_unmatched_node_has_no_service():
+    """Nodes that don't match any container have None for service/container_kind."""
+    model = build_v2_test_model()
+
+    node = IRNode(
+        id=CanonicalId(language=Language.PYTHON, code_root="other", fqname="lib.utils"),
+        kind=SymbolKind.MODULE,
+        path="other/utils.py",
+    )
+    ir = ArchitectureIR(
+        schema_version=2, produced_by="test", repo_root="/test",
+        nodes=(node,), edges=(), metadata={},
+    )
+
+    enriched = DefaultArchitectureEnricher().enrich(ir, model)
+    n = enriched.nodes[0]
+
+    assert n.container is None
+    assert n.service is None
+    assert n.container_kind is None