Add comprehensive test suite

- Add conftest.py with shared pytest fixtures
- Add test_module.py for module attributes and exports
- Add test_solvers.py for solver discovery and constants
- Add test_simulation.py for grid and simulation functions
- Add test_output.py for VTK and CSV output
- Add test_errors.py for error handling
- Add test_integration.py for end-to-end workflows

Tests cover:
- Dynamic solver registration
- Grid creation and validation
- Simulation execution
- Output file generation
- Error conditions and edge cases

Author: shaia

tests/conftest.py

@@ -0,0 +1,39 @@
+"""
+Pytest configuration and shared fixtures for CFD Python tests
+"""
+import pytest
+import sys
+import os
+
+# Add the build directory to the path for testing
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
+
+try:
+    import cfd_python
+except ImportError:
+    pytest.skip("CFD Python module not built yet", allow_module_level=True)
+
+
+@pytest.fixture
+def cfd():
+    """Provide the cfd_python module"""
+    return cfd_python
+
+
+@pytest.fixture
+def small_grid_params():
+    """Small grid parameters for quick tests"""
+    return {
+        'nx': 5,
+        'ny': 5,
+        'xmin': 0.0,
+        'xmax': 1.0,
+        'ymin': 0.0,
+        'ymax': 1.0,
+    }
+
+
+@pytest.fixture
+def default_solver_params(cfd):
+    """Default solver parameters"""
+    return cfd.get_default_solver_params()

tests/test_errors.py

@@ -0,0 +1,58 @@
+"""
+Tests for error handling
+"""
+import pytest
+import cfd_python
+
+
+class TestErrorHandling:
+    """Test error handling"""
+
+    def test_run_simulation_invalid_nx(self):
+        """Test error handling for invalid nx type"""
+        with pytest.raises(TypeError):
+            cfd_python.run_simulation("invalid", 5, steps=3)
+
+    def test_run_simulation_invalid_ny(self):
+        """Test error handling for invalid ny type"""
+        with pytest.raises(TypeError):
+            cfd_python.run_simulation(5, "invalid", steps=3)
+
+    def test_create_grid_invalid_params(self):
+        """Test error handling for invalid grid parameters"""
+        with pytest.raises(TypeError):
+            cfd_python.create_grid("invalid", 10, 0.0, 1.0, 0.0, 1.0)
+
+    def test_write_vtk_scalar_invalid_data_type(self, tmp_path):
+        """Test error handling for invalid data type"""
+        output_file = tmp_path / "invalid.vtk"
+        with pytest.raises(TypeError):
+            cfd_python.write_vtk_scalar(
+                str(output_file), "test", "not a list",
+                5, 5, 0.0, 1.0, 0.0, 1.0
+            )
+
+    def test_has_solver_invalid_type(self):
+        """Test error handling for invalid solver type argument"""
+        with pytest.raises(TypeError):
+            cfd_python.has_solver(123)  # Should be string
+
+    def test_get_solver_info_empty_string(self):
+        """Test error handling for empty solver name"""
+        with pytest.raises(ValueError):
+            cfd_python.get_solver_info('')
+
+    def test_create_grid_zero_dimensions(self):
+        """Test error handling for zero grid dimensions"""
+        with pytest.raises(ValueError):
+            cfd_python.create_grid(0, 10, 0.0, 1.0, 0.0, 1.0)
+
+    def test_create_grid_negative_dimensions(self):
+        """Test error handling for negative grid dimensions"""
+        with pytest.raises(ValueError):
+            cfd_python.create_grid(-5, 10, 0.0, 1.0, 0.0, 1.0)
+
+    def test_run_simulation_zero_steps(self):
+        """Test error handling for zero steps"""
+        with pytest.raises(ValueError):
+            cfd_python.run_simulation(5, 5, steps=0)

tests/test_integration.py

