Initial commit

tests/integration/test_workflow.py

@@ -0,0 +1,217 @@
+"""Integration tests for complete workflows."""
+
+import pytest
+import tempfile
+import shutil
+from pathlib import Path
+
+from src.generators import RecursiveBacktrackingGenerator, KruskalGenerator
+from src.solvers import BFSSolver, DFSSolver
+from src.storage.file_handler import FileHandler
+from src.visualization.image_renderer import ImageRenderer
+from src.analysis.analyzer import MazeAnalyzer
+
+
+class TestCompleteWorkflow:
+    """Test complete end-to-end workflows."""
+
+    def test_generate_solve_analyze_workflow(self):
+        """Test generating, solving, and analyzing a maze."""
+        # Generate maze
+        generator = RecursiveBacktrackingGenerator()
+        maze = generator.generate(15, 15, seed=42)
+
+        assert maze is not None
+        assert maze.rows == 15
+        assert maze.cols == 15
+
+        # Solve maze
+        solver = BFSSolver()
+        result = solver.solve(maze)
+
+        assert result['success']
+        assert result['path_length'] > 0
+
+        # Analyze maze
+        analysis = MazeAnalyzer.analyze(maze)
+
+        assert analysis['total_cells'] == 225
+        assert analysis['dead_ends'] > 0
+
+    def test_generate_save_load_workflow(self):
+        """Test generating, saving, and loading a maze."""
+        # Create temp directory
+        temp_dir = tempfile.mkdtemp()
+
+        try:
+            # Generate maze
+            generator = KruskalGenerator()
+            maze = generator.generate(10, 10, seed=123)
+
+            # Save maze
+            filepath = FileHandler.save_maze(maze, 'test_maze', temp_dir)
+            assert Path(filepath).exists()
+
+            # Load maze
+            loaded_maze = FileHandler.load_maze('test_maze', temp_dir)
+
+            assert loaded_maze.rows == maze.rows
+            assert loaded_maze.cols == maze.cols
+            assert loaded_maze.seed == maze.seed
+
+            # Verify walls are preserved
+            for row in range(maze.rows):
+                for col in range(maze.cols):
+                    original_cell = maze.get_cell(row, col)
+                    loaded_cell = loaded_maze.get_cell(row, col)
+                    assert original_cell.walls == loaded_cell.walls
+
+        finally:
+            shutil.rmtree(temp_dir)
+
+    def test_generate_render_workflow(self):
+        """Test generating and rendering a maze."""
+        temp_dir = tempfile.mkdtemp()
+
+        try:
+            # Generate maze
+            generator = RecursiveBacktrackingGenerator()
+            maze = generator.generate(10, 10, seed=42)
+
+            # Render image
+            renderer = ImageRenderer(cell_size=20)
+            filepath = renderer.render(maze, 'test_render', temp_dir)
+
+            assert Path(filepath).exists()
+
+            # File should have content
+            file_size = Path(filepath).stat().st_size
+            assert file_size > 0
+
+        finally:
+            shutil.rmtree(temp_dir)
+
+    def test_generate_solve_render_workflow(self):
+        """Test generating, solving, and rendering with solution."""
+        temp_dir = tempfile.mkdtemp()
+
+        try:
+            # Generate maze
+            generator = RecursiveBacktrackingGenerator()
+            maze = generator.generate(15, 15, seed=42)
+
+            # Solve maze
+            solver = DFSSolver()
+            result = solver.solve(maze)
+
+            # Render with solution
+            renderer = ImageRenderer(cell_size=20)
+            filepath = renderer.render(
+                maze,
+                'maze_with_solution',
+                temp_dir,
+                solution_path=result['path'],
+                visited_cells=result['visited']
+            )
+
+            assert Path(filepath).exists()
+            assert Path(filepath).stat().st_size > 0
+
+        finally:
+            shutil.rmtree(temp_dir)
+
+    def test_multiple_algorithms_workflow(self):
+        """Test workflow with multiple algorithms."""
+        from src.generators import (
+            PrimGenerator,
+            SidewinderGenerator,
+            WilsonGenerator
+        )
+
+        generators = [
+            PrimGenerator(),
+            SidewinderGenerator(),
+            WilsonGenerator()
+        ]
+
+        for generator in generators:
+            # Generate
+            maze = generator.generate(10, 10, seed=42)
+            assert maze is not None
+
+            # Solve with both solvers
+            for solver in [DFSSolver(), BFSSolver()]:
+                result = solver.solve(maze)
+                assert result['success']
+
+            # Analyze
+            analysis = MazeAnalyzer.analyze(maze)
+            assert analysis['total_cells'] == 100
+
+
+class TestFileOperations:
+    """Test file operation workflows."""
+
+    def test_save_list_delete_workflow(self):
+        """Test saving, listing, and deleting mazes."""
+        temp_dir = tempfile.mkdtemp()
+
+        try:
+            generator = RecursiveBacktrackingGenerator()
+
+            # Save multiple mazes
+            maze1 = generator.generate(5, 5, seed=1)
+            maze2 = generator.generate(10, 10, seed=2)
+
+            FileHandler.save_maze(maze1, 'maze1', temp_dir)
+            FileHandler.save_maze(maze2, 'maze2', temp_dir)
+
+            # List mazes
+            files = FileHandler.list_saved_mazes(temp_dir)
+            assert len(files) == 2
+            assert 'maze1.json' in files
+            assert 'maze2.json' in files
+
+            # Delete one
+            deleted = FileHandler.delete_maze('maze1', temp_dir)
+            assert deleted
+
+            # List again
+            files = FileHandler.list_saved_mazes(temp_dir)
+            assert len(files) == 1
+            assert 'maze2.json' in files
+
+        finally:
+            shutil.rmtree(temp_dir)
+
+    def test_load_nonexistent_file(self):
+        """Test loading a file that doesn't exist."""
+        temp_dir = tempfile.mkdtemp()
+
+        try:
+            with pytest.raises(FileNotFoundError):
+                FileHandler.load_maze('nonexistent', temp_dir)
+
+        finally:
+            shutil.rmtree(temp_dir)
+
+
+class TestVisualization:
+    """Test visualization workflows."""
+
+    def test_render_different_sizes(self):
+        """Test rendering mazes of different sizes."""
+        temp_dir = tempfile.mkdtemp()
+
+        try:
+            generator = RecursiveBacktrackingGenerator()
+            renderer = ImageRenderer()
+
+            for size in [5, 10, 15]:
+                maze = generator.generate(size, size, seed=42)
+                filepath = renderer.render(maze, f'maze_{size}', temp_dir)
+
+                assert Path(filepath).exists()
+
+        finally:
+            shutil.rmtree(temp_dir)