buildzr 0.0.17__tar.gz → 0.0.19__tar.gz

{buildzr-0.0.17 → buildzr-0.0.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: buildzr
-Version: 0.0.17
+Version: 0.0.19
 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.19/buildzr/__about__.py

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

{buildzr-0.0.17 → buildzr-0.0.19}/buildzr/dsl/dsl.py

@@ -129,16 +129,19 @@ 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
+        skipped.
+
         This process is idempotent, which means this can be called multiple times
         without duplicating similar relationships.
         """
@@ -149,12 +152,22 @@ 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
             destination = relationship.destination
             destination_parent = destination.parent
 
+            if isinstance(source, (SoftwareSystemInstance, ContainerInstance)) or \
+               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 \
@@ -179,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)
@@ -364,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
 
@@ -832,6 +877,12 @@ 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]
 
@@ -900,6 +951,12 @@ 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]
 

{buildzr-0.0.17 → buildzr-0.0.19}/tests/test_dsl.py

@@ -15,6 +15,7 @@ from buildzr.dsl import (
     SystemContextView,
     DeploymentEnvironment,
     DeploymentNode,
+    DeploymentView,
     InfrastructureNode,
     DeploymentGroup,
     SoftwareSystemInstance,
@@ -394,6 +395,53 @@ def test_implied_relationship() -> Optional[None]:
         assert w.u.model.relationships[1].id in system_context_view_relationships
         assert w.u.model.relationships[1].linkedRelationshipId == w.u.model.relationships[0].id
 
+    import os
+    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'})
@@ -1099,4 +1147,230 @@ def test_json_sink_empty_views() -> Optional[None]:
     assert data
 
     import os
-    os.remove("test.json")
+    os.remove("test.json")
+
+def test_deployment_instance_relationships_with_implied_relationships() -> Optional[None]:
+    """
+    Test that deployment instance relationships are created correctly when
+    implied_relationships=True, without creating duplicates.
+
+    This test ensures:
+    1. Container relationships automatically create ContainerInstance relationships
+    2. No duplicate instance relationships are created when implied_relationships=True
+    3. Instance relationships are only created once, even with multiple view/export calls
+    """
+
+    with Workspace('deployment-test', implied_relationships=True) as w:
+        # Create containers with relationships
+        ecommerce = SoftwareSystem('E-Commerce System')
+        with ecommerce:
+            api_gateway = Container('API Gateway', technology='Kong')
+            order_svc = Container('Order Service', technology='Node.js')
+            db = Container('Database', technology='MongoDB')
+
+        # Define container relationships
+        api_gateway >> "Routes to" >> order_svc
+        order_svc >> "Stores in" >> db
+
+        # Create deployment with container instances
+        with DeploymentEnvironment('Production') as prod:
+            with DeploymentNode('AWS', technology='Cloud Provider'):
+                api_gw_instance = ContainerInstance(api_gateway)
+                order_instance = ContainerInstance(order_svc)
+                db_instance = ContainerInstance(db)
+
+        # Create views and export (triggers implied relationships multiple times)
+        SystemContextView(
+            software_system_selector=ecommerce,
+            key='test-system-context',
+            description="Test System Context",
+        )
+
+        DeploymentView(
+            environment=prod,
+            key='test-deployment',
+        )
+
+        # Export multiple times to ensure idempotency
+        w.to_json('test_deployment1.json')
+        w.to_json('test_deployment2.json')
+
+    # Verify instance relationships exist
+    assert api_gw_instance.model.relationships is not None
+    assert order_instance.model.relationships is not None
+
+    # Get all instance relationships
+    api_gw_rels = api_gw_instance.model.relationships
+    order_rels = order_instance.model.relationships
+
+    # Should have exactly 1 relationship from api_gw_instance to order_instance
+    api_to_order_rels = [
+        r for r in api_gw_rels
+        if r.destinationId == order_instance.model.id
+    ]
+    assert len(api_to_order_rels) == 1, f"Expected 1 relationship, found {len(api_to_order_rels)}"
+    assert api_to_order_rels[0].description == "Routes to"
+
+    # Should have exactly 1 relationship from order_instance to db_instance
+    order_to_db_rels = [
+        r for r in order_rels
+        if r.destinationId == db_instance.model.id
+    ]
+    assert len(order_to_db_rels) == 1, f"Expected 1 relationship, found {len(order_to_db_rels)}"
+    assert order_to_db_rels[0].description == "Stores in"
+
+    # Verify linkedRelationshipId is set correctly
+    assert api_to_order_rels[0].linkedRelationshipId is not None
+    assert order_to_db_rels[0].linkedRelationshipId is not None
+
+    # Clean up
+    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

{buildzr-0.0.17 → buildzr-0.0.19}/tests/test_explorer.py

@@ -90,7 +90,7 @@ def test_walk_relationships(workspace: Workspace) -> Optional[None]:
 
     # 5 explicit relationships.
     # Add one additional implied relationship.
-    # And four additional from container instances for each two container instance (2x2=4 + 2x2=4 more).
+    # And four additional from container instances for each two container instance (2x2=4).
     #
     # Explanation: if we have containers A and B with relationship A >> "Uses" >> B,
     # and container instances ci_A_1, ci_A_2, ci_B_1, ci_B_2, then we have the
@@ -99,7 +99,7 @@ def test_walk_relationships(workspace: Workspace) -> Optional[None]:
     #   ci_A_1 >> "Uses" >> ci_B_2
     #   ci_A_2 >> "Uses" >> ci_B_1
     #   ci_A_2 >> "Uses" >> ci_B_2
-    assert len(relationships) == 14
+    assert len(relationships) == 10
 
     for relationship in relationships:
         relationship_set = (

buildzr-0.0.17/buildzr/__about__.py

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