@@ -0,0 +1,121 @@
+"""
+Integration tests for complete workflows
+"""
+import pytest
+import cfd_python
+
+
+class TestIntegration:
+    """Integration tests for complete workflows"""
+
+    def test_full_simulation_workflow(self, tmp_path):
+        """Test complete simulation workflow"""
+        # 1. List available solvers
+        solvers = cfd_python.list_solvers()
+        assert len(solvers) > 0
+
+        # 2. Get solver info
+        solver_info = cfd_python.get_solver_info(solvers[0])
+        assert 'name' in solver_info
+
+        # 3. Get default parameters
+        params = cfd_python.get_default_solver_params()
+        assert 'dt' in params
+
+        # 4. Create grid
+        grid = cfd_python.create_grid(10, 10, 0.0, 1.0, 0.0, 1.0)
+        assert grid['nx'] == 10
+
+        # 5. Run simulation
+        vtk_file = tmp_path / "workflow_test.vtk"
+        result = cfd_python.run_simulation_with_params(
+            10, 10, 0.0, 1.0, 0.0, 1.0,
+            steps=5,
+            solver_type=solvers[0],
+            output_file=str(vtk_file)
+        )
+
+        # 6. Verify results
+        assert 'velocity_magnitude' in result
+        assert len(result['velocity_magnitude']) == 100
+        assert vtk_file.exists()
+
+    def test_solver_constant_matches_list(self):
+        """Test that solver constants match list_solvers output"""
+        solvers = cfd_python.list_solvers()
+
+        for solver_name in solvers:
+            # Use the constant to run a simulation
+            const_name = 'SOLVER_' + solver_name.upper()
+            if hasattr(cfd_python, const_name):
+                solver_type = getattr(cfd_python, const_name)
+                # Should be able to use this to check solver exists
+                assert cfd_python.has_solver(solver_type)
+
+    def test_multiple_simulations_same_grid(self):
+        """Test running multiple simulations with same grid"""
+        grid = cfd_python.create_grid(8, 8, 0.0, 1.0, 0.0, 1.0)
+
+        results = []
+        for i in range(3):
+            result = cfd_python.run_simulation(
+                grid['nx'], grid['ny'], steps=2
+            )
+            results.append(result)
+
+        # All results should have same size
+        for r in results:
+            assert len(r) == 64
+
+    def test_different_solvers_same_problem(self):
+        """Test running same problem with different solvers"""
+        solvers = cfd_python.list_solvers()
+
+        results = {}
+        for solver_name in solvers[:2]:  # Test first two solvers
+            result = cfd_python.run_simulation(
+                5, 5, steps=3, solver_type=solver_name
+            )
+            results[solver_name] = result
+
+        # All results should have correct size
+        for name, result in results.items():
+            assert len(result) == 25, f"Solver {name} returned wrong size"
+
+    def test_output_workflow(self, tmp_path):
+        """Test complete output workflow"""
+        # Set output directory
+        cfd_python.set_output_dir(str(tmp_path))
+
+        # Run simulation
+        nx, ny = 6, 6
+        result = cfd_python.run_simulation(nx, ny, steps=3)
+
+        # Write VTK scalar output
+        vtk_file = tmp_path / "velocity_mag.vtk"
+        cfd_python.write_vtk_scalar(
+            str(vtk_file), "velocity_magnitude", result,
+            nx, ny, 0.0, 1.0, 0.0, 1.0
+        )
+        assert vtk_file.exists()
+
+        # Write VTK vector output
+        u_data = [0.1] * (nx * ny)
+        v_data = [0.05] * (nx * ny)
+        vtk_vector_file = tmp_path / "velocity.vtk"
+        cfd_python.write_vtk_vector(
+            str(vtk_vector_file), "velocity", u_data, v_data,
+            nx, ny, 0.0, 1.0, 0.0, 1.0
+        )
+        assert vtk_vector_file.exists()
+
+        # Write CSV timeseries
+        csv_file = tmp_path / "timeseries.csv"
+        p_data = [1.0] * (nx * ny)
+        cfd_python.write_csv_timeseries(
+            str(csv_file), step=0, time=0.0,
+            u_data=u_data, v_data=v_data, p_data=p_data,
+            nx=nx, ny=ny, dt=0.001, iterations=10,
+            create_new=True
+        )
+        assert csv_file.exists()

