buildzr 0.0.18__tar.gz → 0.0.20__tar.gz

{buildzr-0.0.18 → buildzr-0.0.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: buildzr
-Version: 0.0.18
+Version: 0.0.20
 Summary: Structurizr for the `buildzr`s 🧱⚒️
 Project-URL: homepage, https://github.com/amirulmenjeni/buildzr
 Project-URL: issues, https://github.com/amirulmenjeni/buildzr/issues

buildzr-0.0.20/buildzr/__about__.py

@@ -0,0 +1 @@
+VERSION = "0.0.20"

{buildzr-0.0.18 → buildzr-0.0.20}/buildzr/dsl/dsl.py

@@ -129,14 +129,14 @@ class Workspace(DslWorkspaceElement):
 
         _current_workspace.reset(self._token)
 
-    def _imply_relationships(
-        self,
+    def _imply_relationships( self,
     ) -> None:
 
         """
         Process implied relationships:
         If we have relationship s >> do >> a.b, then create s >> do >> a.
         If we have relationship s.ss >> do >> a.b.c, then create s.ss >> do >> a.b and s.ss >> do >> a.
+        If we have relationship s.ss >> do >> a, then create s >> do >> a.
         And so on...
 
         Relationships of `SoftwareSystemInstance`s and `ContainerInstance`s are
@@ -152,6 +152,7 @@ class Workspace(DslWorkspaceElement):
         from buildzr.dsl.explorer import Explorer
 
         explorer = Explorer(self)
+        # Take a snapshot of relationships to avoid processing newly created ones
         relationships = list(explorer.walk_relationships())
         for relationship in relationships:
             source = relationship.source
@@ -162,6 +163,11 @@ class Workspace(DslWorkspaceElement):
                isinstance(destination, (SoftwareSystemInstance, ContainerInstance)):
                 continue
 
+            # Skip relationships that are already implied (have linkedRelationshipId)
+            if relationship.model.linkedRelationshipId is not None:
+                continue
+
+            # Handle case: s >> a.b => s >> a (destination is child)
             while destination_parent is not None and \
                 isinstance(source, DslElement) and \
                 not isinstance(source.model, buildzr.models.Workspace) and \
@@ -186,7 +192,38 @@ class Workspace(DslWorkspaceElement):
                             technology=relationship.model.technology,
                         )
                         r.model.linkedRelationshipId = relationship.model.id
-                    destination_parent = destination_parent.parent
+                destination_parent = destination_parent.parent
+
+            # Handle inverse case: s.ss >> a => s >> a (source is child)
+            source_parent = source.parent
+            while source_parent is not None and \
+                isinstance(destination, DslElement) and \
+                not isinstance(destination.model, buildzr.models.Workspace) and \
+                not isinstance(source_parent.model, buildzr.models.Workspace) and \
+                not isinstance(source_parent, DslWorkspaceElement):
+
+                if source_parent is destination.parent:
+                    break
+
+                rels = source_parent.model.relationships
+
+                # The parent source relationship might be empty
+                # (i.e., []).
+                if rels is not None:
+                    already_exists = any(
+                        r.destinationId == destination.model.id and
+                        r.description == relationship.model.description and
+                        r.technology == relationship.model.technology
+                        for r in rels
+                    )
+                    if not already_exists:
+                        r = source_parent.uses(
+                            destination,
+                            description=relationship.model.description,
+                            technology=relationship.model.technology,
+                        )
+                        r.model.linkedRelationshipId = relationship.model.id
+                source_parent = source_parent.parent
 
     def person(self) -> TypedDynamicAttribute['Person']:
         return TypedDynamicAttribute['Person'](self._dynamic_attrs)
@@ -371,6 +408,7 @@ class SoftwareSystem(DslElementRelationOverrides[
         self.model.id = GenerateId.for_element()
         self.model.name = name
         self.model.description = description
+        self.model.relationships = []
         self.model.tags = ','.join(self._tags)
         self.model.properties = properties
 
@@ -804,6 +842,10 @@ class DeploymentEnvironment(DslDeploymentEnvironment):
         new relationship between those software system instances.
 
         These implied relationships are used in `DeploymentView`.
+
+        Relationships are only created between instances that share at least
+        one common deployment group. If no deployment groups are specified,
+        instances are considered to be in the same default group.
         """
 
         software_instances = [
@@ -839,12 +881,25 @@ class DeploymentEnvironment(DslDeploymentEnvironment):
                 if not relationship.destinationId in other_softwares_ids:
                     continue
 
+                if software.model.id not in software_instance_map:
+                    continue
+
+                if relationship.destinationId not in software_instance_map:
+                    continue
+
                 this_software_instances = software_instance_map[software.model.id]
                 other_software_instances = software_instance_map[relationship.destinationId]
 
                 for this_software_instance in this_software_instances:
                     for other_software_instance in other_software_instances:
 
+                        # Only create relationship if instances share a deployment group
+                        if not self._instances_share_deployment_group(
+                            this_software_instance,
+                            other_software_instance
+                        ):
+                            continue
+
                         already_exists = this_software_instance.model.relationships is not None and any(
                             r.sourceId == this_software_instance.model.id and
                             r.destinationId == other_software_instance.model.id and
@@ -862,6 +917,40 @@ class DeploymentEnvironment(DslDeploymentEnvironment):
                             )
                             r.model.linkedRelationshipId = relationship.id
 
+    def _instances_share_deployment_group(
+        self,
+        instance1: Union['ContainerInstance', 'SoftwareSystemInstance'],
+        instance2: Union['ContainerInstance', 'SoftwareSystemInstance']
+    ) -> bool:
+        """
+        Check if two deployment instances share at least one common deployment group.
+
+        If either instance has no deployment groups specified, they are considered
+        to be in the "default" group and can relate to all other instances without
+        deployment groups.
+
+        Args:
+            instance1: First deployment instance
+            instance2: Second deployment instance
+
+        Returns:
+            True if instances share at least one deployment group or if both have
+            no deployment groups specified, False otherwise.
+        """
+        groups1 = set(instance1.model.deploymentGroups or [])
+        groups2 = set(instance2.model.deploymentGroups or [])
+
+        # If both have no deployment groups, they can relate
+        if not groups1 and not groups2:
+            return True
+
+        # If one has groups and the other doesn't, they cannot relate
+        if (groups1 and not groups2) or (not groups1 and groups2):
+            return False
+
+        # Check if they share at least one common group
+        return bool(groups1.intersection(groups2))
+
     def _imply_container_instance_relationships(self, workspace: Workspace) -> None:
 
         """
@@ -871,6 +960,10 @@ class DeploymentEnvironment(DslDeploymentEnvironment):
         between those container instances.
 
         These implied relationships are used in `DeploymentView`.
+
+        Relationships are only created between instances that share at least
+        one common deployment group. If no deployment groups are specified,
+        instances are considered to be in the same default group.
         """
 
         from buildzr.dsl.expression import Expression
@@ -907,12 +1000,25 @@ class DeploymentEnvironment(DslDeploymentEnvironment):
                 if not relationship.destinationId in other_containers_ids:
                     continue
 
+                if container.model.id not in container_instance_map:
+                    continue
+
+                if relationship.destinationId not in container_instance_map:
+                    continue
+
                 this_container_instances = container_instance_map[container.model.id]
                 other_container_instances = container_instance_map[relationship.destinationId]
 
                 for this_container_instance in this_container_instances:
                     for other_container_instance in other_container_instances:
 
+                        # Only create relationship if instances share a deployment group
+                        if not self._instances_share_deployment_group(
+                            this_container_instance,
+                            other_container_instance
+                        ):
+                            continue
+
                         already_exists = this_container_instance.model.relationships is not None and any(
                             r.sourceId == this_container_instance.model.id and
                             r.destinationId == other_container_instance.model.id and

{buildzr-0.0.18 → buildzr-0.0.20}/tests/test_dsl.py

@@ -399,6 +399,49 @@ def test_implied_relationship() -> Optional[None]:
     os.remove('workspace.test.json')
     os.remove('workspace2.test.json')
 
+def test_inverse_implied_relationship() -> Optional[None]:
+    """
+    Test that inverse implied relationships work correctly.
+    When a.container >> b (child to parent), it should imply a >> b.
+
+    See: https://docs.structurizr.com/java/implied-relationships
+    """
+
+    with Workspace("w", implied_relationships=True) as w:
+        u = Person('User')
+        s = SoftwareSystem('System')
+        with s:
+            api = Container('API')
+            db = Container('Database')
+            api >> "Uses" >> db
+
+        # Create relationship from child to parent: s.api >> u
+        # This should imply s >> u
+        s.api >> "Notifies" >> u
+
+        # Invoke implied relationships via view
+        SystemContextView(
+            software_system_selector=s,
+            key='s_context',
+            description="System context view",
+        )
+
+        w.to_json('workspace.inverse.test.json')
+
+    # Check that System has an implied relationship to User
+    assert len(s.model.relationships) == 1
+    assert s.model.relationships[0].description == "Notifies"
+    assert s.model.relationships[0].sourceId == s.model.id
+    assert s.model.relationships[0].destinationId == u.model.id
+    assert s.model.relationships[0].linkedRelationshipId == s.api.model.relationships[1].id
+
+    # The implied relationship should appear in system context view
+    system_context_view_relationships = [x.id for x in w._m.views.systemContextViews[0].relationships]
+    assert s.model.relationships[0].id in system_context_view_relationships
+
+    import os
+    os.remove('workspace.inverse.test.json')
+
 def test_tags_on_elements() -> Optional[None]:
 
     u = Person('My User', tags={'admin'})
@@ -1105,6 +1148,7 @@ def test_json_sink_empty_views() -> Optional[None]:
 
     import os
     os.remove("test.json")
+
 def test_deployment_instance_relationships_with_implied_relationships() -> Optional[None]:
     """
     Test that deployment instance relationships are created correctly when
@@ -1183,3 +1227,366 @@ def test_deployment_instance_relationships_with_implied_relationships() -> Optio
     import os
     os.remove('test_deployment1.json')
     os.remove('test_deployment2.json')
+
+def test_imply_relationships_before_deployment_environment_not_crashing() -> Optional[None]:
+
+    with Workspace('workspace') as w:
+
+        with SoftwareSystem("X") as x:
+
+            # Notice that we don't need to specify the tags "Application" and "Database"
+            # for styling -- just pass the `wa` and `db` variables directly to the `StyleElements` class.
+            wa = Container("Web Application", technology="Java and Spring boot")
+            db = Container("Database Schema")
+
+            wa >> "Reads from and writes to" >> db
+
+        with DeploymentEnvironment("Live") as live:
+            with DeploymentNode("Amazon Web Services") as aws:
+                aws.add_tags("Amazon Web Services - Cloud")
+
+                with DeploymentNode("US-East-1") as region:
+                    region.add_tags("Amazon Web Services - Region")
+
+                    dns = InfrastructureNode(
+                        "DNS Router",
+                        description="Routes incoming requests based upon domain name.",
+                        technology="Route 53",
+                        tags={"Amazon Web Services - Route 53"}
+                    )
+
+                    lb = InfrastructureNode(
+                        "Load Balancer",
+                        description="Automatically distributes incoming application traffic.",
+                        technology="Elastic Load Balancer",
+                        tags={"Amazon Web Services - Elastic Load Balancer"}
+                    )
+
+                    dns >> ("Fowards requests to", "HTTP") >> lb
+
+                    with DeploymentNode("Amazon EC2", tags={"Amazon Web Services - EC2"}) as asg:
+                        with DeploymentNode("Amazon EC2 - Ubuntu Server", tags={"Amazon Web Services - EC2 Instance"}):
+                            lb >> "Forwards requests to" >> ContainerInstance(wa)
+
+                    with DeploymentNode("Amazon RDS", tags={"Amazon Web Services - RDS Instance"}) as rds:
+                        with DeploymentNode("MySQL", tags={"Amazon Web Services - RDS MySQL instance"}):
+                            database_instance = ContainerInstance(db)
+
+        DeploymentView(
+            environment=live,
+            key='aws-deployment-view',
+            software_system_selector=x,
+            title="Amazon Web Services Deployment",
+            description="Deployment view of the web application on AWS",
+            auto_layout='lr',
+        )
+
+        w.to_json('amazon_web_services.json', pretty=True)
+
+def test_software_system_instance_relationships_with_missing_instances() -> Optional[None]:
+    """
+    Test that _imply_software_system_instance_relationships doesn't crash when
+    a software system has a relationship to another software system, but only
+    one of them has instances deployed.
+
+    This reproduces the bug where:
+    - E-Commerce System has instances deployed
+    - Payment Provider has NO instances deployed
+    - E-Commerce System -> Payment Provider relationship exists
+    - Should not crash with KeyError when trying to look up Payment Provider instances
+    """
+
+    with Workspace('test-workspace') as w:
+        # Create two software systems with a relationship
+        ecommerce = SoftwareSystem('E-Commerce System')
+        payment_provider = SoftwareSystem('Payment Provider')
+
+        ecommerce >> "Processes payments via" >> payment_provider
+
+        # Deploy only the E-Commerce System, NOT the Payment Provider
+        with DeploymentEnvironment('Production') as prod:
+            with DeploymentNode('AWS'):
+                ecommerce_instance = SoftwareSystemInstance(ecommerce)
+
+        # This should not crash - the implication happens in DeploymentEnvironment.__exit__
+        # Even though ecommerce has a relationship to payment_provider,
+        # payment_provider has no instances deployed
+
+    # If we get here without a KeyError, the test passes
+    assert ecommerce_instance.model.softwareSystemId == ecommerce.model.id
+
+def test_container_instance_relationships_with_missing_instances() -> Optional[None]:
+    """
+    Test that _imply_container_instance_relationships doesn't crash when
+    a container has a relationship to another container, but only one of
+    them has instances deployed.
+
+    This tests the same bug pattern but for containers instead of software systems.
+    """
+
+    with Workspace('test-workspace') as w:
+        # Create software system with containers that have relationships
+        with SoftwareSystem('E-Commerce System') as ecommerce:
+            web_app = Container('Web Application')
+            api = Container('API')
+            database = Container('Database')
+            external_service = Container('External Payment Service')
+
+            # Create relationships
+            web_app >> "Calls" >> api
+            api >> "Stores data in" >> database
+            api >> "Processes payments via" >> external_service
+
+        # Deploy only some containers, NOT all of them
+        with DeploymentEnvironment('Production') as prod:
+            with DeploymentNode('AWS'):
+                web_app_instance = ContainerInstance(web_app)
+                api_instance = ContainerInstance(api)
+                db_instance = ContainerInstance(database)
+                # Note: external_service is NOT deployed
+
+        # This should not crash - even though api has a relationship to external_service,
+        # external_service has no instances deployed
+
+    # If we get here without a KeyError, the test passes
+    assert web_app_instance.model.containerId == web_app.model.id
+    assert api_instance.model.containerId == api.model.id
+    assert db_instance.model.containerId == database.model.id
+
+    # Verify that the deployed instances DO have implied relationships
+    # web_app_instance should have relationship to api_instance
+    web_to_api_rels = [
+        r for r in (web_app_instance.model.relationships or [])
+        if r.destinationId == api_instance.model.id
+    ]
+    assert len(web_to_api_rels) == 1
+
+    # api_instance should have relationship to db_instance
+    api_to_db_rels = [
+        r for r in (api_instance.model.relationships or [])
+        if r.destinationId == db_instance.model.id
+    ]
+    assert len(api_to_db_rels) == 1
+
+    # But api_instance should NOT have a relationship to external_service
+    # (because it wasn't deployed)
+    all_api_destinations = [
+        r.destinationId for r in (api_instance.model.relationships or [])
+    ]
+    assert external_service.model.id not in all_api_destinations
+
+def test_container_instance_relationships_respect_deployment_groups() -> Optional[None]:
+    """
+    Test that container instance relationships only connect instances within
+    the same deployment group.
+
+    When containers have relationships and are deployed with deployment groups,
+    instance relationships should only be created between instances that share
+    at least one common deployment group.
+
+    This matches the behavior in Structurizr DSL where deployment groups act
+    as boundaries for relationship propagation.
+    """
+
+    with Workspace("w", scope=None) as w:
+        with SoftwareSystem("Software System") as software_system:
+            database = Container("Database")
+            api = Container("Service API")
+            api >> "Reads from and writes to" >> database
+
+        with DeploymentEnvironment("Production") as production:
+            service_instance_1 = DeploymentGroup("Service Instance 1")
+            service_instance_2 = DeploymentGroup("Service Instance 2")
+
+            with DeploymentNode("Server 1") as server_1:
+                api_instance_1 = ContainerInstance(api, [service_instance_1])
+                with DeploymentNode("Database Server"):
+                    db_instance_1 = ContainerInstance(database, [service_instance_1])
+
+            with DeploymentNode("Server 2") as server_2:
+                api_instance_2 = ContainerInstance(api, [service_instance_2])
+                with DeploymentNode("Database Server"):
+                    db_instance_2 = ContainerInstance(database, [service_instance_2])
+
+    # Verify deployment group assignments
+    assert api_instance_1.model.deploymentGroups == ["Service Instance 1"]
+    assert db_instance_1.model.deploymentGroups == ["Service Instance 1"]
+    assert api_instance_2.model.deploymentGroups == ["Service Instance 2"]
+    assert db_instance_2.model.deploymentGroups == ["Service Instance 2"]
+
+    # Check that api_instance_1 only has relationship to db_instance_1 (same group)
+    api_1_relationships = [
+        r for r in (api_instance_1.model.relationships or [])
+        if r.description == "Reads from and writes to"
+    ]
+    assert len(api_1_relationships) == 1, f"Expected 1 relationship, found {len(api_1_relationships)}"
+    assert api_1_relationships[0].destinationId == db_instance_1.model.id
+    assert api_1_relationships[0].destinationId != db_instance_2.model.id
+
+    # Check that api_instance_2 only has relationship to db_instance_2 (same group)
+    api_2_relationships = [
+        r for r in (api_instance_2.model.relationships or [])
+        if r.description == "Reads from and writes to"
+    ]
+    assert len(api_2_relationships) == 1, f"Expected 1 relationship, found {len(api_2_relationships)}"
+    assert api_2_relationships[0].destinationId == db_instance_2.model.id
+    assert api_2_relationships[0].destinationId != db_instance_1.model.id
+
+    # Verify no cross-group relationships exist
+    all_api_1_destinations = [r.destinationId for r in (api_instance_1.model.relationships or [])]
+    all_api_2_destinations = [r.destinationId for r in (api_instance_2.model.relationships or [])]
+
+    assert db_instance_2.model.id not in all_api_1_destinations, "api_instance_1 should not connect to db_instance_2"
+    assert db_instance_1.model.id not in all_api_2_destinations, "api_instance_2 should not connect to db_instance_1"
+
+def test_software_system_instance_relationships_respect_deployment_groups() -> Optional[None]:
+    """
+    Test that software system instance relationships only connect instances
+    within the same deployment group.
+
+    When software systems have relationships and are deployed with deployment
+    groups, instance relationships should only be created between instances
+    that share at least one common deployment group.
+    """
+
+    with Workspace("w", scope=None) as w:
+        api_system = SoftwareSystem("API System")
+        db_system = SoftwareSystem("Database System")
+
+        api_system >> "Connects to" >> db_system
+
+        with DeploymentEnvironment("Production") as production:
+            region_1 = DeploymentGroup("Region 1")
+            region_2 = DeploymentGroup("Region 2")
+
+            with DeploymentNode("Datacenter 1") as dc1:
+                api_instance_1 = SoftwareSystemInstance(api_system, [region_1])
+                db_instance_1 = SoftwareSystemInstance(db_system, [region_1])
+
+            with DeploymentNode("Datacenter 2") as dc2:
+                api_instance_2 = SoftwareSystemInstance(api_system, [region_2])
+                db_instance_2 = SoftwareSystemInstance(db_system, [region_2])
+
+    # Verify deployment group assignments
+    assert api_instance_1.model.deploymentGroups == ["Region 1"]
+    assert db_instance_1.model.deploymentGroups == ["Region 1"]
+    assert api_instance_2.model.deploymentGroups == ["Region 2"]
+    assert db_instance_2.model.deploymentGroups == ["Region 2"]
+
+    # Check that api_instance_1 only has relationship to db_instance_1 (same group)
+    api_1_relationships = [
+        r for r in (api_instance_1.model.relationships or [])
+        if r.description == "Connects to"
+    ]
+    assert len(api_1_relationships) == 1, f"Expected 1 relationship, found {len(api_1_relationships)}"
+    assert api_1_relationships[0].destinationId == db_instance_1.model.id
+    assert api_1_relationships[0].destinationId != db_instance_2.model.id
+
+    # Check that api_instance_2 only has relationship to db_instance_2 (same group)
+    api_2_relationships = [
+        r for r in (api_instance_2.model.relationships or [])
+        if r.description == "Connects to"
+    ]
+    assert len(api_2_relationships) == 1, f"Expected 1 relationship, found {len(api_2_relationships)}"
+    assert api_2_relationships[0].destinationId == db_instance_2.model.id
+    assert api_2_relationships[0].destinationId != db_instance_1.model.id
+
+    # Verify no cross-group relationships exist
+    all_api_1_destinations = [r.destinationId for r in (api_instance_1.model.relationships or [])]
+    all_api_2_destinations = [r.destinationId for r in (api_instance_2.model.relationships or [])]
+
+    assert db_instance_2.model.id not in all_api_1_destinations, "api_instance_1 should not connect to db_instance_2"
+    assert db_instance_1.model.id not in all_api_2_destinations, "api_instance_2 should not connect to db_instance_1"
+
+def test_container_instance_relationships_with_multiple_shared_deployment_groups() -> Optional[None]:
+    """
+    Test that container instances with overlapping deployment groups can have
+    relationships.
+
+    If two container instances share at least one deployment group, they should
+    be able to have relationships even if they belong to other groups as well.
+    """
+
+    with Workspace("w", scope=None) as w:
+        with SoftwareSystem("Software System") as software_system:
+            frontend = Container("Frontend")
+            backend = Container("Backend")
+            frontend >> "Calls" >> backend
+
+        with DeploymentEnvironment("Production") as production:
+            group_a = DeploymentGroup("Group A")
+            group_b = DeploymentGroup("Group B")
+            group_shared = DeploymentGroup("Shared Group")
+
+            with DeploymentNode("Server 1"):
+                # Frontend in Group A and Shared Group
+                frontend_instance = ContainerInstance(frontend, [group_a, group_shared])
+
+            with DeploymentNode("Server 2"):
+                # Backend in Group B and Shared Group
+                backend_instance = ContainerInstance(backend, [group_b, group_shared])
+
+    # Verify deployment group assignments
+    assert set(frontend_instance.model.deploymentGroups) == {"Group A", "Shared Group"}
+    assert set(backend_instance.model.deploymentGroups) == {"Group B", "Shared Group"}
+
+    # Frontend and backend share "Shared Group", so relationship should exist
+    frontend_relationships = [
+        r for r in (frontend_instance.model.relationships or [])
+        if r.description == "Calls"
+    ]
+    assert len(frontend_relationships) == 1, f"Expected 1 relationship, found {len(frontend_relationships)}"
+    assert frontend_relationships[0].destinationId == backend_instance.model.id
+
+def test_container_instance_relationships_with_no_deployment_groups() -> Optional[None]:
+    """
+    Test that container instances without deployment groups can still have
+    relationships (backward compatibility).
+
+    When no deployment groups are specified, all instances should be able to
+    relate to each other as before.
+    """
+
+    with Workspace("w", scope=None) as w:
+        with SoftwareSystem("Software System") as software_system:
+            service_a = Container("Service A")
+            service_b = Container("Service B")
+            service_a >> "Communicates with" >> service_b
+
+        with DeploymentEnvironment("Production") as production:
+            with DeploymentNode("Server 1"):
+                # No deployment groups specified
+                service_a_instance_1 = ContainerInstance(service_a)
+                service_b_instance_1 = ContainerInstance(service_b)
+
+            with DeploymentNode("Server 2"):
+                # No deployment groups specified
+                service_a_instance_2 = ContainerInstance(service_a)
+                service_b_instance_2 = ContainerInstance(service_b)
+
+    # When no deployment groups are specified, instances should be able to
+    # relate to each other (all instances are in the "default" group)
+    # This maintains backward compatibility
+
+    # Each service_a instance should relate to ALL service_b instances
+    service_a_1_rels = [
+        r for r in (service_a_instance_1.model.relationships or [])
+        if r.description == "Communicates with"
+    ]
+    service_a_2_rels = [
+        r for r in (service_a_instance_2.model.relationships or [])
+        if r.description == "Communicates with"
+    ]
+
+    # When no groups specified, all instances should connect to all other instances
+    assert len(service_a_1_rels) == 2, f"Expected 2 relationships (to both service_b instances), found {len(service_a_1_rels)}"
+    assert len(service_a_2_rels) == 2, f"Expected 2 relationships (to both service_b instances), found {len(service_a_2_rels)}"
+
+    # Verify destinations
+    service_a_1_destinations = {r.destinationId for r in service_a_1_rels}
+    service_a_2_destinations = {r.destinationId for r in service_a_2_rels}
+
+    assert service_b_instance_1.model.id in service_a_1_destinations
+    assert service_b_instance_2.model.id in service_a_1_destinations
+    assert service_b_instance_1.model.id in service_a_2_destinations
+    assert service_b_instance_2.model.id in service_a_2_destinations

buildzr-0.0.18/buildzr/__about__.py

@@ -1 +0,0 @@
-VERSION = "0.0.18"