Merge pull request #102 from gdsfactory/test/improve-test-suite

test: remove redundant tests, add workflow integration tests

Author: vvahidd

src/gsim/palace/base.py

@@ -651,7 +651,7 @@ def _configure_ports_on_component(self, stack: LayerStack) -> None:  # noqa: ARG
             raise ValueError("No component set")
 
         # Configure regular ports
-        for port_config in self.ports:
+        for port_config in self.ports or []:
             if self.simulation_type != "driven":
                 port_config.excited = False
             if port_config.name is None:
@@ -698,7 +698,7 @@ def _configure_ports_on_component(self, stack: LayerStack) -> None:  # noqa: ARG
                 gf_port.info["capacitance"] = port_config.capacitance
 
         # Configure CPW ports
-        for cpw_config in self.cpw_ports:
+        for cpw_config in self.cpw_ports or []:
             # Find the single gdsfactory port at the signal center
             gf_port = None
             for p in component.ports:

src/gsim/palace/mesh/config_generator.py

@@ -49,7 +49,12 @@ def generate_palace_config(
     """
     from gsim.palace.ports.config import PortGeometry
 
-    if simulation_type not in ("driven", "eigenmode", "electrostatics"):
+    if simulation_type not in (
+        "driven",
+        "eigenmode",
+        "electrostatic",
+        "electrostatics",
+    ):
         raise ValueError(f"Unsupported simulation type: {simulation_type}")
 
     # Use driven_config if provided, otherwise fall back to legacy parameters

tests/meep/test_meep_models.py

@@ -17,9 +17,6 @@
     WavelengthConfig,
 )
 from gsim.meep.models.config import (
-    LayerStackEntry,
-    MaterialData,
-    PortData,
     StoppingConfig,
     SymmetryEntry,
 )
@@ -180,88 +177,6 @@ def test_to_json(self, tmp_path):
         assert data["stopping"]["run_after_sources"] == 200.0
 
 
-class TestPortData:
-    """Test PortData model."""
-
-    def test_creation(self):
-        p = PortData(
-            name="o1",
-            center=[0.0, 0.0, 0.11],
-            orientation=0.0,
-            width=0.5,
-            normal_axis=0,
-            direction="-",
-            is_source=True,
-        )
-        assert p.name == "o1"
-        assert p.is_source
-
-    def test_model_dump(self):
-        p = PortData(
-            name="o1",
-            center=[0.0, 0.0, 0.11],
-            orientation=180.0,
-            width=0.5,
-            normal_axis=0,
-            direction="+",
-        )
-        d = p.model_dump()
-        assert d["name"] == "o1"
-        assert d["direction"] == "+"
-
-
-class TestLayerStackEntry:
-    """Test LayerStackEntry model."""
-
-    def test_creation(self):
-        entry = LayerStackEntry(
-            layer_name="core",
-            gds_layer=[1, 0],
-            zmin=0.0,
-            zmax=0.22,
-            material="si",
-        )
-        assert entry.layer_name == "core"
-        assert entry.gds_layer == [1, 0]
-        assert entry.sidewall_angle == 0.0
-
-    def test_with_sidewall_angle(self):
-        entry = LayerStackEntry(
-            layer_name="core",
-            gds_layer=[1, 0],
-            zmin=0.0,
-            zmax=0.22,
-            material="si",
-            sidewall_angle=10.0,
-        )
-        assert entry.sidewall_angle == 10.0
-
-    def test_model_dump(self):
-        entry = LayerStackEntry(
-            layer_name="clad",
-            gds_layer=[2, 0],
-            zmin=-0.5,
-            zmax=0.5,
-            material="SiO2",
-        )
-        d = entry.model_dump()
-        assert d["layer_name"] == "clad"
-        assert d["gds_layer"] == [2, 0]
-
-
-class TestMaterialData:
-    """Test MaterialData model."""
-
-    def test_creation(self):
-        m = MaterialData(refractive_index=3.47)
-        assert m.refractive_index == 3.47
-        assert m.extinction_coeff == 0.0
-
-    def test_with_extinction(self):
-        m = MaterialData(refractive_index=3.47, extinction_coeff=0.01)
-        assert m.extinction_coeff == 0.01
-
-
 # ---------------------------------------------------------------------------
 # Port extraction tests
 # ---------------------------------------------------------------------------
@@ -521,34 +436,6 @@ def test_to_dict_omits_zero_angle(self):
         assert "sidewall_angle" not in d
 
 
-# ---------------------------------------------------------------------------
-# Import test
-# ---------------------------------------------------------------------------
-
-
-class TestImportWithoutMeep:
-    """Verify module imports work without meep installed."""
-
-    def test_import_all_public_api(self):
-        from gsim.meep import (
-            DomainConfig,
-            ResolutionConfig,
-            SimConfig,
-            Simulation,
-            SourceConfig,
-            SParameterResult,
-            WavelengthConfig,
-        )
-
-        assert WavelengthConfig is not None
-        assert DomainConfig is not None
-        assert ResolutionConfig is not None
-        assert SParameterResult is not None
-        assert SimConfig is not None
-        assert SourceConfig is not None
-        assert Simulation is not None
-
-
 # ---------------------------------------------------------------------------
 # DomainConfig tests
 # ---------------------------------------------------------------------------
@@ -1088,6 +975,7 @@ def test_build_sim_overlay(self):
         import numpy as np
 
         from gsim.common.geometry_model import GeometryModel, Prism
+        from gsim.meep.models.config import PortData
         from gsim.meep.overlay import build_sim_overlay
 
         gm = GeometryModel(

tests/meep/test_simulation.py

@@ -8,11 +8,9 @@
 from gsim.meep import (
     FDTD,
     Domain,
-    Geometry,
     Material,
     ModeSource,
     Simulation,
-    Symmetry,
 )
 
 # ---------------------------------------------------------------------------
@@ -23,15 +21,6 @@
 class TestMaterial:
     """Tests for the Material model."""
 
-    def test_basic(self):
-        m = Material(n=3.47)
-        assert m.n == 3.47
-        assert m.k == 0.0
-
-    def test_with_extinction(self):
-        m = Material(n=3.47, k=0.01)
-        assert m.k == 0.01
-
     def test_n_must_be_positive(self):
         with pytest.raises(ValidationError):
             Material(n=0)
@@ -41,65 +30,9 @@ def test_k_must_be_non_negative(self):
             Material(n=1.5, k=-0.1)
 
 
-class TestModeSource:
-    """Tests for the ModeSource model."""
-
-    def test_defaults(self):
-        s = ModeSource()
-        assert s.port is None
-        assert s.wavelength == 1.55
-        assert s.wavelength_span == 0.1
-        assert s.num_freqs == 11
-
-    def test_custom(self):
-        s = ModeSource(port="o1", wavelength=1.31, wavelength_span=0.05, num_freqs=21)
-        assert s.port == "o1"
-        assert s.wavelength == 1.31
-        assert s.wavelength_span == 0.05
-        assert s.num_freqs == 21
-
-
-class TestDomain:
-    """Tests for the Domain model."""
-
-    def test_defaults(self):
-        d = Domain()
-        assert d.pml == 1.0
-        assert d.margin == 0.5
-        assert d.margin_z_above == 0.5
-        assert d.margin_z_below == 0.5
-        assert d.port_margin == 0.5
-        assert d.extend_ports == 0.0
-        assert d.source_port_offset == 0.1
-        assert d.distance_source_to_monitors == 0.2
-        assert d.symmetries == []
-
-    def test_custom(self):
-        d = Domain(pml=0.5, margin=0.2, port_margin=0.3)
-        assert d.pml == 0.5
-        assert d.margin == 0.2
-        assert d.port_margin == 0.3
-
-    def test_symmetries(self):
-        d = Domain(symmetries=[Symmetry(direction="Y", phase=-1)])
-        assert len(d.symmetries) == 1
-        assert d.symmetries[0].direction == "Y"
-        assert d.symmetries[0].phase == -1
-
-
 class TestStoppingFields:
     """Tests for the FDTD stopping criteria."""
 
-    def test_defaults(self):
-        f = FDTD()
-        assert f.stopping == "energy_decay"
-        assert f.max_time == 2000.0
-        assert f.stopping_threshold == 0.01
-        assert f.stopping_min_time == 100.0
-        assert f.stopping_component == "Ey"
-        assert f.stopping_dt == 20.0
-        assert f.stopping_monitor_port is None
-
     def test_fixed_mode(self):
         f = FDTD(stopping="fixed", max_time=100)
         assert f.stopping == "fixed"
@@ -137,42 +70,11 @@ def test_invalid_mode(self):
 class TestFDTD:
     """Tests for the FDTD model."""
 
-    def test_defaults(self):
-        f = FDTD()
-        assert f.resolution == 32
-        assert f.stopping == "energy_decay"
-        assert f.max_time == 2000.0
-        assert f.subpixel is False
-        assert f.simplify_tol == 0.0
-
-    def test_with_custom_stopping(self):
-        f = FDTD(stopping="field_decay", stopping_threshold=1e-4)
-        assert f.stopping == "field_decay"
-        assert f.stopping_threshold == 1e-4
-
     def test_resolution_custom(self):
         f = FDTD(resolution=64)
         assert f.resolution == 64
 
 
-class TestFDTDDiagnostics:
-    """Tests for the FDTD diagnostics settings."""
-
-    def test_defaults(self):
-        f = FDTD()
-        assert f.save_geometry is True
-        assert f.save_fields is True
-        assert f.save_animation is False
-        assert f.preview_only is False
-        assert f.verbose_interval == 0
-
-    def test_custom(self):
-        f = FDTD(save_animation=True, verbose_interval=5.0, preview_only=True)
-        assert f.save_animation is True
-        assert f.verbose_interval == 5.0
-        assert f.preview_only is True
-
-
 # ---------------------------------------------------------------------------
 # Material normalization
 # ---------------------------------------------------------------------------
@@ -502,42 +404,3 @@ def test_diagnostics_translation(self):
         cfg = sim._diagnostics_config()
         assert cfg.save_animation is True
         assert cfg.preview_only is True
-
-
-# ---------------------------------------------------------------------------
-# Import tests
-# ---------------------------------------------------------------------------
-
-
-class TestImports:
-    """Tests for importing the new declarative API."""
-
-    def test_import_all_new_api(self):
-        from gsim.meep import (
-            FDTD,
-            Domain,
-            Material,
-            ModeSource,
-            Simulation,
-            Symmetry,
-        )
-
-        assert all(
-            cls is not None
-            for cls in [
-                Domain,
-                FDTD,
-                Geometry,
-                Material,
-                ModeSource,
-                Simulation,
-                Symmetry,
-            ]
-        )
-
-    def test_simulation_instantiation(self):
-        sim = Simulation()
-        assert sim.geometry.component is None
-        assert sim.materials == {}
-        assert sim.monitors == []
-        assert sim.solver.resolution == 32