tests/test_module.py

@@ -0,0 +1,81 @@
+"""
+Tests for module-level attributes and exports
+"""
+import pytest
+import cfd_python
+
+
+class TestModuleAttributes:
+    """Test module-level attributes and constants"""
+
+    def test_version(self):
+        """Test version string exists"""
+        assert hasattr(cfd_python, '__version__')
+        assert isinstance(cfd_python.__version__, str)
+        assert cfd_python.__version__ == "0.3.0"
+
+    def test_output_constants_exist(self):
+        """Test OUTPUT_* constants are defined"""
+        assert hasattr(cfd_python, 'OUTPUT_PRESSURE')
+        assert hasattr(cfd_python, 'OUTPUT_VELOCITY')
+        assert hasattr(cfd_python, 'OUTPUT_FULL_FIELD')
+        assert hasattr(cfd_python, 'OUTPUT_CSV_TIMESERIES')
+        assert hasattr(cfd_python, 'OUTPUT_CSV_CENTERLINE')
+        assert hasattr(cfd_python, 'OUTPUT_CSV_STATISTICS')
+
+    def test_output_constants_are_integers(self):
+        """Test OUTPUT_* constants are integers"""
+        assert isinstance(cfd_python.OUTPUT_PRESSURE, int)
+        assert isinstance(cfd_python.OUTPUT_VELOCITY, int)
+        assert isinstance(cfd_python.OUTPUT_FULL_FIELD, int)
+        assert isinstance(cfd_python.OUTPUT_CSV_TIMESERIES, int)
+        assert isinstance(cfd_python.OUTPUT_CSV_CENTERLINE, int)
+        assert isinstance(cfd_python.OUTPUT_CSV_STATISTICS, int)
+
+    def test_output_constants_unique(self):
+        """Test OUTPUT_* constants have unique values"""
+        values = [
+            cfd_python.OUTPUT_PRESSURE,
+            cfd_python.OUTPUT_VELOCITY,
+            cfd_python.OUTPUT_FULL_FIELD,
+            cfd_python.OUTPUT_CSV_TIMESERIES,
+            cfd_python.OUTPUT_CSV_CENTERLINE,
+            cfd_python.OUTPUT_CSV_STATISTICS,
+        ]
+        assert len(values) == len(set(values)), "OUTPUT_* constants should have unique values"
+
+
+class TestAllExports:
+    """Test that __all__ exports are accessible"""
+
+    def test_core_functions_exported(self):
+        """Test core functions are in __all__ and accessible"""
+        core_functions = [
+            'run_simulation',
+            'create_grid',
+            'get_default_solver_params',
+            'run_simulation_with_params',
+            'list_solvers',
+            'has_solver',
+            'get_solver_info',
+            'set_output_dir',
+            'write_vtk_scalar',
+            'write_vtk_vector',
+            'write_csv_timeseries',
+        ]
+        for func_name in core_functions:
+            assert hasattr(cfd_python, func_name), f"Missing function: {func_name}"
+            assert callable(getattr(cfd_python, func_name)), f"{func_name} should be callable"
+
+    def test_output_constants_in_all(self):
+        """Test OUTPUT_* constants are exported"""
+        output_constants = [
+            'OUTPUT_PRESSURE',
+            'OUTPUT_VELOCITY',
+            'OUTPUT_FULL_FIELD',
+            'OUTPUT_CSV_TIMESERIES',
+            'OUTPUT_CSV_CENTERLINE',
+            'OUTPUT_CSV_STATISTICS',
+        ]
+        for const_name in output_constants:
+            assert const_name in cfd_python.__all__, f"{const_name} should be in __all__"