gridappsd-python 2026.2.1a1__tar.gz → 2026.2.1a2__tar.gz

{gridappsd_python-2026.2.1a1 → gridappsd_python-2026.2.1a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gridappsd-python
-Version: 2026.2.1a1
+Version: 2026.2.1a2
 Summary: A GridAPPS-D Python Adapter
 Project-URL: Repository, https://github.com/GRIDAPPSD/gridappsd-python
 Project-URL: Homepage, https://gridappsd.readthedocs.io

{gridappsd_python-2026.2.1a1 → gridappsd_python-2026.2.1a2}/gridappsd/app_registration.py

@@ -1,6 +1,7 @@
 # import json
 import logging
 import os
+from enum import Enum
 from queue import Queue
 import time
 import subprocess
@@ -14,6 +15,30 @@ from . import utils, json_extension as json
 
 _log = logging.getLogger(__name__)
 
+GRIDAPPSD_APPLICATION_STATUS = "GRIDAPPSD_APPLICATION_STATUS"
+
+
+class ApplicationStatusEnum(Enum):
+    """Values this module writes to the GRIDAPPSD_APPLICATION_STATUS environment variable.
+
+    This is a distinct enum from gridappsd.utils.ProcessStatusEnum: this module's
+    STOPPED value has no equivalent in ProcessStatusEnum (which has CLOSED
+    instead), so reusing that enum here would either drop STOPPED or introduce
+    a mismatch between the value written and the value a reader expects.
+    """
+
+    STARTING = "STARTING"
+    STOPPING = "STOPPING"
+    RUNNING = "RUNNING"
+    STOPPED = "STOPPED"
+    ERROR = "ERROR"
+
+
+def _set_application_status(status: ApplicationStatusEnum) -> None:
+    """Write status to the GRIDAPPSD_APPLICATION_STATUS environment variable."""
+    os.environ[GRIDAPPSD_APPLICATION_STATUS] = status.value
+
+
 # determine OS type
 posix = False
 if os.name == "posix":
@@ -35,20 +60,20 @@ class Job(threading.Thread):
     def run(self):
         try:
             self.running = True
-            os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "RUNNING"
+            _set_application_status(ApplicationStatusEnum.RUNNING)
 
             p = subprocess.Popen(args=self._args, shell=False, stdout=self._out, stderr=self._err)
 
             # Loop while process is executing
             while p.poll() is None and self.running:
-                os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "RUNNING"
+                _set_application_status(ApplicationStatusEnum.RUNNING)
                 time.sleep(1)
 
         except Exception as e:
-            os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "ERROR"
+            _set_application_status(ApplicationStatusEnum.ERROR)
             _log.error(repr(e))
         else:
-            os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STOPPED"
+            _set_application_status(ApplicationStatusEnum.STOPPED)
 
 
 class ApplicationController(object):
@@ -58,7 +83,7 @@ class ApplicationController(object):
         if not isinstance(gridappsd, GridAPPSD):
             raise ValueError("Invalid gridappsd instance passed.")
 
-        os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STOPPED"
+        _set_application_status(ApplicationStatusEnum.STOPPED)
         self._configDict = config.copy()
         self._validate_config()
         self._gapd = gridappsd
@@ -80,7 +105,7 @@ class ApplicationController(object):
         self._end_callback = None
         self._print_queue = Queue()
         self._heartbeat_thread = None
-        os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STOPPED"
+        _set_application_status(ApplicationStatusEnum.STOPPED)
 
         if "type" not in self._configDict or self._configDict["type"] != "REMOTE":
             _log.warning(
@@ -119,7 +144,7 @@ class ApplicationController(object):
         self._stop_control_topic = response.get("stopControlTopic")
 
         os.environ["GRIDAPPSD_APPLICATION_ID"] = self._application_id
-        os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STOPPED"
+        _set_application_status(ApplicationStatusEnum.STOPPED)
 
         self._gapd.subscribe(self._stop_control_topic, self.__handle_stop)
         self._gapd.subscribe(self._start_control_topic, self.__handle_start)
@@ -160,7 +185,7 @@ class ApplicationController(object):
             obj = json.loads(message)
         else:
             obj = message
-        os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STARTING"
+        _set_application_status(ApplicationStatusEnum.STARTING)
         self._gapd.get_logger().debug("Handling Start: {}\ndict:\n{}".format(headers, obj))
 
         if "command" not in obj:
@@ -176,12 +201,12 @@ class ApplicationController(object):
 
     def __handle_stop(self, headers, message):
         print("Handling Stop: {} {}".format(headers, message))
-        os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STOPPING"
+        _set_application_status(ApplicationStatusEnum.STOPPING)
         if self._thread:
             self._thread.join()
         if self._end_callback is not None:
             self._end_callback()
-        os.environ["GRIDAPPSD_APPLICATION_STATUS"] = "STOPPED"
+        _set_application_status(ApplicationStatusEnum.STOPPED)
 
     def shutdown(self):
         self._shutting_down = True

{gridappsd_python-2026.2.1a1 → gridappsd_python-2026.2.1a2}/gridappsd/goss.py

@@ -57,7 +57,6 @@ from enum import Enum
 from logging import Logger
 from queue import Queue
 
-import stomp as _stomp_module
 from stomp import Connection12 as Connection
 from stomp.exception import NotConnectedException
 from time import sleep
@@ -66,19 +65,41 @@ from gridappsd import json_extension as json
 
 _log: Logger = logging.getLogger(inspect.getmodulename(__file__))
 
-# stomp.py 8.x changed listener callbacks from (headers, body) to (frame)
-_stomp_major = (
-    int(getattr(_stomp_module, "__version__", (0,))[0])
-    if isinstance(getattr(_stomp_module, "__version__", None), tuple)
-    else 0
-)
-try:
-    from importlib.metadata import version as _pkg_version
-
-    _stomp_major = int(_pkg_version("stomp-py").split(".")[0])
-except Exception:
-    pass
-_STOMP_V8 = _stomp_major >= 8
+
+def _unpack_stomp_args(*args):
+    """Return (headers, body) from a stomp listener callback's arguments.
+
+    stomp-py pre 8.x, and this module's own CallbackRouter dispatch, call
+    on_message/on_error with two positional arguments: headers and body.
+    stomp-py 8.x's raw listener protocol calls with a single Frame object
+    exposing .headers and .body instead. A listener reached through
+    CallbackRouter (any listener registered via subscribe()) always
+    receives the two argument shape, regardless of the installed stomp-py
+    version, because CallbackRouter.run_callbacks is the caller, not
+    stomp itself. Only a listener registered directly on a raw stomp
+    Connection (CallbackRouter itself, TokenResponseListener) is actually
+    invoked by stomp's own version dependent dispatch. Detecting the
+    argument shape at each call, instead of trusting a single global
+    version sniffed flag, is correct for both callers.
+    """
+    if len(args) >= 2:
+        return args[0], args[1]
+    frame = args[0]
+    if hasattr(frame, "headers") and hasattr(frame, "body"):
+        return frame.headers, frame.body
+    headers, body = frame
+    return headers, body
+
+
+def _serialize_message(message):
+    """Return message ready to send on the wire.
+
+    A list or dict body is serialized to a JSON string; any other body
+    (already a string, bytes, etc.) is passed through unchanged.
+    """
+    if isinstance(message, (list, dict)):
+        return json.dumps(message)
+    return message
 
 
 class GRIDAPPSD_ENV_ENUM(Enum):
@@ -168,8 +189,7 @@ class GOSS(object):
 
     def send(self, topic, message):
         self._make_connection()
-        if isinstance(message, list) or isinstance(message, dict):
-            message = json.dumps(message)
+        message = _serialize_message(message)
         _log.debug("Sending topic: {} body: {}".format(topic, message))
         self._conn.send(
             body=message, destination=topic, headers={"GOSS_HAS_SUBJECT": True, "GOSS_SUBJECT": self.__token}
@@ -185,11 +205,8 @@ class GOSS(object):
         if "resultFormat" in message:
             self.result_format = message["resultFormat"]
 
-        # Change message to string if we have a dictionary.
-        if isinstance(message, dict):
-            message = json.dumps(message)
-        elif isinstance(message, list):
-            message = json.dumps(message)
+        # Change message to string if we have a dictionary or list.
+        message = _serialize_message(message)
 
         class ResponseListener(object):
             def __init__(self, topic, result_format):
@@ -198,11 +215,7 @@ class GOSS(object):
                 self.result_format = result_format
 
             def on_message(self, *args):
-                if _STOMP_V8:
-                    frame = args[0]
-                    header, message = frame.headers, frame.body
-                else:
-                    header, message = args[0], args[1]
+                header, message = _unpack_stomp_args(*args)
                 _log.debug("Internal on message is: {} {}".format(header, message))
                 try:
                     if self.result_format == "JSON":
@@ -216,11 +229,7 @@ class GOSS(object):
                     self.response = dict(error="Invalid json returned", header=header, message=message)
 
             def on_error(self, *args):
-                if _STOMP_V8:
-                    frame = args[0]
-                    headers, message = frame.headers, frame.body
-                else:
-                    headers, message = args[0], args[1]
+                headers, message = _unpack_stomp_args(*args)
                 _log.error("ERR: {}".format(headers))
                 _log.error("OUR ERROR: {}".format(message))
 
@@ -337,21 +346,13 @@ class GOSS(object):
                         return self.__token
 
                     def on_message(self, *args):
-                        if _STOMP_V8:
-                            frame = args[0]
-                            header, message = frame.headers, frame.body
-                        else:
-                            header, message = args[0], args[1]
+                        header, message = _unpack_stomp_args(*args)
                         _log.debug("Internal on message is: {} {}".format(header, message))
 
                         self.__token = str(message)
 
                     def on_error(self, *args):
-                        if _STOMP_V8:
-                            frame = args[0]
-                            headers, message = frame.headers, frame.body
-                        else:
-                            headers, message = args[0], args[1]
+                        headers, message = _unpack_stomp_args(*args)
                         _log.error("ERR: {}".format(headers))
                         _log.error("OUR ERROR: {}".format(message))
 
@@ -404,9 +405,10 @@ class CallbackRouter(object):
             cb, hdrs, msg = self._queue_callerback.get()
             try:
                 msg = json.loads(msg)
-            except:
+            except (TypeError, ValueError):
+                # msg was not JSON text (already a dict, or plain string body);
+                # pass it through unchanged rather than as a decode failure.
                 pass
-                # msg = message
 
             for c in cb:
                 c(hdrs, msg)
@@ -429,11 +431,7 @@ class CallbackRouter(object):
                 pass
 
     def on_message(self, *args):
-        if _STOMP_V8:
-            frame = args[0]
-            headers, message = frame.headers, frame.body
-        else:
-            headers, message = args[0], args[1]
+        headers, message = _unpack_stomp_args(*args)
         destination = headers["destination"]
         # _log.debug("Topic map keys are: {keys}".format(keys=self._topics_callback_map.keys()))
         if destination in self._topics_callback_map:
@@ -442,11 +440,7 @@ class CallbackRouter(object):
             _log.error("INVALID DESTINATION {destination}".format(destination=destination))
 
     def on_error(self, *args):
-        if _STOMP_V8:
-            frame = args[0]
-            header, message = frame.headers, frame.body
-        else:
-            header, message = args[0], args[1]
+        header, message = _unpack_stomp_args(*args)
         _log.error("Error in callback router")
         _log.error(header)
         _log.error(message)

{gridappsd_python-2026.2.1a1 → gridappsd_python-2026.2.1a2}/gridappsd/gridappsd.py

@@ -116,29 +116,32 @@ class GridAPPSD(GOSS):
                 self._simulation_log_topic = t.simulation_log_topic(self._simulation_id)
         return self._simulation_id
 
-    def set_application_status(self, status):
-        """
-        Set the application status.
-        :param status:
+    def _set_status(self, status, kind):
+        """Set self._process_status, warning instead of raising on an invalid value.
+
+        :param status: candidate value for ProcessStatusEnum
+        :param kind: human readable label for the warning message, e.g. "application"
         """
         try:
             self._process_status = ProcessStatusEnum(status)
         except ValueError:
             self.get_logger().warning(
-                "Unsuccessful change of application status." + f"Valid statuses are {ProcessStatusEnum.__members__}."
+                f"Unsuccessful change of {kind} status." + f"Valid statuses are {ProcessStatusEnum.__members__}."
             )
 
+    def set_application_status(self, status):
+        """
+        Set the application status.
+        :param status:
+        """
+        self._set_status(status, "application")
+
     def set_service_status(self, status):
         """
         Set the service status.
         :param status:
         """
-        try:
-            self._process_status = ProcessStatusEnum(status)
-        except ValueError:
-            self.get_logger().warning(
-                "Unsuccessful change of service status." + f"Valid statuses are {ProcessStatusEnum.__members__}."
-            )
+        self._set_status(status, "service")
 
     def set_simulation_id(self, simulation_id):
         if simulation_id is None:
@@ -148,12 +151,16 @@ class GridAPPSD(GOSS):
             self._simulation_id = simulation_id
             self._simulation_log_topic = t.simulation_log_topic(self._simulation_id)
 
+    def _get_status(self):
+        """Return self._process_status as its plain string value."""
+        return self._process_status.value
+
     def get_application_status(self):
         """
         Return the application status
         :return:
         """
-        return self._process_status.value
+        return self._get_status()
 
     def get_application_id(self):
         return utils.get_gridappsd_application_id()
@@ -163,7 +170,7 @@ class GridAPPSD(GOSS):
         Return the service status
         :return:
         """
-        return self._process_status.value
+        return self._get_status()
 
     def query_object_types(self, model_id=None):
         """Allows the caller to query the different object types.

{gridappsd_python-2026.2.1a1 → gridappsd_python-2026.2.1a2}/gridappsd/simulation.py

@@ -58,8 +58,8 @@ class ModelCreationConfig(ConfigBase):
 class SimulationArgs(ConfigBase):
     start_time: int = field(default=1655321830)
     duration: int = field(default=300)
-    publish_period: int = field(default=None)
-    interval: int = field(default=None)
+    publish_period: int | None = field(default=None)
+    interval: int | None = field(default=None)
     run_realtime: bool = field(default=True)
     pause_after_measurements: bool = field(default=False)
     simulation_name: str = field(default="ieee13nodeckt")
@@ -75,8 +75,10 @@ class SimulationArgs(ConfigBase):
             if not self.publish_period:
                 self.publish_period = 60
         if self.publish_period < self.interval:
-            raise RuntimeError("A simulation's publishing_period cannot be less than the simulation's timestep "
-                               "interval. please make the publishing_period >= interval!")
+            raise RuntimeError(
+                "A simulation's publishing_period cannot be less than the simulation's timestep "
+                "interval. please make the publishing_period >= interval!"
+            )
 
 
 @dataclass
@@ -215,26 +217,30 @@ class Simulation:
         for p in self.__on_start:
             p(self)
 
-    def pause(self):
-        """Pause simulation"""
-        _log.debug("Pausing simulation")
-        command = dict(command="pause")
+    def _send_simulation_command(self, command_name, **command_input):
+        """Send a command to this simulation's input topic.
+
+        :param command_name: value of the command field sent to the simulation
+        :param command_input: when given, nested under the command's "input" key
+        """
+        _log.debug("Sending simulation command: {}".format(command_name))
+        command = dict(command=command_name)
+        if command_input:
+            command["input"] = command_input
         self._gapps.send(t.simulation_input_topic(self.simulation_id), json.dumps(command))
         self._running_or_paused = True
 
+    def pause(self):
+        """Pause simulation"""
+        self._send_simulation_command("pause")
+
     def stop(self):
         """Stop the simulation"""
-        _log.debug("Stopping simulation")
-        command = dict(command="stop")
-        self._gapps.send(t.simulation_input_topic(self.simulation_id), json.dumps(command))
-        self._running_or_paused = True
+        self._send_simulation_command("stop")
 
     def resume(self):
         """Resume the simulation"""
-        _log.debug("Resuming simulation")
-        command = dict(command="resume")
-        self._gapps.send(t.simulation_input_topic(self.simulation_id), json.dumps(command))
-        self._running_or_paused = True
+        self._send_simulation_command("resume")
 
     def run_loop(self):
         """Loop around the running of the simulation itself.
@@ -265,9 +271,7 @@ class Simulation:
         :param pause_in: number of seconds to run before pausing the simulation
         """
         _log.debug("Resuming simulation. Will pause after {} seconds".format(pause_in))
-        command = dict(command="resumePauseAt", input=dict(pauseIn=pause_in))
-        self._gapps.send(t.simulation_input_topic(self.simulation_id), json.dumps(command))
-        self._running_or_paused = True
+        self._send_simulation_command("resumePauseAt", pauseIn=pause_in)
 
     def add_onmeasurement_callback(self, callback, device_filter=()):
         """registers an onmeasurment callback to be called when measurements have come through.

{gridappsd_python-2026.2.1a1 → gridappsd_python-2026.2.1a2}/gridappsd/timeseries.py

@@ -46,38 +46,37 @@ class Query:
             self.last = n
         return self
 
-    def ge(self, value):
-        """Method to add 'value greater than or equal to' filter to a key.
+    def _add_filter(self, operator, value):
+        """Append a single {key, operator: value} filter for the current key.
 
-        :param value:
+        :param operator: one of "ge", "le", "eq"
+        :param value: value to filter on
         """
         if self.key is None:
             raise ValueError("Key is not specified. Call where_key first.")
-        obj = {"key": self.key, "ge": value}
-        self.queryFilter.append(obj)
+        self.queryFilter.append({"key": self.key, operator: value})
         return self
 
+    def ge(self, value):
+        """Method to add 'value greater than or equal to' filter to a key.
+
+        :param value:
+        """
+        return self._add_filter("ge", value)
+
     def le(self, value):
         """Method to add 'value less than or equal to' filter to a key.
 
         :param value:
         """
-        if self.key is None:
-            raise ValueError("Key is not specified. Call where_key first.")
-        obj = {"key": self.key, "le": value}
-        self.queryFilter.append(obj)
-        return self
+        return self._add_filter("le", value)
 
     def eq(self, value):
         """Method to add 'value equal to' filter to a key.
 
         :param value:
         """
-        if self.key is None:
-            raise ValueError("Key is not specified. Call where_key first.")
-        obj = {"key": self.key, "eq": value}
-        self.queryFilter.append(obj)
-        return self
+        return self._add_filter("eq", value)
 
     def between(self, value1, value2):
         """Method to add 'value between' value1 and value2 filter to a key.
@@ -85,13 +84,8 @@ class Query:
         :param value1: defines 'greater than equal to' filter for key's value
         :param value2: defines 'less than equal to' filter for key's value
         """
-        if self.key is None:
-            raise ValueError("Key is not specified. Call where_key first.")
-        obj = {"key": self.key, "ge": value1}
-        self.queryFilter.append(obj)
-        obj = {"key": self.key, "le": value2}
-        self.queryFilter.append(obj)
-        return self
+        self._add_filter("ge", value1)
+        return self._add_filter("le", value2)
 
     def where_key(self, key):
         self.key = key

{gridappsd_python-2026.2.1a1 → gridappsd_python-2026.2.1a2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "gridappsd-python"
-version = "2026.02.1a1"
+version = "2026.02.1a2"
 description = "A GridAPPS-D Python Adapter"
 readme = "README.md"
 license = "BSD-3-Clause"

gridappsd_python-2026.2.1a2/tests/test_app_registration.py

@@ -0,0 +1,63 @@
+"""Unit tests for gridappsd.app_registration status handling.
+
+_set_application_status writes ApplicationStatusEnum values to the
+GRIDAPPSD_APPLICATION_STATUS environment variable. These tests assert
+the exact string value written for each status, and that Job.run()
+drives the environment variable through the expected RUNNING then
+STOPPED transition for a command that exits cleanly.
+"""
+
+import os
+
+import pytest
+
+from gridappsd.app_registration import (
+    GRIDAPPSD_APPLICATION_STATUS,
+    ApplicationStatusEnum,
+    Job,
+    _set_application_status,
+)
+
+
+@pytest.fixture(autouse=True)
+def _clear_status_env(monkeypatch):
+    monkeypatch.delenv(GRIDAPPSD_APPLICATION_STATUS, raising=False)
+
+
+class TestSetApplicationStatus:
+    @pytest.mark.parametrize(
+        "status",
+        [
+            ApplicationStatusEnum.STARTING,
+            ApplicationStatusEnum.STOPPING,
+            ApplicationStatusEnum.RUNNING,
+            ApplicationStatusEnum.STOPPED,
+            ApplicationStatusEnum.ERROR,
+        ],
+    )
+    def test_writes_exact_status_value_to_environment(self, status):
+        _set_application_status(status)
+
+        assert os.environ[GRIDAPPSD_APPLICATION_STATUS] == status.value
+
+    def test_overwrites_previous_value(self):
+        _set_application_status(ApplicationStatusEnum.STARTING)
+        _set_application_status(ApplicationStatusEnum.RUNNING)
+
+        assert os.environ[GRIDAPPSD_APPLICATION_STATUS] == "RUNNING"
+
+
+class TestJobRunSetsApplicationStatus:
+    def test_successful_job_ends_in_stopped_status(self):
+        job = Job(args=["true"])
+
+        job.run()
+
+        assert os.environ[GRIDAPPSD_APPLICATION_STATUS] == ApplicationStatusEnum.STOPPED.value
+
+    def test_failing_job_ends_in_error_status(self):
+        job = Job(args=["/nonexistent-command-for-gadp-044-test"])
+
+        job.run()
+
+        assert os.environ[GRIDAPPSD_APPLICATION_STATUS] == ApplicationStatusEnum.ERROR.value

gridappsd_python-2026.2.1a2/tests/test_goss.py

@@ -0,0 +1,128 @@
+"""Unit tests for gridappsd.goss.
+
+These tests exercise the pure argument-shape and serialization helpers
+directly. They do not require a live stomp broker: GOSS is constructed
+with attempt_connection=False where a GOSS/GridAPPSD instance is needed
+at all.
+"""
+
+import pytest
+
+from gridappsd.goss import _serialize_message, _unpack_stomp_args
+
+
+class _FakeFrame:
+    """Stand in for stomp-py 8.x's Frame object.
+
+    stomp-py 8.x calls a raw listener's on_message/on_error with a single
+    object exposing .headers and .body, instead of two positional
+    arguments. This fake reproduces that shape without depending on the
+    installed stomp-py version actually being 8.x.
+    """
+
+    def __init__(self, headers, body):
+        self.headers = headers
+        self.body = body
+
+
+class TestUnpackStompArgs:
+    """Parametrized coverage of both stomp callback argument shapes."""
+
+    def test_two_positional_args_stomp_pre_8(self):
+        headers = {"destination": "/topic/foo", "reply-to": "/temp-queue/bar"}
+        body = "hello world"
+
+        unpacked_headers, unpacked_body = _unpack_stomp_args(headers, body)
+
+        assert unpacked_headers == headers
+        assert unpacked_body == body
+
+    def test_two_positional_args_preserves_dict_body(self):
+        headers = {"destination": "/topic/foo"}
+        body = {"key": "value"}
+
+        unpacked_headers, unpacked_body = _unpack_stomp_args(headers, body)
+
+        assert unpacked_headers is headers
+        assert unpacked_body is body
+
+    def test_single_frame_object_stomp_8(self):
+        headers = {"destination": "/topic/foo", "reply-to": "/temp-queue/bar"}
+        body = "hello world"
+        frame = _FakeFrame(headers, body)
+
+        unpacked_headers, unpacked_body = _unpack_stomp_args(frame)
+
+        assert unpacked_headers == headers
+        assert unpacked_body == body
+
+    def test_single_frame_object_preserves_dict_body(self):
+        headers = {"destination": "/topic/foo"}
+        body = {"key": "value"}
+        frame = _FakeFrame(headers, body)
+
+        unpacked_headers, unpacked_body = _unpack_stomp_args(frame)
+
+        assert unpacked_headers is headers
+        assert unpacked_body is body
+
+    def test_single_tuple_falls_back_to_unpacking(self):
+        headers = {"destination": "/topic/foo"}
+        body = "plain body"
+
+        unpacked_headers, unpacked_body = _unpack_stomp_args((headers, body))
+
+        assert unpacked_headers == headers
+        assert unpacked_body == body
+
+    @pytest.mark.parametrize(
+        "args,expected_headers,expected_body",
+        [
+            (({"destination": "/topic/a"}, "body-a"), {"destination": "/topic/a"}, "body-a"),
+            (({"destination": "/topic/b"}, {"nested": 1}), {"destination": "/topic/b"}, {"nested": 1}),
+        ],
+    )
+    def test_two_arg_shape_parametrized(self, args, expected_headers, expected_body):
+        unpacked_headers, unpacked_body = _unpack_stomp_args(*args)
+
+        assert unpacked_headers == expected_headers
+        assert unpacked_body == expected_body
+
+    @pytest.mark.parametrize(
+        "headers,body",
+        [
+            ({"destination": "/topic/c"}, "body-c"),
+            ({"destination": "/topic/d"}, {"nested": 2}),
+        ],
+    )
+    def test_frame_shape_parametrized(self, headers, body):
+        frame = _FakeFrame(headers, body)
+
+        unpacked_headers, unpacked_body = _unpack_stomp_args(frame)
+
+        assert unpacked_headers == headers
+        assert unpacked_body == body
+
+
+class TestSerializeMessage:
+    def test_dict_is_serialized_to_json_string(self):
+        result = _serialize_message({"a": 1, "b": 2})
+
+        assert result == '{"a": 1, "b": 2}'
+
+    def test_list_is_serialized_to_json_string(self):
+        result = _serialize_message([1, 2, 3])
+
+        assert result == "[1, 2, 3]"
+
+    def test_string_passes_through_unchanged(self):
+        result = _serialize_message("already a string")
+
+        assert result == "already a string"
+
+    def test_bytes_pass_through_unchanged(self):
+        payload = b"already bytes"
+
+        result = _serialize_message(payload)
+
+        assert result is payload

{gridappsd_python-2026.2.1a1 → gridappsd_python-2026.2.1a2}/tests/test_gridappsd.py

@@ -5,9 +5,78 @@
 
 # import mock
 
-from gridappsd import GridAPPSD
+from gridappsd import GridAPPSD, ProcessStatusEnum
+
+#, topics as t
+
+
+def _make_gappsd():
+    return GridAPPSD(attempt_connection=False, username="u", password="p")
+
+
+class TestApplicationAndServiceStatusShareState:
+    """Unit coverage for the semantics the commented out test_gridappsd_status
+    integration stub below documents: set_application_status and
+    set_service_status both mutate the same shared _process_status field,
+    and an invalid status string is silently ignored (with a warning), not
+    raised, leaving the old value in place. No live broker is required:
+    GridAPPSD is constructed with attempt_connection=False.
+    """
+
+    def test_starts_in_starting_status(self):
+        gappsd = _make_gappsd()
+
+        assert gappsd.get_application_status() == ProcessStatusEnum.STARTING.value
+        assert gappsd.get_service_status() == ProcessStatusEnum.STARTING.value
+
+    def test_set_application_status_is_visible_through_service_status(self):
+        gappsd = _make_gappsd()
+
+        gappsd.set_application_status("RUNNING")
+
+        assert gappsd.get_service_status() == ProcessStatusEnum.RUNNING.value
+        assert gappsd.get_application_status() == ProcessStatusEnum.RUNNING.value
+
+    def test_set_service_status_is_visible_through_application_status(self):
+        gappsd = _make_gappsd()
+
+        gappsd.set_service_status("COMPLETE")
+
+        assert gappsd.get_service_status() == ProcessStatusEnum.COMPLETE.value
+        assert gappsd.get_application_status() == ProcessStatusEnum.COMPLETE.value
+
+    def test_invalid_service_status_is_ignored_and_retains_old_value(self, monkeypatch):
+        # The except ValueError branch in _set_status logs a warning, and the
+        # logger reads GRIDAPPSD_APPLICATION_ID to build the log record. In
+        # production app_registration.py sets this before app code runs; here
+        # it must be set explicitly so the warning path itself does not raise.
+        monkeypatch.setenv("GRIDAPPSD_APPLICATION_ID", "test-app-id")
+        gappsd = _make_gappsd()
+        # GOSS.send() calls _make_connection() unconditionally, even though
+        # this instance was constructed with attempt_connection=False, so the
+        # logger's warning path (get_logger().warning -> Logger.log ->
+        # self._gaps.send) would otherwise open a real stomp socket. Stub the
+        # network boundary, not the status logic under test.
+        monkeypatch.setattr(gappsd, "send", lambda topic, message: None)
+        gappsd.set_service_status("COMPLETE")
+
+        gappsd.set_service_status("Foo")
+
+        assert gappsd.get_service_status() == ProcessStatusEnum.COMPLETE.value
+        assert gappsd.get_application_status() == ProcessStatusEnum.COMPLETE.value
+
+    def test_invalid_application_status_is_ignored_and_retains_old_value(self, monkeypatch):
+        monkeypatch.setenv("GRIDAPPSD_APPLICATION_ID", "test-app-id")
+        gappsd = _make_gappsd()
+        # See the comment in test_invalid_service_status_is_ignored_and_retains_old_value:
+        # the warning path on an invalid status sends a log message over stomp.
+        monkeypatch.setattr(gappsd, "send", lambda topic, message: None)
+        gappsd.set_application_status("RUNNING")
+
+        gappsd.set_application_status("NotAValidStatus")
+
+        assert gappsd.get_application_status() == ProcessStatusEnum.RUNNING.value
 
-#, topics as t, ProcessStatusEnum
 
     # def test_get_gridappsd_client(gridappsd_client: GridAPPSD):
     #     assert isinstance(gridappsd_client, GridAPPSD)

gridappsd_python-2026.2.1a2/tests/test_simulation_commands.py

@@ -0,0 +1,93 @@
+"""Unit tests for gridappsd.simulation.Simulation's command-sending methods.
+
+These tests exercise _send_simulation_command and the pause/stop/resume/
+resume_pause_at wrappers built on it, asserting the exact JSON payload sent
+and the destination topic. No live broker or docker stack is required:
+GridAPPSD is constructed with attempt_connection=False, and Simulation's
+own gapps.send call is mocked directly.
+"""
+
+from unittest import mock
+
+import gridappsd.topics as t
+from gridappsd import GridAPPSD, json_extension as json
+from gridappsd.simulation import Simulation
+
+
+def _make_simulation():
+    gapps = GridAPPSD(attempt_connection=False, username="u", password="p")
+    run_config = {"simulation_config": {"duration": 300}}
+    simulation = Simulation(gapps, run_config)
+    simulation.simulation_id = "12345"
+    return simulation
+
+
+class TestSendSimulationCommand:
+    def test_command_without_input_omits_input_key(self):
+        simulation = _make_simulation()
+
+        with mock.patch.object(simulation._gapps, "send") as mock_send:
+            simulation._send_simulation_command("pause")
+
+        mock_send.assert_called_once()
+        destination, body = mock_send.call_args[0]
+        assert destination == t.simulation_input_topic("12345")
+        assert json.loads(body) == {"command": "pause"}
+        assert simulation._running_or_paused is True
+
+    def test_command_with_input_nests_it_under_input_key(self):
+        simulation = _make_simulation()
+
+        with mock.patch.object(simulation._gapps, "send") as mock_send:
+            simulation._send_simulation_command("resumePauseAt", pauseIn=30)
+
+        destination, body = mock_send.call_args[0]
+        assert destination == t.simulation_input_topic("12345")
+        assert json.loads(body) == {"command": "resumePauseAt", "input": {"pauseIn": 30}}
+
+
+class TestPauseStopResumeWrappers:
+    def test_pause_sends_bare_pause_command(self):
+        simulation = _make_simulation()
+
+        with mock.patch.object(simulation._gapps, "send") as mock_send:
+            simulation.pause()
+
+        _, body = mock_send.call_args[0]
+        assert json.loads(body) == {"command": "pause"}
+
+    def test_stop_sends_bare_stop_command(self):
+        simulation = _make_simulation()
+
+        with mock.patch.object(simulation._gapps, "send") as mock_send:
+            simulation.stop()
+
+        _, body = mock_send.call_args[0]
+        assert json.loads(body) == {"command": "stop"}
+
+    def test_resume_sends_bare_resume_command(self):
+        simulation = _make_simulation()
+
+        with mock.patch.object(simulation._gapps, "send") as mock_send:
+            simulation.resume()
+
+        _, body = mock_send.call_args[0]
+        assert json.loads(body) == {"command": "resume"}
+
+    def test_resume_pause_at_sends_command_with_nested_pause_in(self):
+        simulation = _make_simulation()
+
+        with mock.patch.object(simulation._gapps, "send") as mock_send:
+            simulation.resume_pause_at(45)
+
+        _, body = mock_send.call_args[0]
+        assert json.loads(body) == {"command": "resumePauseAt", "input": {"pauseIn": 45}}
+
+    def test_all_wrappers_set_running_or_paused_true(self):
+        simulation = _make_simulation()
+        simulation._running_or_paused = False
+
+        with mock.patch.object(simulation._gapps, "send"):
+            simulation.pause()
+
+        assert simulation._running_or_paused is True

gridappsd_python-2026.2.1a2/tests/test_timeseries.py

@@ -0,0 +1,66 @@
+"""Unit tests for gridappsd.timeseries.Query filter building.
+
+ge/le/eq/between all delegate to the shared _add_filter helper. These
+tests assert the exact queryFilter list contents and ordering produced,
+and that a filter method called before where_key raises.
+"""
+
+import pytest
+
+from gridappsd.timeseries import Query
+
+
+class TestAddFilter:
+    def test_ge_appends_ge_filter_for_current_key(self):
+        query = Query("measurement").where_key("value")
+
+        query.ge(10)
+
+        assert query.queryFilter == [{"key": "value", "ge": 10}]
+
+    def test_le_appends_le_filter_for_current_key(self):
+        query = Query("measurement").where_key("value")
+
+        query.le(20)
+
+        assert query.queryFilter == [{"key": "value", "le": 20}]
+
+    def test_eq_appends_eq_filter_for_current_key(self):
+        query = Query("measurement").where_key("value")
+
+        query.eq(15)
+
+        assert query.queryFilter == [{"key": "value", "eq": 15}]
+
+    def test_between_appends_ge_then_le_in_order(self):
+        query = Query("measurement").where_key("value")
+
+        query.between(10, 20)
+
+        assert query.queryFilter == [
+            {"key": "value", "ge": 10},
+            {"key": "value", "le": 20},
+        ]
+
+    def test_chained_filters_on_different_keys_preserve_each_keys_filters(self):
+        query = Query("measurement")
+        query.where_key("value").ge(10)
+        query.where_key("timestamp").le(999)
+
+        assert query.queryFilter == [
+            {"key": "value", "ge": 10},
+            {"key": "timestamp", "le": 999},
+        ]
+
+    def test_filter_without_where_key_raises_value_error(self):
+        query = Query("measurement")
+
+        with pytest.raises(ValueError):
+            query.ge(10)
+
+    def test_filter_methods_return_self_for_chaining(self):
+        query = Query("measurement").where_key("value")
+
+        result = query.ge(10)
+
+        assert result is query

gridappsd_python-2026.2.1a1/tests/test_goss.py

@@ -1,204 +0,0 @@
-# import json
-# import logging
-# import os
-# import threading
-# from queue import Queue
-
-# import mock
-# import pytest
-# from time import sleep
-
-# from gridappsd import GOSS
-# from gridappsd.docker_handler import get_docker_in_docker
-# from gridappsd.goss import GRIDAPPSD_ENV_ENUM
-
-# _log = logging.getLogger(__name__)
-
-# def test_auth_raises_error_no_username_password(docker_dependencies):
-#     container = get_docker_in_docker()
-#     mockdict = {
-#         GRIDAPPSD_ENV_ENUM.GRIDAPPSD_USER.value: '',
-#         GRIDAPPSD_ENV_ENUM.GRIDAPPSD_PASSWORD.value: ''
-#     }
-#     if container:
-#         mockdict[GRIDAPPSD_ENV_ENUM.GRIDAPPSD_ADDRESS.value] = "gridappsd"
-
-#     with mock.patch.dict(os.environ, mockdict):
-#         with pytest.raises(ValueError) as ex:
-#             goss = GOSS()
-
-#         with pytest.raises(ValueError) as ex:
-#             goss = GOSS(username="foo")
-
-#         with pytest.raises(ValueError) as ex:
-#             goss = GOSS(password="bar")
-
-# def test_get_response(caplog, goss_client):
-#     caplog.set_level(logging.DEBUG)
-
-#     def addem_callback(header, message):
-#         print("Addem callback")
-#         print("Threadid: {}".format(threading.current_thread().ident))
-
-#         if isinstance(message, str):
-#             item = json.loads(message)
-#         else:
-#             item = message
-#         total = 0
-#         for x in item:
-#             total += x
-
-#         reply_to = header['reply-to']
-#         response = dict(result=total)
-#         print("Sending back topic: {topic} {response}".format(topic=reply_to,
-#                                                               response=response))
-#         goss_client.send(reply_to, json.dumps(response))
-
-#     gen_sub = []
-
-#     def generic_subscription(header, message):
-#         gen_sub.append((header, message))
-
-#     # Simulate an rpc call.
-#     goss_client.subscribe("/addem", addem_callback)
-
-#     goss_client.subscribe("foo", generic_subscription)
-
-#     # id_before = id(goss_client._conn)
-#     result = goss_client.get_response('/addem', [5, 6])
-#     assert result['result'] == 11
-#     # assert id_before == id(goss_client._conn)
-
-#     goss_client.send("foo", str(result['result']))
-
-#     count = 0
-#     while True:
-#         sleep(0.1)
-#         count += 1
-#         if len(gen_sub) > 0 or count > 10:
-#             break
-
-#     assert gen_sub
-#     assert len(gen_sub) == 1
-#     assert len(gen_sub[0]) == 2
-#     assert result['result'] == 11
-
-# def test_send_receive(goss_client):
-#     message_queue = Queue()
-
-#     class MyListener(object):
-#         def on_message(self, headers, message):
-#             message_queue.put((headers, message))
-
-#     listener = MyListener()
-#     goss_client.subscribe('doah', listener)
-#     goss_client.send('doah', "I am a foo")
-#     sleep(0.5)
-#     assert message_queue.qsize() == 1
-#     header, message = message_queue.get()
-#     assert message == "I am a foo"
-
-# def test_callback_function(goss_client):
-#     message_queue1 = Queue()
-
-#     def callback1(headers, message):
-#         message_queue1.put((headers, message))
-
-#     goss_client.subscribe('foo', callback1)
-#     goss_client.send('foo', "I am a foo")
-#     sleep(0.5)
-#     assert message_queue1.qsize() == 1
-#     header, message = message_queue1.get()
-#     assert message == "I am a foo"
-
-# def test_multi_subscriptions(goss_client):
-#     message_queue1 = Queue()
-#     message_queue2 = Queue()
-
-#     def callback1(headers, message):
-#         print(f"mq1 {headers} {message}")
-#         message_queue1.put((headers, message))
-
-#     def callback2(headers, message):
-#         print(f"mq2 {headers} {message}")
-#         message_queue2.put((headers, message))
-
-#     goss_client.subscribe('bim', callback1)
-#     goss_client.subscribe('bar', callback2)
-#     sleep(0.5)
-#     goss_client.send('bim', "I am a foo")
-#     goss_client.send('bar', "I am a bar")
-#     sleep(0.5)
-#     assert message_queue1.qsize() == 1
-#     assert message_queue2.qsize() == 1
-#     header, message = message_queue1.get()
-#     assert message == "I am a foo"
-#     header, message = message_queue2.get()
-#     assert message == "I am a bar"
-
-# def test_multi_subscriptions_same_topic(goss_client):
-#     # pytest.xfail("Multiple topics can't be subscribed to the same topic at present.")
-
-#     message_queue1 = Queue()
-#     message_queue2 = Queue()
-
-#     def callback1(headers, message):
-#         print(f"handling callback1 {message} ")
-#         message_queue1.put((headers, message))
-
-#     def callback2(headers, message):
-#         print(f"handling callback2 {message} ")
-#         message_queue2.put((headers, message))
-
-#     indx1 = goss_client.subscribe('bim', callback1)
-#     goss_client.subscribe('bim', callback2)
-#     sleep(0.5)
-#     goss_client.send('bim', "I am a foo")
-#     goss_client.send('bim', "I am a bar")
-#     sleep(0.5)
-#     assert message_queue1.qsize() == 2
-#     assert message_queue2.qsize() == 2
-#     header, message = message_queue1.get()
-#     assert message == "I am a foo"
-#     header, message = message_queue1.get()
-#     assert message == "I am a bar"
-#     header, message = message_queue2.get()
-#     assert message == "I am a foo"
-#     header, message = message_queue2.get()
-#     assert message == "I am a bar"
-
-# def test_response_class(goss_client):
-#     message_queue = Queue()
-
-#     class SubListener:
-#         def on_message(self, header, message):
-#             message_queue.put((header, message))
-
-#     goss_client.subscribe("/topic/bar", SubListener())
-#     sleep(0.5)
-#     goss_client.send("/topic/bar", {"abc": "def"})
-
-#     result = message_queue.get()
-
-#     print(result)
-#     assert result
-#     assert 2 == len(result)
-
-#     assert dict(abc="def") == result[1]
-
-# def test_replace_subscription(caplog, goss_client):
-#     caplog.set_level(logging.DEBUG)
-#     original_queue = Queue()
-#     after_queue = Queue()
-
-#     def original_callback(headers, message):
-#         original_queue.put((headers, message))
-
-#     def after_callback(headers, message):
-#         after_queue.put((headers, message))
-
-#     goss_client.subscribe("woot", original_callback)
-#     goss_client.send("woot", "This is a message")
-#     sleep(0.5)
-
-#     assert original_queue.qsize() == 1