Tests and validation for IndexSimulation/Data

Author: daquinteroflex

tests/test_components/test_index.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import pydantic.v1 as pydantic
+import pytest
+
+from tidy3d import IndexSimulation, Simulation
+
+from ..utils import SAMPLE_SIMULATIONS
+
+# Reusable test constants
+SIM_INDEX = ("sim_A", "sim_B")
+DATA_INDEX = ("data_A", "data_B")
+
+
+def make_simulations() -> tuple[Simulation, ...]:
+    """Creates a tuple of simple, distinct Simulation objects for testing."""
+    sim1 = SAMPLE_SIMULATIONS["full_fdtd"]
+    sim2 = SAMPLE_SIMULATIONS["full_fdtd"]
+    return (sim1, sim2)
+
+
+def make_index_simulation(**kwargs) -> IndexSimulation:
+    """Factory function to create a standard IndexSimulation instance."""
+    return IndexSimulation(index=SIM_INDEX, simulation=make_simulations(), **kwargs)
+
+
+def test_index_simulation_creation():
+    """Tests successful creation of an IndexSimulation instance."""
+    sims = make_simulations()
+    container = make_index_simulation()
+    assert container.index == SIM_INDEX
+    assert container.simulation == sims
+    assert len(container.index) == len(container.simulation)
+
+
+def test_index_simulation_mismatched_length_raises_error():
+    """Tests that a ValueError is raised for mismatched index and simulation lengths."""
+    sims = make_simulations()
+    with pytest.raises(pydantic.ValidationError, match="Length of 'index' and 'simulation'"):
+        IndexSimulation(index=("only_one_index",), simulation=sims)
+
+
+def test_index_simulation_getitem_success():
+    """Tests successful retrieval of a simulation by its string index."""
+    container = make_index_simulation()
+    sims = make_simulations()
+    assert container[SIM_INDEX[0]] == sims[0]
+    assert container[SIM_INDEX[1]] == sims[1]
+
+
+def test_index_simulation_getitem_key_error():
+    """Tests that a KeyError is raised when retrieving a non-existent index."""
+    container = make_index_simulation()
+    with pytest.raises(KeyError, match="Index 'not_a_real_key' not found."):
+        _ = container["not_a_real_key"]

tests/test_data/test_index.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import pydantic.v1 as pydantic
+import pytest
+
+from tidy3d import IndexSimulation, IndexSimulationData, Simulation, SimulationData
+
+from ..utils import SAMPLE_SIMULATIONS, run_emulated
+
+# Reusable test constants
+SIM_INDEX = ("sim_A", "sim_B")
+DATA_INDEX = ("data_A", "data_B")
+
+
+def make_simulations() -> tuple[Simulation, ...]:
+    """Creates a tuple of simple, distinct Simulation objects for testing."""
+    sim1 = SAMPLE_SIMULATIONS["full_fdtd"]
+    sim2 = SAMPLE_SIMULATIONS["full_fdtd"].updated_copy(run_time=2e-12)
+    return (sim1, sim2)
+
+
+def make_simulation_data() -> tuple[SimulationData, ...]:
+    """Creates a tuple of simple SimulationData objects for testing."""
+    sims = make_simulations()
+    data1 = run_emulated(sims[0])
+    data2 = run_emulated(sims[1])
+    return (data1, data2)
+
+
+def make_index_simulation(**kwargs) -> IndexSimulation:
+    """Factory function to create a standard IndexSimulation instance."""
+    return IndexSimulation(index=SIM_INDEX, simulation=make_simulations(), **kwargs)
+
+
+def make_index_simulation_data(**kwargs) -> IndexSimulationData:
+    """Factory function to create a standard IndexSimulationData instance."""
+    return IndexSimulationData(index=DATA_INDEX, data=make_simulation_data(), **kwargs)
+
+
+def test_index_simulation_data_creation():
+    """Tests successful creation of an IndexSimulationData instance."""
+    sim_data = make_simulation_data()
+    container = make_index_simulation_data()
+    assert container.index == DATA_INDEX
+    assert container.data == sim_data
+    assert len(container.index) == len(container.data)
+
+
+def test_index_simulation_data_mismatched_length_raises_error():
+    """Tests that a ValueError is raised for mismatched index and data lengths."""
+    sim_data = make_simulation_data()
+    with pytest.raises(pydantic.ValidationError, match="Length of 'index' and 'data'"):
+        IndexSimulationData(index=("only_one_index",), data=sim_data)
+
+
+def test_index_simulation_data_getitem_success():
+    """Tests successful retrieval of simulation data by its string index."""
+    container = make_index_simulation_data()
+    sim_data = make_simulation_data()
+    assert container[DATA_INDEX[0]] == sim_data[0]
+    assert container[DATA_INDEX[1]] == sim_data[1]
+
+
+def test_index_simulation_data_getitem_key_error():
+    """Tests that a KeyError is raised when retrieving a non-existent index."""
+    container = make_index_simulation_data()
+    with pytest.raises(KeyError, match="Index 'not_a_real_key' not found."):
+        _ = container["not_a_real_key"]

tests/test_plugins/smatrix/test_component_modeler.py

@@ -412,47 +412,3 @@ def test_mapping_with_run_only():
     run_only.remove(EXCLUDE_INDEX)
     with pytest.raises(pydantic.ValidationError):
         _ = make_component_modeler(element_mappings=element_mappings, run_only=run_only)
