dbos 0.21.0a4__tar.gz → 0.21.0a5__tar.gz

{dbos-0.21.0a4 → dbos-0.21.0a5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbos
-Version: 0.21.0a4
+Version: 0.21.0a5
 Summary: Ultra-lightweight durable execution in Python
 Author-Email: "DBOS, Inc." <contact@dbos.dev>
 License: MIT

{dbos-0.21.0a4 → dbos-0.21.0a5}/dbos/_dbos_config.py

@@ -123,7 +123,10 @@ def get_dbos_database_url(config_file_path: str = DBOS_CONFIG_PATH) -> str:
 
 
 def load_config(
-    config_file_path: str = DBOS_CONFIG_PATH, *, use_db_wizard: bool = True
+    config_file_path: str = DBOS_CONFIG_PATH,
+    *,
+    use_db_wizard: bool = True,
+    silent: bool = False,
 ) -> ConfigFile:
     """
     Load the DBOS `ConfigFile` from the specified path (typically `dbos-config.yaml`).
@@ -188,18 +191,19 @@ def load_config(
     # Load the DB connection file. Use its values for missing fields from dbos-config.yaml. Use defaults otherwise.
     data = cast(ConfigFile, data)
     db_connection = load_db_connection()
-    if data["database"].get("hostname"):
-        print(
-            "[bold blue]Loading database connection parameters from dbos-config.yaml[/bold blue]"
-        )
-    elif db_connection.get("hostname"):
-        print(
-            "[bold blue]Loading database connection parameters from .dbos/db_connection[/bold blue]"
-        )
-    else:
-        print(
-            "[bold blue]Using default database connection parameters (localhost)[/bold blue]"
-        )
+    if not silent:
+        if data["database"].get("hostname"):
+            print(
+                "[bold blue]Loading database connection parameters from dbos-config.yaml[/bold blue]"
+            )
+        elif db_connection.get("hostname"):
+            print(
+                "[bold blue]Loading database connection parameters from .dbos/db_connection[/bold blue]"
+            )
+        else:
+            print(
+                "[bold blue]Using default database connection parameters (localhost)[/bold blue]"
+            )
 
     data["database"]["hostname"] = (
         data["database"].get("hostname") or db_connection.get("hostname") or "localhost"

{dbos-0.21.0a4 → dbos-0.21.0a5}/dbos/_sys_db.py

@@ -126,6 +126,15 @@ class GetWorkflowsInput:
         )
 
 
+class GetQueuedWorkflowsInput(TypedDict):
+    queue_name: Optional[str]
+    status: Optional[str]
+    start_time: Optional[str]  # Timestamp in ISO 8601 format
+    end_time: Optional[str]  # Timestamp in ISO 8601 format
+    limit: Optional[int]  # Return up to this many workflows IDs.
+    name: Optional[str]  # The name of the workflow function
+
+
 class GetWorkflowsOutput:
     def __init__(self, workflow_uuids: List[str]):
         self.workflow_uuids = workflow_uuids
@@ -658,7 +667,6 @@ class SystemDatabase:
         query = sa.select(SystemSchema.workflow_status.c.workflow_uuid).order_by(
             SystemSchema.workflow_status.c.created_at.desc()
         )
-
         if input.name:
             query = query.where(SystemSchema.workflow_status.c.name == input.name)
         if input.authenticated_user:
@@ -692,6 +700,52 @@ class SystemDatabase:
 
         return GetWorkflowsOutput(workflow_uuids)
 
+    def get_queued_workflows(
+        self, input: GetQueuedWorkflowsInput
+    ) -> GetWorkflowsOutput:
+
+        query = (
+            sa.select(SystemSchema.workflow_queue.c.workflow_uuid)
+            .join(
+                SystemSchema.workflow_status,
+                SystemSchema.workflow_queue.c.workflow_uuid
+                == SystemSchema.workflow_status.c.workflow_uuid,
+            )
+            .order_by(SystemSchema.workflow_status.c.created_at.desc())
+        )
+
+        if input.get("name"):
+            query = query.where(SystemSchema.workflow_status.c.name == input["name"])
+
+        if input.get("queue_name"):
+            query = query.where(
+                SystemSchema.workflow_queue.c.queue_name == input["queue_name"]
+            )
+
+        if input.get("status"):
+            query = query.where(
+                SystemSchema.workflow_status.c.status == input["status"]
+            )
+        if "start_time" in input and input["start_time"] is not None:
+            query = query.where(
+                SystemSchema.workflow_status.c.created_at
+                >= datetime.datetime.fromisoformat(input["start_time"]).timestamp()
+                * 1000
+            )
+        if "end_time" in input and input["end_time"] is not None:
+            query = query.where(
+                SystemSchema.workflow_status.c.created_at
+                <= datetime.datetime.fromisoformat(input["end_time"]).timestamp() * 1000
+            )
+        if input.get("limit"):
+            query = query.limit(input["limit"])
+
+        with self.engine.begin() as c:
+            rows = c.execute(query)
+        workflow_uuids = [row[0] for row in rows]
+
+        return GetWorkflowsOutput(workflow_uuids)
+
     def get_pending_workflows(self, executor_id: str) -> list[str]:
         with self.engine.begin() as c:
             rows = c.execute(

{dbos-0.21.0a4 → dbos-0.21.0a5}/dbos/_workflow_commands.py

@@ -5,6 +5,7 @@ import typer
 from . import _serialization
 from ._dbos_config import ConfigFile
 from ._sys_db import (
+    GetQueuedWorkflowsInput,
     GetWorkflowsInput,
     GetWorkflowsOutput,
     SystemDatabase,
@@ -19,8 +20,8 @@ class WorkflowInformation:
     workflowClassName: Optional[str]
     workflowConfigName: Optional[str]
     input: Optional[_serialization.WorkflowInputs]  # JSON (jsonpickle)
-    output: Optional[str]  # JSON (jsonpickle)
-    error: Optional[str]  # JSON (jsonpickle)
+    output: Optional[str] = None  # JSON (jsonpickle)
+    error: Optional[str] = None  # JSON (jsonpickle)
     executor_id: Optional[str]
     app_version: Optional[str]
     app_id: Optional[str]
@@ -34,17 +35,15 @@ class WorkflowInformation:
 
 def list_workflows(
     config: ConfigFile,
-    li: int,
+    limit: int,
     user: Optional[str],
     starttime: Optional[str],
     endtime: Optional[str],
     status: Optional[str],
     request: bool,
     appversion: Optional[str],
+    name: Optional[str],
 ) -> List[WorkflowInformation]:
-
-    sys_db = None
-
     try:
         sys_db = SystemDatabase(config)
 
@@ -55,24 +54,55 @@ def list_workflows(
         if status is not None:
             input.status = cast(WorkflowStatuses, status)
         input.application_version = appversion
-        input.limit = li
+        input.limit = limit
+        input.name = name
 
         output: GetWorkflowsOutput = sys_db.get_workflows(input)
-
         infos: List[WorkflowInformation] = []
+        for workflow_id in output.workflow_uuids:
+            info = _get_workflow_info(
+                sys_db, workflow_id, request
+            )  # Call the method for each ID
+            if info is not None:
+                infos.append(info)
+
+        return infos
+    except Exception as e:
+        typer.echo(f"Error listing workflows: {e}")
+        return []
+    finally:
+        if sys_db:
+            sys_db.destroy()
 
-        if output.workflow_uuids is None:
-            typer.echo("No workflows found")
-            return {}
 
+def list_queued_workflows(
+    config: ConfigFile,
+    limit: Optional[int] = None,
+    start_time: Optional[str] = None,
+    end_time: Optional[str] = None,
+    queue_name: Optional[str] = None,
+    status: Optional[str] = None,
+    name: Optional[str] = None,
+    request: bool = False,
+) -> List[WorkflowInformation]:
+    try:
+        sys_db = SystemDatabase(config)
+        input: GetQueuedWorkflowsInput = {
+            "queue_name": queue_name,
+            "start_time": start_time,
+            "end_time": end_time,
+            "status": status,
+            "limit": limit,
+            "name": name,
+        }
+        output: GetWorkflowsOutput = sys_db.get_queued_workflows(input)
+        infos: List[WorkflowInformation] = []
         for workflow_id in output.workflow_uuids:
             info = _get_workflow_info(
                 sys_db, workflow_id, request
             )  # Call the method for each ID
-
             if info is not None:
                 infos.append(info)
-
         return infos
     except Exception as e:
         typer.echo(f"Error listing workflows: {e}")

{dbos-0.21.0a4 → dbos-0.21.0a5}/dbos/cli/cli.py

@@ -19,14 +19,21 @@ from .. import load_config
 from .._app_db import ApplicationDatabase
 from .._dbos_config import _is_valid_app_name
 from .._sys_db import SystemDatabase, reset_system_database
-from .._workflow_commands import cancel_workflow, get_workflow, list_workflows
+from .._workflow_commands import (
+    cancel_workflow,
+    get_workflow,
+    list_queued_workflows,
+    list_workflows,
+)
 from ..cli._github_init import create_template_from_github
 from ._template_init import copy_template, get_project_name, get_templates_directory
 
 app = typer.Typer()
 workflow = typer.Typer()
+queue = typer.Typer()
 
 app.add_typer(workflow, name="workflow", help="Manage DBOS workflows")
+workflow.add_typer(queue, name="queue", help="Manage enqueued workflows")
 
 
 def _on_windows() -> bool:
@@ -272,18 +279,22 @@ def list(
             help="Retrieve workflows with this application version",
         ),
     ] = None,
+    name: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--name",
+            "-n",
+            help="Retrieve workflows with this name",
+        ),
+    ] = None,
     request: Annotated[
         bool,
         typer.Option("--request", help="Retrieve workflow request information"),
     ] = True,
-    appdir: Annotated[
-        typing.Optional[str],
-        typer.Option("--app-dir", "-d", help="Specify the application root directory"),
-    ] = None,
 ) -> None:
-    config = load_config()
+    config = load_config(silent=True)
     workflows = list_workflows(
-        config, limit, user, starttime, endtime, status, request, appversion
+        config, limit, user, starttime, endtime, status, request, appversion, name
     )
     print(jsonpickle.encode(workflows, unpicklable=False))
 
@@ -291,16 +302,12 @@ def list(
 @workflow.command(help="Retrieve the status of a workflow")
 def get(
     uuid: Annotated[str, typer.Argument()],
-    appdir: Annotated[
-        typing.Optional[str],
-        typer.Option("--app-dir", "-d", help="Specify the application root directory"),
-    ] = None,
     request: Annotated[
         bool,
         typer.Option("--request", help="Retrieve workflow request information"),
     ] = True,
 ) -> None:
-    config = load_config()
+    config = load_config(silent=True)
     print(jsonpickle.encode(get_workflow(config, uuid, request), unpicklable=False))
 
 
@@ -309,10 +316,6 @@ def get(
 )
 def cancel(
     uuid: Annotated[str, typer.Argument()],
-    appdir: Annotated[
-        typing.Optional[str],
-        typer.Option("--app-dir", "-d", help="Specify the application root directory"),
-    ] = None,
 ) -> None:
     config = load_config()
     cancel_workflow(config, uuid)
@@ -363,5 +366,70 @@ def restart(
         print(f"Failed to resume workflow {uuid}. Status code: {response.status_code}")
 
 
+@queue.command(name="list", help="List enqueued functions for your application")
+def list_queue(
+    limit: Annotated[
+        typing.Optional[int],
+        typer.Option("--limit", "-l", help="Limit the results returned"),
+    ] = None,
+    start_time: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--start-time",
+            "-s",
+            help="Retrieve functions starting after this timestamp (ISO 8601 format)",
+        ),
+    ] = None,
+    end_time: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--end-time",
+            "-e",
+            help="Retrieve functions starting before this timestamp (ISO 8601 format)",
+        ),
+    ] = None,
+    status: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--status",
+            "-S",
+            help="Retrieve functions with this status (PENDING, SUCCESS, ERROR, RETRIES_EXCEEDED, ENQUEUED, or CANCELLED)",
+        ),
+    ] = None,
+    queue_name: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--queue-name",
+            "-q",
+            help="Retrieve functions on this queue",
+        ),
+    ] = None,
+    name: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--name",
+            "-n",
+            help="Retrieve functions on this queue",
+        ),
+    ] = None,
+    request: Annotated[
+        bool,
+        typer.Option("--request", help="Retrieve workflow request information"),
+    ] = True,
+) -> None:
+    config = load_config(silent=True)
+    workflows = list_queued_workflows(
+        config=config,
+        limit=limit,
+        start_time=start_time,
+        end_time=end_time,
+        queue_name=queue_name,
+        status=status,
+        request=request,
+        name=name,
+    )
+    print(jsonpickle.encode(workflows, unpicklable=False))
+
+
 if __name__ == "__main__":
     app()

{dbos-0.21.0a4 → dbos-0.21.0a5}/pyproject.toml

@@ -27,7 +27,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "0.21.0a4"
+version = "0.21.0a5"
 
 [project.license]
 text = "MIT"

{dbos-0.21.0a4 → dbos-0.21.0a5}/tests/test_admin_server.py

@@ -165,7 +165,7 @@ def test_admin_workflow_resume(dbos: DBOS, config: ConfigFile) -> None:
 
     # Verify the workflow has succeeded
     output = _workflow_commands.list_workflows(
-        config, 10, None, None, None, None, False, None
+        config, 10, None, None, None, None, False, None, None
     )
     assert len(output) == 1, f"Expected list length to be 1, but got {len(output)}"
     assert output[0] != None, "Expected output to be not None"
@@ -219,7 +219,7 @@ def test_admin_workflow_restart(dbos: DBOS, config: ConfigFile) -> None:
 
     # get the workflow list
     output = _workflow_commands.list_workflows(
-        config, 10, None, None, None, None, False, None
+        config, 10, None, None, None, None, False, None, None
     )
     assert len(output) == 1, f"Expected list length to be 1, but got {len(output)}"
 
@@ -257,7 +257,7 @@ def test_admin_workflow_restart(dbos: DBOS, config: ConfigFile) -> None:
         assert False, "Expected info to be not None"
 
     output = _workflow_commands.list_workflows(
-        config, 10, None, None, None, None, False, None
+        config, 10, None, None, None, None, False, None, None
     )
     assert len(output) == 2, f"Expected list length to be 2, but got {len(output)}"
 

{dbos-0.21.0a4 → dbos-0.21.0a5}/tests/test_package.py

@@ -8,6 +8,7 @@ import time
 import urllib.error
 import urllib.request
 
+import requests
 import sqlalchemy as sa
 import yaml
 
@@ -147,3 +148,48 @@ def test_reset(postgres_db_engine: sa.Engine) -> None:
                 )
             ).scalar()
             assert result == 0
+
+
+def test_list_commands() -> None:
+    app_name = "reset-app"
+    with tempfile.TemporaryDirectory() as temp_path:
+        subprocess.check_call(
+            ["dbos", "init", app_name, "--template", "dbos-toolbox"],
+            cwd=temp_path,
+        )
+        subprocess.check_call(["dbos", "reset", "-y"], cwd=temp_path)
+        subprocess.check_call(["dbos", "migrate"], cwd=temp_path)
+
+        # Get some workflows enqueued on the toolbox, then kill the toolbox
+        process = subprocess.Popen(["dbos", "start"], cwd=temp_path)
+        try:
+            session = requests.Session()
+            for i in range(10):
+                try:
+                    session.get(
+                        "http://localhost:8000/queue", timeout=1
+                    ).raise_for_status()
+                    break
+                except requests.exceptions.Timeout:
+                    break
+                except requests.exceptions.ConnectionError as e:
+                    if i == 9:
+                        raise
+                    print(f"Attempt {i+1} failed: {e}. Retrying in 1 second...")
+                    time.sleep(1)
+            time.sleep(1)  # So the queued workflows can start
+        finally:
+            os.kill(process.pid, signal.SIGINT)
+            process.wait()
+
+        # Verify the output is valid JSON
+        output = subprocess.check_output(["dbos", "workflow", "list"], cwd=temp_path)
+        data = json.loads(output)
+        assert isinstance(data, list) and len(data) == 10
+
+        # Verify the output is valid JSON
+        output = subprocess.check_output(
+            ["dbos", "workflow", "queue", "list"], cwd=temp_path
+        )
+        data = json.loads(output)
+        assert isinstance(data, list) and len(data) == 10

{dbos-0.21.0a4 → dbos-0.21.0a5}/tests/test_workflow_cmds.py

@@ -1,22 +1,9 @@
-import logging
 import threading
 import time
-import uuid
-from datetime import datetime, timedelta
-from typing import List, cast
-
-import pytest
-import sqlalchemy as sa
+from datetime import datetime, timedelta, timezone
 
 # Public API
-from dbos import (
-    DBOS,
-    ConfigFile,
-    SetWorkflowID,
-    WorkflowHandle,
-    WorkflowStatusString,
-    _workflow_commands,
-)
+from dbos import DBOS, ConfigFile, Queue, WorkflowStatusString, _workflow_commands
 
 
 def test_list_workflow(dbos: DBOS, config: ConfigFile) -> None:
@@ -32,7 +19,7 @@ def test_list_workflow(dbos: DBOS, config: ConfigFile) -> None:
     time.sleep(1)  # wait for the workflow to complete
     # get the workflow list
     output = _workflow_commands.list_workflows(
-        config, 10, None, None, None, None, False, None
+        config, 10, None, None, None, None, False, None, None
     )
     assert len(output) == 1, f"Expected list length to be 1, but got {len(output)}"
     assert output[0] != None, "Expected output to be not None"
@@ -55,12 +42,12 @@ def test_list_workflow_limit(dbos: DBOS, config: ConfigFile) -> None:
     time.sleep(1)  # wait for the workflow to complete
     # get the workflow list
     output = _workflow_commands.list_workflows(
-        config, 2, None, None, None, None, False, None
+        config, 2, None, None, None, None, False, None, None
     )
     assert len(output) == 2, f"Expected list length to be 1, but got {len(output)}"
 
 
-def test_list_workflow_status(dbos: DBOS, config: ConfigFile) -> None:
+def test_list_workflow_status_name(dbos: DBOS, config: ConfigFile) -> None:
     print("Testing list_workflow")
 
     @DBOS.workflow()
@@ -73,12 +60,22 @@ def test_list_workflow_status(dbos: DBOS, config: ConfigFile) -> None:
     time.sleep(1)  # wait for the workflow to complete
     # get the workflow list
     output = _workflow_commands.list_workflows(
-        config, 10, None, None, None, "PENDING", False, None
+        config, 10, None, None, None, "PENDING", False, None, None
+    )
+    assert len(output) == 0, f"Expected list length to be 0, but got {len(output)}"
+
+    output = _workflow_commands.list_workflows(
+        config, 10, None, None, None, "SUCCESS", False, None, None
+    )
+    assert len(output) == 1, f"Expected list length to be 1, but got {len(output)}"
+
+    output = _workflow_commands.list_workflows(
+        config, 10, None, None, None, None, False, None, "no"
     )
     assert len(output) == 0, f"Expected list length to be 0, but got {len(output)}"
 
     output = _workflow_commands.list_workflows(
-        config, 10, None, None, None, "SUCCESS", False, None
+        config, 10, None, None, None, None, False, None, simple_workflow.__qualname__
     )
     assert len(output) == 1, f"Expected list length to be 1, but got {len(output)}"
 
@@ -103,7 +100,7 @@ def test_list_workflow_start_end_times(dbos: DBOS, config: ConfigFile) -> None:
     print(endtime)
 
     output = _workflow_commands.list_workflows(
-        config, 10, None, starttime, endtime, None, False, None
+        config, 10, None, starttime, endtime, None, False, None, None
     )
     assert len(output) == 1, f"Expected list length to be 1, but got {len(output)}"
 
@@ -111,7 +108,7 @@ def test_list_workflow_start_end_times(dbos: DBOS, config: ConfigFile) -> None:
     newendtime = starttime
 
     output = _workflow_commands.list_workflows(
-        config, 10, None, newstarttime, newendtime, None, False, None
+        config, 10, None, newstarttime, newendtime, None, False, None, None
     )
     assert len(output) == 0, f"Expected list length to be 0, but got {len(output)}"
 
@@ -142,19 +139,19 @@ def test_list_workflow_end_times_positive(dbos: DBOS, config: ConfigFile) -> Non
     time_3 = datetime.now().isoformat()
 
     output = _workflow_commands.list_workflows(
-        config, 10, None, time_0, time_1, None, False, None
+        config, 10, None, time_0, time_1, None, False, None, None
     )
 
     assert len(output) == 0, f"Expected list length to be 0, but got {len(output)}"
 
     output = _workflow_commands.list_workflows(
-        config, 10, None, time_1, time_2, None, False, None
+        config, 10, None, time_1, time_2, None, False, None, None
     )
 
     assert len(output) == 1, f"Expected list length to be 1, but got {len(output)}"
 
     output = _workflow_commands.list_workflows(
-        config, 10, None, time_1, time_3, None, False, None
+        config, 10, None, time_1, time_3, None, False, None, None
     )
     assert len(output) == 2, f"Expected list length to be 2, but got {len(output)}"
 
@@ -172,7 +169,7 @@ def test_get_workflow(dbos: DBOS, config: ConfigFile) -> None:
     time.sleep(1)  # wait for the workflow to complete
     # get the workflow list
     output = _workflow_commands.list_workflows(
-        config, 10, None, None, None, None, False, None
+        config, 10, None, None, None, None, False, None, None
     )
     assert len(output) == 1, f"Expected list length to be 1, but got {len(output)}"
 
@@ -200,7 +197,7 @@ def test_cancel_workflow(dbos: DBOS, config: ConfigFile) -> None:
     simple_workflow()
     # get the workflow list
     output = _workflow_commands.list_workflows(
-        config, 10, None, None, None, None, False, None
+        config, 10, None, None, None, None, False, None, None
     )
     # assert len(output) == 1, f"Expected list length to be 1, but got {len(output)}"
 
@@ -214,3 +211,79 @@ def test_cancel_workflow(dbos: DBOS, config: ConfigFile) -> None:
     assert info is not None, "Expected info to be not None"
     if info is not None:
         assert info.status == "CANCELLED", f"Expected status to be CANCELLED"
+
+
+def test_queued_workflows(dbos: DBOS, config: ConfigFile) -> None:
+    queued_steps = 5
+    step_events = [threading.Event() for _ in range(queued_steps)]
+    event = threading.Event()
+    queue = Queue("test_queue")
+
+    @DBOS.workflow()
+    def test_workflow() -> list[int]:
+        handles = []
+        for i in range(queued_steps):
+            h = queue.enqueue(blocking_step, i)
+            handles.append(h)
+        return [h.get_result() for h in handles]
+
+    @DBOS.step()
+    def blocking_step(i: int) -> int:
+        step_events[i].set()
+        event.wait()
+        return i
+
+    # The workflow enqueues blocking steps, wait for all to start
+    handle = DBOS.start_workflow(test_workflow)
+    for e in step_events:
+        e.wait()
+
+    # Verify all blocking steps are enqueued and have the right data
+    workflows = _workflow_commands.list_queued_workflows(config)
+    assert len(workflows) == queued_steps
+    for i, workflow in enumerate(workflows):
+        assert workflow.status == WorkflowStatusString.PENDING.value
+        assert workflow.queue_name == queue.name
+        assert workflow.input is not None
+        # Verify newest queue entries appear first
+        assert workflow.input["args"][0] == queued_steps - i - 1
+        assert workflow.output is None
+        assert workflow.error is None
+        assert "blocking_step" in workflow.workflowName
+
+    # Test every filter
+    workflows = _workflow_commands.list_queued_workflows(
+        config, status=WorkflowStatusString.PENDING.value
+    )
+    assert len(workflows) == queued_steps
+    workflows = _workflow_commands.list_queued_workflows(
+        config, status=WorkflowStatusString.ENQUEUED.value
+    )
+    assert len(workflows) == 0
+    workflows = _workflow_commands.list_queued_workflows(config, queue_name=queue.name)
+    assert len(workflows) == queued_steps
+    workflows = _workflow_commands.list_queued_workflows(config, queue_name="no")
+    assert len(workflows) == 0
+    workflows = _workflow_commands.list_queued_workflows(
+        config, name=f"<temp>.{blocking_step.__qualname__}"
+    )
+    assert len(workflows) == queued_steps
+    workflows = _workflow_commands.list_queued_workflows(config, name="no")
+    assert len(workflows) == 0
+    now = datetime.now(timezone.utc)
+    start_time = (now - timedelta(seconds=10)).isoformat()
+    end_time = (now + timedelta(seconds=10)).isoformat()
+    workflows = _workflow_commands.list_queued_workflows(
+        config, start_time=start_time, end_time=end_time
+    )
+    assert len(workflows) == queued_steps
+    workflows = _workflow_commands.list_queued_workflows(
+        config, start_time=now.isoformat(), end_time=end_time
+    )
+    assert len(workflows) == 0
+
+    # Confirm the workflow finishes and nothing is enqueued afterwards
+    event.set()
+    assert handle.get_result() == [0, 1, 2, 3, 4]
+    workflows = _workflow_commands.list_queued_workflows(config)
+    assert len(workflows) == 0