asnyc background

2025-11-11 15:34:04 +01:00
parent aa3eacf627
commit 099ccb4c6b
15 changed files with 1781 additions and 142 deletions
@@ -419,3 +419,195 @@ class TestAlignmentManager:
        
        assert abs(gap1 - 50) < 0.01
        assert abs(gap2 - 50) < 0.01
+
+    def test_maximize_pattern_empty_list(self):
+        """Test maximize_pattern with empty list"""
+        changes = AlignmentManager.maximize_pattern([], (297, 210))
+        assert changes == []
+
+    def test_maximize_pattern_single_element(self):
+        """Test maximize_pattern with single element"""
+        # Small element in the middle of the page
+        elem = ImageData(x=100, y=80, width=20, height=15)
+        page_size = (297, 210)  # A4 landscape in mm
+
+        changes = AlignmentManager.maximize_pattern([elem], page_size, min_gap=2.0)
+
+        # Element should grow significantly
+        assert elem.size[0] > 20
+        assert elem.size[1] > 15
+
+        # Should maintain aspect ratio
+        original_aspect = 20 / 15
+        new_aspect = elem.size[0] / elem.size[1]
+        assert abs(original_aspect - new_aspect) < 0.01
+
+        # Should not exceed page boundaries (with min_gap)
+        assert elem.position[0] >= 2.0
+        assert elem.position[1] >= 2.0
+        assert elem.position[0] + elem.size[0] <= 297 - 2.0
+        assert elem.position[1] + elem.size[1] <= 210 - 2.0
+
+        # Check undo information
+        assert len(changes) == 1
+        assert changes[0][0] == elem
+        assert changes[0][1] == (100, 80)  # old position
+        assert changes[0][2] == (20, 15)   # old size
+
+    def test_maximize_pattern_two_elements_horizontal(self):
+        """Test maximize_pattern with two elements side by side"""
+        elem1 = ImageData(x=50, y=80, width=20, height=20)
+        elem2 = ImageData(x=200, y=80, width=20, height=20)
+        page_size = (297, 210)  # A4 landscape in mm
+
+        changes = AlignmentManager.maximize_pattern([elem1, elem2], page_size, min_gap=2.0)
+
+        # Both elements should grow
+        assert elem1.size[0] > 20 and elem1.size[1] > 20
+        assert elem2.size[0] > 20 and elem2.size[1] > 20
+
+        # Elements should not overlap (min_gap = 2.0)
+        gap_x = max(
+            elem2.position[0] - (elem1.position[0] + elem1.size[0]),
+            elem1.position[0] - (elem2.position[0] + elem2.size[0])
+        )
+        gap_y = max(
+            elem2.position[1] - (elem1.position[1] + elem1.size[1]),
+            elem1.position[1] - (elem2.position[1] + elem2.size[1])
+        )
+
+        # Either horizontal or vertical gap should be >= min_gap
+        assert gap_x >= 2.0 or gap_y >= 2.0
+
+        # Both elements should respect page boundaries
+        for elem in [elem1, elem2]:
+            assert elem.position[0] >= 2.0
+            assert elem.position[1] >= 2.0
+            assert elem.position[0] + elem.size[0] <= 297 - 2.0
+            assert elem.position[1] + elem.size[1] <= 210 - 2.0
+
+    def test_maximize_pattern_three_elements_grid(self):
+        """Test maximize_pattern with three elements in a grid pattern"""
+        elem1 = ImageData(x=50, y=50, width=15, height=15)
+        elem2 = ImageData(x=150, y=50, width=15, height=15)
+        elem3 = ImageData(x=100, y=120, width=15, height=15)
+        page_size = (297, 210)  # A4 landscape in mm
+
+        changes = AlignmentManager.maximize_pattern([elem1, elem2, elem3], page_size, min_gap=2.0)
+
+        # All elements should grow
+        for elem in [elem1, elem2, elem3]:
+            assert elem.size[0] > 15
+            assert elem.size[1] > 15
+
+        # Check no overlaps with min_gap
+        elements = [elem1, elem2, elem3]
+        for i, elem_a in enumerate(elements):
+            for j, elem_b in enumerate(elements):
+                if i >= j:
+                    continue
+
+                # Calculate gaps between rectangles
+                gap_x = max(
+                    elem_b.position[0] - (elem_a.position[0] + elem_a.size[0]),
+                    elem_a.position[0] - (elem_b.position[0] + elem_b.size[0])
+                )
+                gap_y = max(
+                    elem_b.position[1] - (elem_a.position[1] + elem_a.size[1]),
+                    elem_a.position[1] - (elem_b.position[1] + elem_b.size[1])
+                )
+
+                # At least one gap should be >= min_gap
+                assert gap_x >= 2.0 or gap_y >= 2.0
+
+        # Check undo information
+        assert len(changes) == 3
+
+    def test_maximize_pattern_respects_boundaries(self):
+        """Test that maximize_pattern respects page boundaries"""
+        elem = ImageData(x=10, y=10, width=10, height=10)
+        page_size = (100, 100)
+        min_gap = 5.0
+
+        changes = AlignmentManager.maximize_pattern([elem], page_size, min_gap=min_gap)
+
+        # Element should not exceed boundaries
+        assert elem.position[0] >= min_gap
+        assert elem.position[1] >= min_gap
+        assert elem.position[0] + elem.size[0] <= page_size[0] - min_gap
+        assert elem.position[1] + elem.size[1] <= page_size[1] - min_gap
+
+    def test_maximize_pattern_maintains_aspect_ratio(self):
+        """Test that maximize_pattern maintains element aspect ratios"""
+        elem1 = ImageData(x=50, y=50, width=30, height=20)  # 3:2 aspect
+        elem2 = ImageData(x=150, y=50, width=20, height=30)  # 2:3 aspect
+        page_size = (297, 210)
+
+        original_aspect1 = elem1.size[0] / elem1.size[1]
+        original_aspect2 = elem2.size[0] / elem2.size[1]
+
+        changes = AlignmentManager.maximize_pattern([elem1, elem2], page_size, min_gap=2.0)
+
+        # Aspect ratios should be maintained
+        new_aspect1 = elem1.size[0] / elem1.size[1]
+        new_aspect2 = elem2.size[0] / elem2.size[1]
+
+        assert abs(original_aspect1 - new_aspect1) < 0.01
+        assert abs(original_aspect2 - new_aspect2) < 0.01
+
+    def test_maximize_pattern_with_constrained_space(self):
+        """Test maximize_pattern when elements are tightly packed"""
+        # Create 4 elements in corners with limited space
+        elem1 = ImageData(x=10, y=10, width=10, height=10)
+        elem2 = ImageData(x=140, y=10, width=10, height=10)
+        elem3 = ImageData(x=10, y=90, width=10, height=10)
+        elem4 = ImageData(x=140, y=90, width=10, height=10)
+        page_size = (160, 110)
+
+        changes = AlignmentManager.maximize_pattern(
+            [elem1, elem2, elem3, elem4],
+            page_size,
+            min_gap=2.0
+        )
+
+        # All elements should grow
+        for elem in [elem1, elem2, elem3, elem4]:
+            assert elem.size[0] > 10
+            assert elem.size[1] > 10
+
+        # Verify no overlaps
+        elements = [elem1, elem2, elem3, elem4]
+        for i, elem_a in enumerate(elements):
+            for j, elem_b in enumerate(elements):
+                if i >= j:
+                    continue
+
+                gap_x = max(
+                    elem_b.position[0] - (elem_a.position[0] + elem_a.size[0]),
+                    elem_a.position[0] - (elem_b.position[0] + elem_b.size[0])
+                )
+                gap_y = max(
+                    elem_b.position[1] - (elem_a.position[1] + elem_a.size[1]),
+                    elem_a.position[1] - (elem_b.position[1] + elem_b.size[1])
+                )
+
+                assert gap_x >= 2.0 or gap_y >= 2.0
+
+    def test_maximize_pattern_with_different_element_types(self):
+        """Test maximize_pattern works with different element types"""
+        elem1 = ImageData(x=50, y=50, width=20, height=20)
+        elem2 = PlaceholderData(placeholder_type="image", x=150, y=50, width=20, height=20)
+        elem3 = TextBoxData(text_content="Test", x=100, y=120, width=20, height=20)
+        page_size = (297, 210)
+
+        changes = AlignmentManager.maximize_pattern([elem1, elem2, elem3], page_size, min_gap=2.0)
+
+        # All elements should grow
+        assert elem1.size[0] > 20
+        assert elem2.size[0] > 20
+        assert elem3.size[0] > 20
+
+        # Check undo information has correct element types
+        assert isinstance(changes[0][0], ImageData)
+        assert isinstance(changes[1][0], PlaceholderData)
+        assert isinstance(changes[2][0], TextBoxData)