-
-
-# def test_batch_filename(tmp_path):
-#     modeler = make_component_modeler()
-#     path = modeler._batch_path
-#     assert path
-# def test_import_smatrix_smatrix():
-#     from tidy3d.plugins.smatrix.smatrix import ComponentModeler, Port
-
-# def test_to_from_file_empty_batch(tmp_path):
-#     modeler = make_component_modeler()
-#
-#     fname = str(tmp_path) + "/modeler.json"
-#
-#     modeler.to_file(fname)
-#     modeler2 = modeler.from_file(fname)
-#
-#     assert modeler2.batch_cached is None
-#
-#
-# def test_to_from_file_batch(tmp_path, monkeypatch):
-#     modeler = make_component_modeler()
-#     _ = run_component_modeler(monkeypatch, modeler)
-#
-#     batch = td.web.Batch(simulations={})
-#
-#     modeler._cached_properties["batch"] = batch
-#
-#     fname = str(tmp_path) + "/modeler.json"
-#
-#     modeler.to_file(fname)
-#     modeler2 = modeler.from_file(fname)
-#
-#     # BREAK this test because it introduces mutability which shouldn't exist
-#     assert modeler2.batch_cached == modeler2.batch == batch
-#
-#
-# def test_non_default_path_dir(monkeypatch):
-#     modeler = make_component_modeler(path_dir="not_default")
-#     monkeypatch.setattr(ComponentModeler, "_construct_smatrix", lambda self: None)
-#     modeler.run()
-#     modeler.run(path_dir="not_default")
-#     with pytest.raises(ValueError):
-#         modeler.run(path_dir="a_new_path")

tidy3d/components/data/index.py

@@ -1,25 +1,45 @@
 from __future__ import annotations
 
+import pydantic.v1 as pd
+
 from tidy3d.components.base import Tidy3dBaseModel
 from tidy3d.components.simulaton_types import SimulationDataType
 
 
 class IndexSimulationData(Tidy3dBaseModel):
+    """Container for a set of simulation data, accessible by a string index."""
+
     index: tuple[str, ...]
+    """Tuple of unique string identifiers for each simulation data object."""
+
     data: tuple[SimulationDataType, ...]
+    """Tuple of :class:`.SimulationData` objects corresponding to each index."""
+
+    @pd.root_validator()
+    def _validate_lengths_match(cls, values):
+        """Validate that index and data have the same length."""
+        index, data = values.get("index"), values.get("data")
+        if index is not None and data is not None and len(index) != len(data):
+            raise ValueError("Length of 'index' and 'data' must be the same.")
+        return values
 
     def __getitem__(self, index: str) -> SimulationDataType:
-        """
-        Allows retrieving simulation data by the port name.
+        """Allows retrieving simulation data by its index name.
 
-        Args:
-            port_name: The string name of the port to look up.
+        Parameters
+        ----------
+        index : str
+            The string name of the simulation data to look up.
 
-        Returns:
-            The SimulationData object corresponding to the given port name.
+        Returns
+        -------
+        SimulationDataType
+            The :class:`.SimulationData` object corresponding to the given index name.
 
-        Raises:
-            KeyError: If no port with the given name is found.
+        Raises
+        ------
+        KeyError
+            If no simulation data with the given index name is found.
         """
         for i, index_i in enumerate(self.index):
             if index_i == index:

tidy3d/components/index.py

@@ -2,26 +2,46 @@
 
 from typing import Union
 
+import pydantic.v1 as pd
+
 from tidy3d.components.base import Tidy3dBaseModel
 from tidy3d.components.simulaton_types import SimulationType
 
 
 class IndexSimulation(Tidy3dBaseModel):
-    index: tuple[str, ...]
-    simulation: tuple[SimulationType, ...]
+    """Container for a set of simulations, accessible by a string index."""
 
-    def __getitem__(self, index: Union[str, int]) -> SimulationType:
-        """
-        Allows retrieving simulation data by the port name.
+    index: tuple[str, ...]
+    """Tuple of unique string identifiers for each simulation."""
 
-        Args:
-            port_name: The string name of the port to look up.
+    simulation: tuple[SimulationType, ...]
+    """Tuple of :class:`.Simulation` objects corresponding to each index."""
 
-        Returns:
-            The SimulationData object corresponding to the given port name.
+    @pd.root_validator()
+    def _validate_lengths_match(cls, values):
+        """Validate that index and simulation have the same length."""
+        index, simulation = values.get("index"), values.get("simulation")
+        if index is not None and simulation is not None and len(index) != len(simulation):
+            raise ValueError("Length of 'index' and 'simulation' must be the same.")
+        return values
 
-        Raises:
-            KeyError: If no port with the given name is found.
+    def __getitem__(self, index: Union[str, int]) -> SimulationType:
+        """Allows retrieving a simulation by its index name.
+
+        Parameters
+        ----------
+        index : Union[str, int]
+            The string name or integer index of the simulation to look up.
+
+        Returns
+        -------
+        SimulationType
+            The :class:`.Simulation` object corresponding to the given index.
+
+        Raises
+        ------
+        KeyError
+            If no simulation with the given index name is found.
         """
         for i, index_i in enumerate(self.index):
             if index_i == index: