steady-queue 0.2.1__tar.gz → 0.3.0__tar.gz

{steady_queue-0.2.1/steady_queue.egg-info → steady_queue-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steady-queue
-Version: 0.2.1
+Version: 0.3.0
 Summary: An asynchronous task library for Django that supports delayed tasks, concurrency controls, recurring tasks, pausing queues, numeric priorities per task, priorities by queue order and bulk enqueueing.
 Author-email: Elias Hernandis <elias@hernandis.me>
 License-Expression: MIT
@@ -535,8 +535,17 @@ instance that is handling the task, as well as the `task_result` (a
 `django.tasks.TaskResult` instance) with information on how the task was called
 and its status.
 
-Unlike Solid Queue, steady queue doesn't yet emit signals related to the
-lifecycle of its processes.
+Steady Queue also emits operational signals from ``steady_queue.signals``:
+
+- `process_started` and `process_stopped` when a supervisor or child process
+  enters or leaves its run loop.
+- `process_restarted` when the supervisor replaces a terminated child.
+- `queue_paused` and `queue_resumed` after queue control actions.
+
+Process signals include process identity and metadata. Queue signals include a
+`changed` flag so receivers can distinguish state transitions from idempotent
+actions. See the [configuration documentation](https://steady-queue.readthedocs.io/en/latest/configuration.html#signals)
+for the complete payloads.
 
 ## Logging
 
@@ -824,8 +833,9 @@ there are a few differences which we outline below.
   will ever be supported, but we've kept the database column for compatibility.
 - Steady Queue worker processes do not set the process name (or procline)
   because doing so requires introducing an external dependency.
-- Steady Queue does not expose rich instrumentation like Solid Queue does due to
-  the lack of a framework-native equivalent to `ActiveSupport::Notifications`.
+- Steady Queue exposes Django signals for task and operational lifecycle events,
+  but does not yet provide the full timed instrumentation event set emitted by
+  Solid Queue through `ActiveSupport::Notifications`.
 - **Priority ordering:** Steady Queue follows Django's convention where larger
   numbers indicate higher priority (e.g., a task with priority 10 runs before
   priority 0), whereas Solid Queue uses the inverse (smaller numbers = higher

{steady_queue-0.2.1 → steady_queue-0.3.0}/README.md

@@ -506,8 +506,17 @@ instance that is handling the task, as well as the `task_result` (a
 `django.tasks.TaskResult` instance) with information on how the task was called
 and its status.
 
-Unlike Solid Queue, steady queue doesn't yet emit signals related to the
-lifecycle of its processes.
+Steady Queue also emits operational signals from ``steady_queue.signals``:
+
+- `process_started` and `process_stopped` when a supervisor or child process
+  enters or leaves its run loop.
+- `process_restarted` when the supervisor replaces a terminated child.
+- `queue_paused` and `queue_resumed` after queue control actions.
+
+Process signals include process identity and metadata. Queue signals include a
+`changed` flag so receivers can distinguish state transitions from idempotent
+actions. See the [configuration documentation](https://steady-queue.readthedocs.io/en/latest/configuration.html#signals)
+for the complete payloads.
 
 ## Logging
 
@@ -795,8 +804,9 @@ there are a few differences which we outline below.
   will ever be supported, but we've kept the database column for compatibility.
 - Steady Queue worker processes do not set the process name (or procline)
   because doing so requires introducing an external dependency.
-- Steady Queue does not expose rich instrumentation like Solid Queue does due to
-  the lack of a framework-native equivalent to `ActiveSupport::Notifications`.
+- Steady Queue exposes Django signals for task and operational lifecycle events,
+  but does not yet provide the full timed instrumentation event set emitted by
+  Solid Queue through `ActiveSupport::Notifications`.
 - **Priority ordering:** Steady Queue follows Django's convention where larger
   numbers indicate higher priority (e.g., a task with priority 10 runs before
   priority 0), whereas Solid Queue uses the inverse (smaller numbers = higher

{steady_queue-0.2.1 → steady_queue-0.3.0}/steady_queue/__init__.py

@@ -1,7 +1,7 @@
 from datetime import timedelta
 from typing import Optional
 
-VERSION = (0, 2, 1)
+VERSION = (0, 3, 0)
 
 __version__ = ".".join(map(str, VERSION))
 

{steady_queue-0.2.1 → steady_queue-0.3.0}/steady_queue/app_executor.py

@@ -40,9 +40,8 @@ class AppExecutor:
                 connection.close()
             raise
         finally:
-            # Django automatically manages connection lifecycle,
-            # but we can explicitly close if needed for long-running processes
             if threading.current_thread() != threading.main_thread():
-                # Only close connections in background threads
-                # Main thread connections are handled by Django's request/response cycle
-                connection.close()
+                # Worker threads are reused without Django's request cleanup.
+                # Return connections for every initialized alias, including the
+                # application databases used by the task, to their pools.
+                connections.close_all()

{steady_queue-0.2.1 → steady_queue-0.3.0}/steady_queue/models/queue.py

@@ -2,6 +2,7 @@ from django.db import models
 
 from steady_queue.models.pause import Pause
 from steady_queue.models.ready_execution import ReadyExecution
+from steady_queue.signals import QueueLifecycle, queue_paused, queue_resumed
 
 
 class QueueQuerySet(models.QuerySet):
@@ -48,10 +49,20 @@ class Queue(models.Model):
         return not self.is_paused
 
     def pause(self) -> None:
-        Pause.objects.get_or_create(queue_name=self.queue_name)
+        _, changed = Pause.objects.get_or_create(queue_name=self.queue_name)
+        queue_paused.send(
+            sender=QueueLifecycle,
+            queue_name=self.queue_name,
+            changed=changed,
+        )
 
     def resume(self) -> None:
-        Pause.objects.filter(queue_name=self.queue_name).delete()
+        deleted, _ = Pause.objects.filter(queue_name=self.queue_name).delete()
+        queue_resumed.send(
+            sender=QueueLifecycle,
+            queue_name=self.queue_name,
+            changed=deleted > 0,
+        )
 
     def __str__(self) -> str:
         return self.queue_name

{steady_queue-0.2.1 → steady_queue-0.3.0}/steady_queue/processes/runnable.py

@@ -1,6 +1,12 @@
 import logging
 
 from steady_queue.processes.supervised import Supervised
+from steady_queue.signals import (
+    _process_signal_context,
+    _send_process_signal,
+    process_started,
+    process_stopped,
+)
 
 logger = logging.getLogger("steady_queue")
 
@@ -10,11 +16,22 @@ class Runnable(Supervised):
 
     def start(self):
         self.boot()
-
-        if self.is_running_async:
-            raise NotImplementedError
-        else:
-            self.run()
+        signal_context = _process_signal_context(self)
+        _send_process_signal(process_started, self, context=signal_context)
+
+        error = None
+        try:
+            if self.is_running_async:
+                raise NotImplementedError
+            else:
+                self.run()
+        except BaseException as exception:
+            error = exception
+            raise
+        finally:
+            _send_process_signal(
+                process_stopped, self, context=signal_context, error=error
+            )
 
     def stop(self):
         super().stop()

{steady_queue-0.2.1 → steady_queue-0.3.0}/steady_queue/processes/supervisor.py

@@ -15,6 +15,14 @@ from steady_queue.processes.pidfiled import Pidfiled
 from steady_queue.processes.registrable import Registrable
 from steady_queue.processes.signals import Signals
 from steady_queue.processes.timer import wait_until
+from steady_queue.signals import (
+    ProcessLifecycle,
+    _process_signal_context,
+    _send_process_signal,
+    process_restarted,
+    process_started,
+    process_stopped,
+)
 
 logger = logging.getLogger("steady_queue")
 
@@ -40,19 +48,35 @@ class Supervisor(Maintenance, Signals, Pidfiled, Registrable, Interruptible, Bas
         super().__init__()
 
     def start(self) -> None:
-        logger.info("starting supervisor with PID %(pid)d", {"pid": self.pid})
+        originating_pid = self.pid
+        logger.info("starting supervisor with PID %(pid)d", {"pid": originating_pid})
+        started = False
+        error = None
+        signal_context = None
         try:
-            self.boot()
-            # Fork only after resetting DB state (connections + psycopg pools).
-            self.reset_database_connections()
-            self.start_processes()
-            self.launch_maintenance_task()
-        except SystemExit:
-            logger.info("supervisor interrupted during boot, shutting down")
-            self.restore_default_signal_handlers()
-            self.shutdown()
-            return
-        self.supervise()
+            try:
+                self.boot()
+                started = True
+                signal_context = _process_signal_context(self)
+                _send_process_signal(process_started, self, context=signal_context)
+                # Fork only after resetting DB state (connections + psycopg pools).
+                self.reset_database_connections()
+                self.start_processes()
+                self.launch_maintenance_task()
+            except SystemExit:
+                logger.info("supervisor interrupted during boot, shutting down")
+                self.restore_default_signal_handlers()
+                self.shutdown()
+                return
+            self.supervise()
+        except BaseException as exception:
+            error = exception
+            raise
+        finally:
+            if started and self.pid == originating_pid:
+                _send_process_signal(
+                    process_stopped, self, context=signal_context, error=error
+                )
 
     def boot(self) -> None:
         super().boot()
@@ -80,7 +104,7 @@ class Supervisor(Maintenance, Signals, Pidfiled, Registrable, Interruptible, Bas
             logger.debug("supervisor finally block")
             self.shutdown()
 
-    def start_process(self, process: Configuration.Process) -> None:
+    def start_process(self, process: Configuration.Process) -> int:
         logger.info("starting process %(process)s", {"process": process})
         instance = process.instantiate()
         instance.supervisor = self.process
@@ -98,6 +122,7 @@ class Supervisor(Maintenance, Signals, Pidfiled, Registrable, Interruptible, Bas
         self.reset_database_connections()
         self.configured_processes[pid] = process
         self.forks[pid] = instance
+        return pid
 
     def set_procline(self) -> None:
         pass
@@ -133,14 +158,14 @@ class Supervisor(Maintenance, Signals, Pidfiled, Registrable, Interruptible, Bas
     def reap_and_replace_terminated_forks(self) -> None:
         while True:
             try:
-                pid, exitcode = os.waitpid(-1, os.WNOHANG)
+                pid, wait_status = os.waitpid(-1, os.WNOHANG)
             except ChildProcessError:
                 break
             else:
                 if not pid:
                     break
 
-            self.replace_fork(pid, exitcode)
+            self.replace_fork(pid, wait_status)
 
     def reap_terminated_forks(self) -> None:
         while True:
@@ -161,11 +186,23 @@ class Supervisor(Maintenance, Signals, Pidfiled, Registrable, Interruptible, Bas
 
             self.configured_processes.pop(pid, None)
 
-    def replace_fork(self, pid: int, exitcode: int) -> None:
+    def replace_fork(self, pid: int, wait_status: int) -> None:
+        exitcode = os.waitstatus_to_exitcode(wait_status)
         logger.info("replacing fork %s due to exit code %s", pid, exitcode)
         if terminated_fork := self.forks.pop(pid, None):
-            self.handle_claimed_jobs_by(terminated_fork, exitcode)
-            self.start_process(self.configured_processes.pop(pid))
+            self.handle_claimed_jobs_by(terminated_fork, wait_status)
+            replacement_pid = self.start_process(self.configured_processes.pop(pid))
+            process_restarted.send(
+                sender=ProcessLifecycle,
+                process_kind=terminated_fork.kind,
+                process_name=terminated_fork.name,
+                pid=pid,
+                hostname=terminated_fork.hostname,
+                metadata=terminated_fork.metadata,
+                exitcode=exitcode,
+                replacement_pid=replacement_pid,
+                supervisor_pid=self.pid,
+            )
 
     def handle_claimed_jobs_by(self, terminated_fork: Base, exitcode: int) -> None:
         if not self.process:

steady_queue-0.3.0/steady_queue/signals.py

@@ -0,0 +1,37 @@
+from django.dispatch import Signal
+
+
+class ProcessLifecycle:
+    """Public sender for process lifecycle signals."""
+
+
+class QueueLifecycle:
+    """Public sender for queue lifecycle signals."""
+
+
+# Process lifecycle signals carry stable data suitable for logs and metrics.
+process_started = Signal()
+process_stopped = Signal()
+process_restarted = Signal()
+
+# Queue control signals. Receivers get ``queue_name`` and ``changed``.
+queue_paused = Signal()
+queue_resumed = Signal()
+
+
+def _process_signal_context(process) -> dict:
+    return {
+        "process_kind": process.kind,
+        "process_name": process.name,
+        "pid": process.pid,
+        "hostname": process.hostname,
+        "metadata": process.metadata,
+    }
+
+
+def _send_process_signal(signal: Signal, process, *, context=None, **kwargs) -> None:
+    signal.send(
+        sender=ProcessLifecycle,
+        **(context or _process_signal_context(process)),
+        **kwargs,
+    )

{steady_queue-0.2.1 → steady_queue-0.3.0/steady_queue.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: steady-queue
-Version: 0.2.1
+Version: 0.3.0
 Summary: An asynchronous task library for Django that supports delayed tasks, concurrency controls, recurring tasks, pausing queues, numeric priorities per task, priorities by queue order and bulk enqueueing.
 Author-email: Elias Hernandis <elias@hernandis.me>
 License-Expression: MIT
@@ -535,8 +535,17 @@ instance that is handling the task, as well as the `task_result` (a
 `django.tasks.TaskResult` instance) with information on how the task was called
 and its status.
 
-Unlike Solid Queue, steady queue doesn't yet emit signals related to the
-lifecycle of its processes.
+Steady Queue also emits operational signals from ``steady_queue.signals``:
+
+- `process_started` and `process_stopped` when a supervisor or child process
+  enters or leaves its run loop.
+- `process_restarted` when the supervisor replaces a terminated child.
+- `queue_paused` and `queue_resumed` after queue control actions.
+
+Process signals include process identity and metadata. Queue signals include a
+`changed` flag so receivers can distinguish state transitions from idempotent
+actions. See the [configuration documentation](https://steady-queue.readthedocs.io/en/latest/configuration.html#signals)
+for the complete payloads.
 
 ## Logging
 
@@ -824,8 +833,9 @@ there are a few differences which we outline below.
   will ever be supported, but we've kept the database column for compatibility.
 - Steady Queue worker processes do not set the process name (or procline)
   because doing so requires introducing an external dependency.
-- Steady Queue does not expose rich instrumentation like Solid Queue does due to
-  the lack of a framework-native equivalent to `ActiveSupport::Notifications`.
+- Steady Queue exposes Django signals for task and operational lifecycle events,
+  but does not yet provide the full timed instrumentation event set emitted by
+  Solid Queue through `ActiveSupport::Notifications`.
 - **Priority ordering:** Steady Queue follows Django's convention where larger
   numbers indicate higher priority (e.g., a task with priority 10 runs before
   priority 0), whereas Solid Queue uses the inverse (smaller numbers = higher

{steady_queue-0.2.1 → steady_queue-0.3.0}/steady_queue.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ steady_queue/db_router.py
 steady_queue/queue_selector.py
 steady_queue/recurring_schedule.py
 steady_queue/recurring_task.py
+steady_queue/signals.py
 steady_queue/task.py
 steady_queue.egg-info/PKG-INFO
 steady_queue.egg-info/SOURCES.txt
@@ -67,6 +68,7 @@ steady_queue/processes/supervised.py
 steady_queue/processes/supervisor.py
 steady_queue/processes/timer.py
 steady_queue/processes/worker.py
+tests/test_app_executor.py
 tests/test_arguments.py
 tests/test_backend.py
 tests/test_concurrency_controls.py
@@ -75,6 +77,7 @@ tests/test_db_router.py
 tests/test_executions.py
 tests/test_fork_safety.py
 tests/test_job.py
+tests/test_observability_signals.py
 tests/test_pidfile.py
 tests/test_process_lifecycle.py
 tests/test_queue_selector.py

steady_queue-0.3.0/tests/test_app_executor.py

@@ -0,0 +1,84 @@
+from concurrent.futures import ThreadPoolExecutor
+from unittest import skipUnless
+
+from django.db import connections, transaction
+from django.test import TransactionTestCase
+
+from steady_queue.app_executor import AppExecutor
+from tests.dummy.models import Dummy
+
+
+@skipUnless(
+    connections["default"].vendor == "postgresql",
+    "Requires PostgreSQL application connection pooling",
+)
+class AppExecutorConnectionsTest(TransactionTestCase):
+    databases = {"default", "queue"}
+
+    def setUp(self):
+        self.application = connections["default"]
+        self.application.close()
+        self.application.close_pool()
+        self.original_options = self.application.settings_dict["OPTIONS"]
+        self.application.settings_dict["OPTIONS"] = {
+            **self.original_options,
+            "pool": {"min_size": 0, "max_size": 1, "timeout": 0.25},
+        }
+        self.addCleanup(self.restore_application_pool)
+
+    def restore_application_pool(self):
+        self.application.close()
+        self.application.close_pool()
+        self.application.settings_dict["OPTIONS"] = self.original_options
+
+    @staticmethod
+    def perform_task(*, fail=False):
+        with AppExecutor.wrap_in_app_executor():
+            Dummy.objects.count()
+            if fail:
+                raise ValueError("Task failed")
+        return (
+            connections["default"].connection is None,
+            connections["queue"].connection is None,
+        )
+
+    def assert_pool_reusable_by_another_worker(self, *, fail=False):
+        # Keep both threads alive: ending a thread must not stand in for the
+        # per-task cleanup that long-lived worker threads need.
+        workers = [ThreadPoolExecutor(max_workers=1) for _ in range(2)]
+        try:
+            first = workers[0].submit(self.perform_task, fail=fail)
+            if fail:
+                with self.assertRaisesMessage(ValueError, "Task failed"):
+                    first.result(timeout=5)
+            else:
+                first.result(timeout=5)
+
+            # A leaked application connection leaves this separate thread
+            # unable to borrow the only connection in the application pool.
+            state = workers[1].submit(self.perform_task).result(timeout=5)
+            self.assertEqual(state, (True, True))
+            self.assertEqual(self.application.pool.get_stats()["pool_available"], 1)
+        finally:
+            for worker in workers:
+                worker.submit(connections.close_all).result(timeout=5)
+                worker.shutdown()
+
+    def test_success_returns_application_connection_for_other_workers(self):
+        self.assert_pool_reusable_by_another_worker()
+
+    def test_failure_returns_application_connection_for_other_workers(self):
+        self.assert_pool_reusable_by_another_worker(fail=True)
+
+    def test_main_thread_preserves_callers_connections_and_transaction(self):
+        connections["queue"].ensure_connection()
+        queue_connection = connections["queue"].connection
+        with transaction.atomic():
+            Dummy.objects.count()
+            application_connection = self.application.connection
+            with AppExecutor.wrap_in_app_executor():
+                Dummy.objects.count()
+            self.assertIs(self.application.connection, application_connection)
+            self.assertIs(connections["queue"].connection, queue_connection)
+            self.assertTrue(self.application.in_atomic_block)
+            Dummy.objects.count()

steady_queue-0.3.0/tests/test_observability_signals.py

@@ -0,0 +1,203 @@
+import os
+from unittest.mock import MagicMock, patch
+
+from django.test import SimpleTestCase, TestCase
+
+from steady_queue.configuration import Configuration
+from steady_queue.models import Job, Queue
+from steady_queue.processes.base import Base
+from steady_queue.processes.runnable import Runnable
+from steady_queue.processes.supervisor import Supervisor
+from steady_queue.signals import (
+    ProcessLifecycle,
+    QueueLifecycle,
+    process_restarted,
+    process_started,
+    process_stopped,
+    queue_paused,
+    queue_resumed,
+)
+from tests.dummy.tasks import dummy_task
+
+
+class FakeRunnable(Runnable, Base):
+    mode = "inline"
+
+    def run(self):
+        pass
+
+
+class ProcessLifecycleSignalTests(SimpleTestCase):
+    def test_runnable_emits_started_and_stopped_with_operational_context(self):
+        process = FakeRunnable()
+        started = MagicMock()
+        stopped = MagicMock()
+
+        process_started.connect(started)
+        process_stopped.connect(stopped)
+        self.addCleanup(process_started.disconnect, started)
+        self.addCleanup(process_stopped.disconnect, stopped)
+
+        process.start()
+
+        started.assert_called_once_with(
+            signal=process_started,
+            sender=ProcessLifecycle,
+            process_kind="fakerunnable",
+            process_name=process.name,
+            pid=process.pid,
+            hostname=process.hostname,
+            metadata={},
+        )
+        stopped.assert_called_once_with(
+            signal=process_stopped,
+            sender=ProcessLifecycle,
+            process_kind="fakerunnable",
+            process_name=process.name,
+            pid=process.pid,
+            hostname=process.hostname,
+            metadata={},
+            error=None,
+        )
+
+    def test_stopped_signal_includes_run_error(self):
+        process = FakeRunnable()
+        error = RuntimeError("broken")
+        stopped = MagicMock()
+        process.run = MagicMock(side_effect=error)
+
+        process_stopped.connect(stopped)
+        self.addCleanup(process_stopped.disconnect, stopped)
+
+        with self.assertRaises(RuntimeError):
+            process.start()
+
+        self.assertIs(stopped.call_args.kwargs["error"], error)
+
+    def test_forked_child_does_not_emit_supervisor_stopped(self):
+        supervisor = Supervisor(Configuration(Configuration.Options()))
+        originating_pid = os.getpid()
+        read_fd, write_fd = os.pipe()
+        child_pids = []
+
+        def record_stop(**kwargs):
+            message = f"{os.getpid()}:{kwargs['pid']}\n".encode()
+            os.write(write_fd, message)
+
+        def fork_child():
+            pid = os.fork()
+            if pid == 0:
+                os.close(read_fd)
+                raise SystemExit
+            child_pids.append(pid)
+
+        process_stopped.connect(record_stop)
+        try:
+            with (
+                patch.object(supervisor, "boot"),
+                patch.object(supervisor, "reset_database_connections"),
+                patch.object(supervisor, "start_processes", side_effect=fork_child),
+                patch.object(supervisor, "launch_maintenance_task"),
+                patch.object(supervisor, "restore_default_signal_handlers"),
+                patch.object(supervisor, "shutdown"),
+                patch.object(supervisor, "supervise"),
+            ):
+                supervisor.start()
+
+            if os.getpid() != originating_pid:
+                os.close(write_fd)
+                os._exit(0)
+
+            os.waitpid(child_pids[0], 0)
+            os.close(write_fd)
+            write_fd = None
+            records = os.read(read_fd, 4096).decode().splitlines()
+        finally:
+            process_stopped.disconnect(record_stop)
+            os.close(read_fd)
+            if write_fd is not None:
+                os.close(write_fd)
+
+        self.assertEqual(records, [f"{originating_pid}:{originating_pid}"])
+
+    def test_supervisor_emits_restart_after_replacing_child(self):
+        supervisor = Supervisor(Configuration(Configuration.Options()))
+        terminated = FakeRunnable()
+        configured = MagicMock()
+        supervisor.forks[123] = terminated
+        supervisor.configured_processes[123] = configured
+        restarted = MagicMock()
+
+        process_restarted.connect(restarted)
+        self.addCleanup(process_restarted.disconnect, restarted)
+
+        with (
+            patch.object(supervisor, "handle_claimed_jobs_by") as recover_jobs,
+            patch.object(supervisor, "start_process", return_value=456),
+        ):
+            supervisor.replace_fork(123, 7 << 8)
+
+        recover_jobs.assert_called_once_with(terminated, 7 << 8)
+        restarted.assert_called_once_with(
+            signal=process_restarted,
+            sender=ProcessLifecycle,
+            process_kind="fakerunnable",
+            process_name=terminated.name,
+            pid=123,
+            hostname=terminated.hostname,
+            metadata={},
+            exitcode=7,
+            replacement_pid=456,
+            supervisor_pid=supervisor.pid,
+        )
+
+
+class QueueLifecycleSignalTests(TestCase):
+    databases = {"default", "queue"}
+
+    def setUp(self):
+        Job.objects.enqueue(dummy_task, [], {})
+        self.queue = Queue.objects.get(queue_name="default")
+
+    def test_pause_and_resume_report_real_and_idempotent_actions(self):
+        paused = MagicMock()
+        resumed = MagicMock()
+        queue_paused.connect(paused)
+        queue_resumed.connect(resumed)
+        self.addCleanup(queue_paused.disconnect, paused)
+        self.addCleanup(queue_resumed.disconnect, resumed)
+
+        self.queue.pause()
+        self.queue.pause()
+        self.queue.resume()
+        self.queue.resume()
+
+        self.assertEqual(
+            [call.kwargs["changed"] for call in paused.call_args_list], [True, False]
+        )
+        self.assertEqual(
+            [call.kwargs["changed"] for call in resumed.call_args_list], [True, False]
+        )
+        self.assertTrue(
+            all(
+                call.kwargs["queue_name"] == "default" for call in paused.call_args_list
+            )
+        )
+        self.assertTrue(
+            all("queue" not in call.kwargs for call in paused.call_args_list)
+        )
+        self.assertTrue(
+            all("queue" not in call.kwargs for call in resumed.call_args_list)
+        )
+        self.assertTrue(
+            all(
+                call.kwargs["sender"] is QueueLifecycle
+                for call in paused.call_args_list
+            )
+        )
+        self.assertTrue(
+            all(
+                call.kwargs["sender"] is QueueLifecycle
+                for call in resumed.call_args_list
+            )
+        )