"""Tests to improve generator.py code coverage."""
import pytest
import tempfile
import os
from pathlib import Path
from unittest.mock import Mock, patch
class TestGeneratorErrorHandling:
"""Test generator error handling scenarios."""
def test_export_to_file_permission_error(self):
"""Test export when file cannot be written due to permissions."""
from archi_mcp.archimate.generator import ArchiMateGenerator
from archi_mcp.archimate import ArchiMateElement
from archi_mcp.archimate.elements.base import ArchiMateLayer, ArchiMateAspect
generator = ArchiMateGenerator()
# Add a test element
element = ArchiMateElement(
id="test",
name="Test Element",
element_type="Business_Actor",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE
)
generator.add_element(element)
# Try to export to a path that would cause permission error
with patch("builtins.open", side_effect=PermissionError("Permission denied")):
with pytest.raises(Exception): # Should raise ArchiMateGenerationError
generator.export_to_file("/invalid/permission/path.puml")
def test_export_to_file_disk_full_error(self):
"""Test export when disk is full."""
from archi_mcp.archimate.generator import ArchiMateGenerator
from archi_mcp.archimate import ArchiMateElement
from archi_mcp.archimate.elements.base import ArchiMateLayer, ArchiMateAspect
generator = ArchiMateGenerator()
element = ArchiMateElement(
id="test",
name="Test Element",
element_type="Business_Actor",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE
)
generator.add_element(element)
# Mock OSError for disk full
with patch("builtins.open", side_effect=OSError("No space left on device")):
with pytest.raises(Exception): # Should raise ArchiMateGenerationError
generator.export_to_file("/tmp/test.puml")
def test_export_to_file_directory_creation_error(self):
"""Test export when directory cannot be created."""
from archi_mcp.archimate.generator import ArchiMateGenerator
from archi_mcp.archimate import ArchiMateElement
from archi_mcp.archimate.elements.base import ArchiMateLayer, ArchiMateAspect
generator = ArchiMateGenerator()
element = ArchiMateElement(
id="test",
name="Test Element",
element_type="Business_Actor",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE
)
generator.add_element(element)
# Mock directory creation failure - this test should actually work since export_to_file doesn't create directories
with pytest.raises(Exception): # Should raise an exception due to non-existent path
generator.export_to_file("/nonexistent/deep/path/test.puml")
class TestGeneratorPlantUMLGeneration:
"""Test PlantUML generation edge cases."""
def test_generate_plantuml_with_complex_descriptions(self):
"""Test PlantUML generation with complex element descriptions."""
from archi_mcp.archimate.generator import ArchiMateGenerator
from archi_mcp.archimate import ArchiMateElement
from archi_mcp.archimate.elements.base import ArchiMateLayer, ArchiMateAspect
generator = ArchiMateGenerator()
# Add element with complex description containing special characters
element = ArchiMateElement(
id="complex",
name="Complex Element",
element_type="Business_Actor",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE,
description="Description with \"quotes\", newlines\nand special chars: @#$%^&*()"
)
generator.add_element(element)
plantuml = generator.generate_plantuml()
assert "@startuml" in plantuml
assert "@enduml" in plantuml
assert "Complex Element" in plantuml
def test_generate_plantuml_with_properties(self):
"""Test PlantUML generation with element properties."""
from archi_mcp.archimate.generator import ArchiMateGenerator
from archi_mcp.archimate import ArchiMateElement
from archi_mcp.archimate.elements.base import ArchiMateLayer, ArchiMateAspect
generator = ArchiMateGenerator()
# Add element with properties
element = ArchiMateElement(
id="props",
name="Element with Properties",
element_type="Business_Actor",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE,
properties={
"cost": "high",
"criticality": "critical",
"owner": "IT Department"
}
)
generator.add_element(element)
plantuml = generator.generate_plantuml()
assert "@startuml" in plantuml
assert "Element with Properties" in plantuml
# Properties might not be rendered in current implementation
# Just verify basic structure is correct
assert "props" in plantuml
def test_generate_plantuml_with_stereotype(self):
"""Test PlantUML generation with element stereotypes."""
from archi_mcp.archimate.generator import ArchiMateGenerator
from archi_mcp.archimate import ArchiMateElement
from archi_mcp.archimate.elements.base import ArchiMateLayer, ArchiMateAspect
generator = ArchiMateGenerator()
# Add element with stereotype
element = ArchiMateElement(
id="stereo",
name="Stereotyped Element",
element_type="Business_Actor",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE,
stereotype="<<external>>"
)
generator.add_element(element)
plantuml = generator.generate_plantuml()
assert "@startuml" in plantuml
assert "Stereotyped Element" in plantuml
assert "external" in plantuml or "<<" in plantuml
def test_generate_plantuml_with_direction_override(self):
"""Test PlantUML generation with direction override."""
from archi_mcp.archimate.generator import ArchiMateGenerator
from archi_mcp.archimate import ArchiMateElement
from archi_mcp.archimate.elements.base import ArchiMateLayer, ArchiMateAspect
generator = ArchiMateGenerator()
# Set horizontal direction using DiagramLayout object
from archi_mcp.archimate.generator import DiagramLayout
layout = DiagramLayout(direction="horizontal")
generator.set_layout(layout)
element1 = ArchiMateElement(
id="elem1",
name="Element 1",
element_type="Business_Actor",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE
)
element2 = ArchiMateElement(
id="elem2",
name="Element 2",
element_type="Business_Service",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.BEHAVIOR
)
generator.add_element(element1)
generator.add_element(element2)
plantuml = generator.generate_plantuml()
assert "@startuml" in plantuml
# Should contain horizontal layout directive
assert "left to right" in plantuml or "!define DIRECTION" in plantuml
def test_generate_plantuml_without_grouping(self):
"""Test PlantUML generation without layer grouping."""
from archi_mcp.archimate.generator import ArchiMateGenerator
from archi_mcp.archimate import ArchiMateElement
from archi_mcp.archimate.elements.base import ArchiMateLayer, ArchiMateAspect
generator = ArchiMateGenerator()
# Disable layer grouping using DiagramLayout object
from archi_mcp.archimate.generator import DiagramLayout
layout = DiagramLayout(group_by_layer=False)
generator.set_layout(layout)
# Add elements from different layers
business_element = ArchiMateElement(
id="business",
name="Business Element",
element_type="Business_Actor",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE
)
app_element = ArchiMateElement(
id="app",
name="App Element",
element_type="Application_Component",
layer=ArchiMateLayer.APPLICATION,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE
)
generator.add_element(business_element)
generator.add_element(app_element)
plantuml = generator.generate_plantuml()
assert "@startuml" in plantuml
assert "Business Element" in plantuml
assert "App Element" in plantuml
# Should not contain layer grouping (no rectangle/package declarations)
layer_group_indicators = ["rectangle", "package", "folder"]
assert not any(indicator in plantuml.lower() for indicator in layer_group_indicators)
def test_generate_plantuml_with_spacing_variations(self):
"""Test PlantUML generation with different spacing options."""
from archi_mcp.archimate.generator import ArchiMateGenerator
from archi_mcp.archimate import ArchiMateElement
from archi_mcp.archimate.elements.base import ArchiMateLayer, ArchiMateAspect
generator = ArchiMateGenerator()
# Test compact spacing using DiagramLayout object
from archi_mcp.archimate.generator import DiagramLayout
layout = DiagramLayout(spacing="compact")
generator.set_layout(layout)
element = ArchiMateElement(
id="test",
name="Test Element",
element_type="Business_Actor",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE
)
generator.add_element(element)
plantuml_compact = generator.generate_plantuml()
assert "@startuml" in plantuml_compact
# Test wide spacing - create new generator since clear_diagram doesn't exist
generator2 = ArchiMateGenerator()
layout2 = DiagramLayout(spacing="wide")
generator2.set_layout(layout2)
generator2.add_element(element)
plantuml_wide = generator2.generate_plantuml()
assert "@startuml" in plantuml_wide
# Both should be valid PlantUML, but spacing implementation may not differ visibly
# Just verify both work without errors
assert "Test Element" in plantuml_compact
assert "Test Element" in plantuml_wide
def test_generate_plantuml_with_title_and_legend(self):
"""Test PlantUML generation with both title and legend."""
from archi_mcp.archimate.generator import ArchiMateGenerator
from archi_mcp.archimate import ArchiMateElement
from archi_mcp.archimate.elements.base import ArchiMateLayer, ArchiMateAspect
generator = ArchiMateGenerator()
# Enable title and legend using DiagramLayout object
from archi_mcp.archimate.generator import DiagramLayout
layout = DiagramLayout(
show_title=True,
show_legend=True
)
generator.set_layout(layout)
element = ArchiMateElement(
id="test",
name="Test Element",
element_type="Business_Actor",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE
)
generator.add_element(element)
plantuml = generator.generate_plantuml(title="Test Architecture Diagram")
assert "@startuml" in plantuml
assert "Test Architecture Diagram" in plantuml
class TestGeneratorValidation:
"""Test generator validation scenarios."""
def test_validate_diagram_with_orphaned_relationships(self):
"""Test validation with orphaned relationships."""
from archi_mcp.archimate.generator import ArchiMateGenerator
from archi_mcp.archimate import ArchiMateElement, ArchiMateRelationship
from archi_mcp.archimate.elements.base import ArchiMateLayer, ArchiMateAspect
from archi_mcp.utils.exceptions import ArchiMateGenerationError
import pytest
generator = ArchiMateGenerator()
# Add element
element = ArchiMateElement(
id="elem1",
name="Element 1",
element_type="Business_Actor",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE
)
generator.add_element(element)
# Try to add relationship referencing non-existent element
orphaned_relationship = ArchiMateRelationship(
id="orphan",
from_element="elem1",
to_element="nonexistent", # This element doesn't exist
relationship_type="Access"
)
# Adding orphaned relationship should raise ArchiMateGenerationError
with pytest.raises(ArchiMateGenerationError) as exc_info:
generator.add_relationship(orphaned_relationship)
# Verify error message contains information about the orphaned relationship
assert "nonexistent" in str(exc_info.value)
def test_validate_diagram_with_duplicate_ids(self):
"""Test validation with duplicate element IDs."""
from archi_mcp.archimate.generator import ArchiMateGenerator
from archi_mcp.archimate import ArchiMateElement
from archi_mcp.archimate.elements.base import ArchiMateLayer, ArchiMateAspect
generator = ArchiMateGenerator()
# Add element
element1 = ArchiMateElement(
id="duplicate",
name="Element 1",
element_type="Business_Actor",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE
)
generator.add_element(element1)
# Try to add another element with same ID
element2 = ArchiMateElement(
id="duplicate", # Same ID
name="Element 2",
element_type="Business_Service",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.BEHAVIOR
)
# This should raise an exception for duplicate ID
with pytest.raises(Exception): # Should raise ArchiMateGenerationError
generator.add_element(element2)
# Validation should pass (only first element should be present)
errors = generator.validate_diagram()
assert len(errors) == 0 # Should be valid since duplicate wasn't added
def test_validate_diagram_success_scenario(self):
"""Test validation with valid diagram."""
from archi_mcp.archimate.generator import ArchiMateGenerator
from archi_mcp.archimate import ArchiMateElement, ArchiMateRelationship
from archi_mcp.archimate.elements.base import ArchiMateLayer, ArchiMateAspect
generator = ArchiMateGenerator()
# Add valid elements
element1 = ArchiMateElement(
id="elem1",
name="Element 1",
element_type="Business_Actor",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE
)
element2 = ArchiMateElement(
id="elem2",
name="Element 2",
element_type="Business_Service",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.BEHAVIOR
)
generator.add_element(element1)
generator.add_element(element2)
# Add valid relationship
relationship = ArchiMateRelationship(
id="rel1",
from_element="elem1",
to_element="elem2",
relationship_type="Access"
)
generator.add_relationship(relationship)
# Validation should pass
errors = generator.validate_diagram()
assert len(errors) == 0
class TestGeneratorStatistics:
"""Test generator statistics and information methods."""
def test_get_layers_used_multiple_layers(self):
"""Test getting layers used with elements from multiple layers."""
from archi_mcp.archimate.generator import ArchiMateGenerator
from archi_mcp.archimate import ArchiMateElement
from archi_mcp.archimate.elements.base import ArchiMateLayer, ArchiMateAspect
generator = ArchiMateGenerator()
# Add elements from different layers
business_element = ArchiMateElement(
id="business",
name="Business Element",
element_type="Business_Actor",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE
)
app_element = ArchiMateElement(
id="app",
name="App Element",
element_type="Application_Component",
layer=ArchiMateLayer.APPLICATION,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE
)
tech_element = ArchiMateElement(
id="tech",
name="Tech Element",
element_type="Node",
layer=ArchiMateLayer.TECHNOLOGY,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE
)
generator.add_element(business_element)
generator.add_element(app_element)
generator.add_element(tech_element)
# Check layers by examining elements directly (since get_layers_used doesn't exist)
layers = set(element.layer for element in generator.elements.values())
assert ArchiMateLayer.BUSINESS in layers
assert ArchiMateLayer.APPLICATION in layers
assert ArchiMateLayer.TECHNOLOGY in layers
assert len(layers) == 3
def test_get_element_count_after_clear(self):
"""Test element count after clearing diagram."""
from archi_mcp.archimate.generator import ArchiMateGenerator
from archi_mcp.archimate import ArchiMateElement
from archi_mcp.archimate.elements.base import ArchiMateLayer, ArchiMateAspect
generator = ArchiMateGenerator()
# Add elements
for i in range(5):
element = ArchiMateElement(
id=f"elem{i}",
name=f"Element {i}",
element_type="Business_Actor",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE
)
generator.add_element(element)
assert len(generator.elements) == 5
# Clear diagram manually (since clear_diagram doesn't exist)
generator.elements.clear()
assert len(generator.elements) == 0
def test_get_relationship_count_after_clear(self):
"""Test relationship count after clearing diagram."""
from archi_mcp.archimate.generator import ArchiMateGenerator
from archi_mcp.archimate import ArchiMateElement, ArchiMateRelationship
from archi_mcp.archimate.elements.base import ArchiMateLayer, ArchiMateAspect
generator = ArchiMateGenerator()
# Add elements first
element1 = ArchiMateElement(
id="elem1",
name="Element 1",
element_type="Business_Actor",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE
)
element2 = ArchiMateElement(
id="elem2",
name="Element 2",
element_type="Business_Service",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.BEHAVIOR
)
generator.add_element(element1)
generator.add_element(element2)
# Add relationships
for i in range(3):
relationship = ArchiMateRelationship(
id=f"rel{i}",
from_element="elem1",
to_element="elem2",
relationship_type="Access"
)
generator.add_relationship(relationship)
assert len(generator.relationships) == 3
# Clear diagram manually (since clear_diagram doesn't exist)
generator.elements.clear()
generator.relationships.clear()
assert len(generator.relationships) == 0
class TestGeneratorEdgeCases:
"""Test generator edge cases and boundary conditions."""
def test_generate_plantuml_empty_after_clear(self):
"""Test PlantUML generation after clearing populated diagram."""
from archi_mcp.archimate.generator import ArchiMateGenerator
from archi_mcp.archimate import ArchiMateElement
from archi_mcp.archimate.elements.base import ArchiMateLayer, ArchiMateAspect
generator = ArchiMateGenerator()
# Add element
element = ArchiMateElement(
id="test",
name="Test Element",
element_type="Business_Actor",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE
)
generator.add_element(element)
# Generate PlantUML with content
plantuml_with_content = generator.generate_plantuml()
assert "Test Element" in plantuml_with_content
# Clear and generate again
generator.elements.clear()
# Should raise exception for empty diagram
with pytest.raises(Exception): # Should raise ArchiMateGenerationError
generator.generate_plantuml()
def test_add_relationship_missing_elements_handling(self):
"""Test adding relationship when referenced elements don't exist yet."""
from archi_mcp.archimate.generator import ArchiMateGenerator
from archi_mcp.archimate import ArchiMateRelationship
generator = ArchiMateGenerator()
# Try to add relationship before adding elements
relationship = ArchiMateRelationship(
id="rel1",
from_element="nonexistent1",
to_element="nonexistent2",
relationship_type="Access"
)
# Validation should catch the error before adding
errors = relationship.validate_relationship(generator.elements)
assert len(errors) > 0 # Should have validation errors for missing elements
assert "not found" in ' '.join(errors).lower() or "nonexistent" in ' '.join(errors).lower()
# Generator should also raise exception when trying to add invalid relationship
with pytest.raises(Exception) as exc_info:
generator.add_relationship(relationship)
# Verify the exception message mentions the validation failure
assert "validation" in str(exc_info.value).lower() or "not found" in str(exc_info.value).lower()
def test_layout_parameter_edge_cases(self):
"""Test layout parameters with edge case values."""
from archi_mcp.archimate.generator import ArchiMateGenerator
generator = ArchiMateGenerator()
# Add a test element first so we can generate diagrams
from archi_mcp.archimate import ArchiMateElement
from archi_mcp.archimate.elements.base import ArchiMateLayer, ArchiMateAspect
from archi_mcp.archimate.generator import DiagramLayout
element = ArchiMateElement(
id="test",
name="Test Element",
element_type="Business_Actor",
layer=ArchiMateLayer.BUSINESS,
aspect=ArchiMateAspect.ACTIVE_STRUCTURE
)
generator.add_element(element)
# Test with various layout values
layout1 = DiagramLayout(direction="vertical", spacing="compact", show_legend=False)
generator.set_layout(layout1)
plantuml1 = generator.generate_plantuml()
assert "@startuml" in plantuml1
assert "@enduml" in plantuml1
# Test with different layout values
layout2 = DiagramLayout(direction="horizontal", spacing="wide", show_title=True)
generator.set_layout(layout2)
plantuml2 = generator.generate_plantuml()
assert "@startuml" in plantuml2
assert "@enduml" in plantuml2
