python-maze/tests/integration/test_workflow.py

"""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)