tests and value checks for batch and launch settings

smartsim/settings/batch_settings.py

@@ -117,6 +117,15 @@ def __init__(
             """The scheduler type"""
         except ValueError:
             raise ValueError(f"Invalid scheduler type: {batch_scheduler}") from None
+
+        if batch_args:
+            if not (
+                isinstance(batch_args, t.Mapping)
+                and all(isinstance(key, str) for key, val in batch_args.items())
+            ):
+                raise TypeError(
+                    "batch_args argument was not of type mapping of str and str"
+                )
         self._arguments = self._get_arguments(batch_args)
         """The BatchSettings child class based on scheduler type"""
         self.env_vars = env_vars or {}
@@ -140,6 +149,16 @@ def env_vars(self) -> StringArgument:
     @env_vars.setter
     def env_vars(self, value: t.Dict[str, str | None]) -> None:
         """Set the environment variables."""
+
+        if not (
+            isinstance(value, t.Mapping)
+            and all(
+                isinstance(key, str) and isinstance(val, str)
+                for key, val in value.items()
+            )
+        ):
+            raise TypeError("env_vars argument was not of type dic of str and str")
+
         self._env_vars = copy.deepcopy(value)
 
     def _get_arguments(self, batch_args: StringArgument | None) -> BatchArguments:

smartsim/settings/launch_settings.py

@@ -126,6 +126,15 @@ def __init__(
             """The launcher type"""
         except ValueError:
             raise ValueError(f"Invalid launcher type: {launcher}")
+
+        if launch_args:
+            if not (
+                isinstance(launch_args, t.Mapping)
+                and all(isinstance(key, str) for key, val in launch_args.items())
+            ):
+                raise TypeError(
+                    "batch_args argument was not of type mapping of str and str"
+                )
         self._arguments = self._get_arguments(launch_args)
         """The LaunchSettings child class based on launcher type"""
         self.env_vars = env_vars or {}
@@ -165,6 +174,15 @@ def env_vars(self, value: dict[str, str | None]) -> None:
 
         :param value: The new environment mapping
         """
+        if not (
+            isinstance(value, t.Mapping)
+            and all(
+                isinstance(key, str) and isinstance(val, str)
+                for key, val in value.items()
+            )
+        ):
+            raise TypeError("env_vars argument was not of type dic of str and str")
+
         self._env_vars = copy.deepcopy(value)
 
     def _get_arguments(self, launch_args: StringArgument | None) -> LaunchArguments:
@@ -209,6 +227,15 @@ def update_env(self, env_vars: t.Dict[str, str | None]) -> None:
         :param env_vars: environment variables to update or add
         :raises TypeError: if env_vars values cannot be coerced to strings
         """
+        if not (
+            isinstance(env_vars, t.Mapping)
+            and all(
+                isinstance(key, str) and isinstance(val, str)
+                for key, val in env_vars.items()
+            )
+        ):
+            raise TypeError("env_vars argument was not of type dic of str and str")
+
         # Coerce env_vars values to str as a convenience to user
         for env, val in env_vars.items():
             if not isinstance(env, str):

tests/temp_tests/test_settings/test_batchSettings.py

@@ -78,3 +78,33 @@ def test_env_vars_property():
     assert bs.env_vars == {"ENV": "VAR"}
     ref = bs.env_vars
     assert ref is bs.env_vars
+
+
+def test_type_batch_scheduler():
+    batch_scheduler = "invalid"
+    with pytest.raises(ValueError, match="Invalid scheduler type: invalid"):
+        BatchSettings(
+            batch_scheduler=batch_scheduler,
+            batch_args={"launch": "var"},
+            env_vars={"ENV": "VAR"},
+        )
+
+
+def test_type_batch_args():
+    batch_args = "invalid"
+    with pytest.raises(
+        TypeError, match="batch_args argument was not of type mapping of str and str"
+    ):
+        BatchSettings(
+            batch_scheduler="slurm",
+            batch_args=batch_args,
+            env_vars={"ENV": "VAR"},
+        )
+
+
+def test_type_env_vars():
+    env_vars = "invalid"
+    with pytest.raises(
+        TypeError, match="env_vars argument was not of type dic of str and str"
+    ):
+        BatchSettings(batch_scheduler="slurm", env_vars=env_vars)

tests/temp_tests/test_settings/test_launchSettings.py

@@ -87,3 +87,29 @@ def test_update_env_vars_errors():
         # and that the function is atomic
         ls.update_env({"test": "test", "test": 1})
         assert ls.env_vars == {"ENV": "VAR"}
+
+
+def test_type_launcher():
+    launcher = "invalid"
+    with pytest.raises(ValueError, match="Invalid launcher type: invalid"):
+        LaunchSettings(
+            launcher=launcher, launch_args={"launch": "var"}, env_vars={"ENV": "VAR"}
+        )
+
+
+def test_type_launch_args():
+    launch_args = "invalid"
+    with pytest.raises(
+        TypeError, match="batch_args argument was not of type mapping of str and str"
+    ):
+        LaunchSettings(
+            launcher="local", launch_args=launch_args, env_vars={"ENV": "VAR"}
+        )
+
+
+def test_type_env_vars():
+    env_vars = "invalid"
+    with pytest.raises(
+        TypeError, match="env_vars argument was not of type dic of str and str"
+    ):
+        LaunchSettings(launcher="local", env_vars=env_vars)