dbos 0.27.0a3__tar.gz → 0.27.0a4__tar.gz

{dbos-0.27.0a3 → dbos-0.27.0a4}/PKG-INFO

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

{dbos-0.27.0a3 → dbos-0.27.0a4}/dbos/_app_db.py

@@ -7,7 +7,7 @@ from sqlalchemy.exc import DBAPIError
 from sqlalchemy.orm import Session, sessionmaker
 
 from . import _serialization
-from ._dbos_config import ConfigFile, DatabaseConfig
+from ._dbos_config import DatabaseConfig
 from ._error import DBOSUnexpectedStepError, DBOSWorkflowConflictIDError
 from ._schemas.application_database import ApplicationSchema
 from ._sys_db import StepInfo

{dbos-0.27.0a3 → dbos-0.27.0a4}/dbos/_client.py

@@ -1,9 +1,10 @@
 import asyncio
 import sys
-import time
 import uuid
 from typing import Any, Generic, List, Optional, TypedDict, TypeVar
 
+from sqlalchemy import URL
+
 from dbos._app_db import ApplicationDatabase
 
 if sys.version_info < (3, 11):
@@ -57,7 +58,7 @@ class WorkflowHandleClientPolling(Generic[R]):
         return res
 
     def get_status(self) -> WorkflowStatus:
-        status = get_workflow(self._sys_db, self.workflow_id, True)
+        status = get_workflow(self._sys_db, self.workflow_id, False)
         if status is None:
             raise DBOSNonExistentWorkflowError(self.workflow_id)
         return status
@@ -80,7 +81,7 @@ class WorkflowHandleClientAsyncPolling(Generic[R]):
 
     async def get_status(self) -> WorkflowStatus:
         status = await asyncio.to_thread(
-            get_workflow, self._sys_db, self.workflow_id, True
+            get_workflow, self._sys_db, self.workflow_id, False
         )
         if status is None:
             raise DBOSNonExistentWorkflowError(self.workflow_id)
@@ -94,6 +95,7 @@ class DBOSClient:
             db_config["sys_db_name"] = system_database
         self._sys_db = SystemDatabase(db_config)
         self._app_db = ApplicationDatabase(db_config)
+        self._db_url = database_url
 
     def destroy(self) -> None:
         self._sys_db.destroy()
@@ -159,13 +161,13 @@ class DBOSClient:
         return WorkflowHandleClientAsyncPolling[R](workflow_id, self._sys_db)
 
     def retrieve_workflow(self, workflow_id: str) -> WorkflowHandle[R]:
-        status = get_workflow(self._sys_db, workflow_id, True)
+        status = get_workflow(self._sys_db, workflow_id, False)
         if status is None:
             raise DBOSNonExistentWorkflowError(workflow_id)
         return WorkflowHandleClientPolling[R](workflow_id, self._sys_db)
 
     async def retrieve_workflow_async(self, workflow_id: str) -> WorkflowHandleAsync[R]:
-        status = asyncio.to_thread(get_workflow, self._sys_db, workflow_id, True)
+        status = asyncio.to_thread(get_workflow, self._sys_db, workflow_id, False)
         if status is None:
             raise DBOSNonExistentWorkflowError(workflow_id)
         return WorkflowHandleClientAsyncPolling[R](workflow_id, self._sys_db)

{dbos-0.27.0a3 → dbos-0.27.0a4}/dbos/_dbos.py

@@ -64,7 +64,8 @@ from ._registrations import (
 )
 from ._roles import default_required_roles, required_roles
 from ._scheduler import ScheduledWorkflow, scheduled
-from ._sys_db import StepInfo, WorkflowStatus, reset_system_database
+from ._schemas.system_database import SystemSchema
+from ._sys_db import StepInfo, SystemDatabase, WorkflowStatus, reset_system_database
 from ._tracer import DBOSTracer, dbos_tracer
 
 if TYPE_CHECKING:
@@ -73,14 +74,15 @@ if TYPE_CHECKING:
     from ._request import Request
     from flask import Flask
 
+from sqlalchemy import URL
 from sqlalchemy.orm import Session
 
 from ._request import Request
 
 if sys.version_info < (3, 10):
-    from typing_extensions import ParamSpec, TypeAlias
+    from typing_extensions import ParamSpec
 else:
-    from typing import ParamSpec, TypeAlias
+    from typing import ParamSpec
 
 from ._admin_server import AdminServer
 from ._app_db import ApplicationDatabase
@@ -109,7 +111,6 @@ from ._error import (
 )
 from ._event_loop import BackgroundEventLoop
 from ._logger import add_otlp_to_all_loggers, config_logger, dbos_logger, init_logger
-from ._sys_db import SystemDatabase
 from ._workflow_commands import get_workflow, list_workflow_steps
 
 # Most DBOS functions are just any callable F, so decorators / wrappers work on F
@@ -563,7 +564,22 @@ class DBOS:
         assert (
             not self._launched
         ), "The system database cannot be reset after DBOS is launched. Resetting the system database is a destructive operation that should only be used in a test environment."
-        reset_system_database(self._config)
+
+        sysdb_name = (
+            self._config["database"]["sys_db_name"]
+            if "sys_db_name" in self._config["database"]
+            and self._config["database"]["sys_db_name"]
+            else self._config["database"]["app_db_name"] + SystemSchema.sysdb_suffix
+        )
+        postgres_db_url = URL.create(
+            "postgresql+psycopg",
+            username=self._config["database"]["username"],
+            password=self._config["database"]["password"],
+            host=self._config["database"]["hostname"],
+            port=self._config["database"]["port"],
+            database="postgres",
+        )
+        reset_system_database(postgres_db_url, sysdb_name)
 
     def _destroy(self) -> None:
         self._initialized = False

{dbos-0.27.0a3 → dbos-0.27.0a4}/dbos/_sys_db.py

@@ -248,6 +248,7 @@ class SystemDatabase:
                     sa.text("SELECT 1 FROM pg_database WHERE datname=:db_name"),
                     parameters={"db_name": sysdb_name},
                 ).scalar():
+                    dbos_logger.info(f"Creating system database {sysdb_name}")
                     conn.execute(sa.text(f"CREATE DATABASE {sysdb_name}"))
             engine.dispose()
 
@@ -1897,20 +1898,7 @@ class SystemDatabase:
         return wf_status, workflow_deadline_epoch_ms
 
 
-def reset_system_database(config: ConfigFile) -> None:
-    sysdb_name = (
-        config["database"]["sys_db_name"]
-        if "sys_db_name" in config["database"] and config["database"]["sys_db_name"]
-        else config["database"]["app_db_name"] + SystemSchema.sysdb_suffix
-    )
-    postgres_db_url = sa.URL.create(
-        "postgresql+psycopg",
-        username=config["database"]["username"],
-        password=config["database"]["password"],
-        host=config["database"]["hostname"],
-        port=config["database"]["port"],
-        database="postgres",
-    )
+def reset_system_database(postgres_db_url: sa.URL, sysdb_name: str) -> None:
     try:
         # Connect to postgres default database
         engine = sa.create_engine(postgres_db_url)

{dbos-0.27.0a3 → dbos-0.27.0a4}/dbos/cli/cli.py

@@ -5,10 +5,10 @@ import subprocess
 import time
 import typing
 from os import path
-from typing import Any
+from typing import Any, Optional
+from urllib.parse import quote
 
 import jsonpickle  # type: ignore
-import requests
 import sqlalchemy as sa
 import typer
 from rich import print
@@ -19,18 +19,28 @@ from dbos._debug import debug_workflow, parse_start_command
 
 from .. import load_config
 from .._app_db import ApplicationDatabase
+from .._client import DBOSClient
 from .._dbos_config import _is_valid_app_name
 from .._docker_pg_helper import start_docker_pg, stop_docker_pg
+from .._schemas.system_database import SystemSchema
 from .._sys_db import SystemDatabase, reset_system_database
-from .._workflow_commands import (
-    get_workflow,
-    list_queued_workflows,
-    list_workflow_steps,
-    list_workflows,
-)
 from ..cli._github_init import create_template_from_github
 from ._template_init import copy_template, get_project_name, get_templates_directory
 
+
+def start_client(db_url: Optional[str] = None) -> DBOSClient:
+    database_url = db_url
+    if database_url is None:
+        database_url = os.getenv("DBOS_DATABASE_URL")
+        if database_url is None:
+            config = load_config(silent=True)
+            database = config["database"]
+            username = quote(database["username"])
+            password = quote(database["password"])
+            database_url = f"postgresql://{username}:{password}@{database['hostname']}:{database['port']}/{database['app_db_name']}"
+    return DBOSClient(database_url=database_url)
+
+
 app = typer.Typer()
 workflow = typer.Typer()
 queue = typer.Typer()
@@ -241,7 +251,23 @@ def migrate() -> None:
 
 @app.command(help="Reset the DBOS system database")
 def reset(
-    yes: bool = typer.Option(False, "-y", "--yes", help="Skip confirmation prompt")
+    yes: bool = typer.Option(False, "-y", "--yes", help="Skip confirmation prompt"),
+    sys_db_name: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--sys-db-name",
+            "-s",
+            help="Specify the name of the system database to reset",
+        ),
+    ] = None,
+    db_url: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--db-url",
+            "-D",
+            help="Your DBOS application database URL",
+        ),
+    ] = None,
 ) -> None:
     if not yes:
         confirm = typer.confirm(
@@ -250,9 +276,18 @@ def reset(
         if not confirm:
             typer.echo("Operation cancelled.")
             raise typer.Exit()
-    config = load_config()
     try:
-        reset_system_database(config)
+        client = start_client(db_url=db_url)
+        pg_db_url = sa.make_url(client._db_url).set(drivername="postgresql+psycopg")
+        assert (
+            pg_db_url.database is not None
+        ), f"Database name is required in URL: {pg_db_url.render_as_string(hide_password=True)}"
+        sysdb_name = (
+            sys_db_name
+            if sys_db_name
+            else (pg_db_url.database + SystemSchema.sysdb_suffix)
+        )
+        reset_system_database(pg_db_url.set(database="postgres"), sysdb_name)
     except sa.exc.SQLAlchemyError as e:
         typer.echo(f"Error resetting system database: {str(e)}")
         return
@@ -276,6 +311,14 @@ def debug(
 
 @workflow.command(help="List workflows for your application")
 def list(
+    db_url: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--db-url",
+            "-D",
+            help="Your DBOS application database URL",
+        ),
+    ] = None,
     limit: Annotated[
         int,
         typer.Option("--limit", "-l", help="Limit the results returned"),
@@ -324,21 +367,31 @@ def list(
             help="Retrieve workflows with this name",
         ),
     ] = None,
-    request: Annotated[
+    sort_desc: Annotated[
         bool,
-        typer.Option("--request", help="Retrieve workflow request information"),
+        typer.Option(
+            "--sort-desc",
+            "-d",
+            help="Sort the results in descending order",
+        ),
     ] = False,
+    offset: Annotated[
+        typing.Optional[int],
+        typer.Option(
+            "--offset",
+            "-o",
+            help="Offset for pagination",
+        ),
+    ] = None,
 ) -> None:
-    config = load_config(silent=True)
-    sys_db = SystemDatabase(config["database"])
-    workflows = list_workflows(
-        sys_db,
+    workflows = start_client(db_url=db_url).list_workflows(
         limit=limit,
+        offset=offset,
+        sort_desc=sort_desc,
         user=user,
         start_time=starttime,
         end_time=endtime,
         status=status,
-        request=request,
         app_version=appversion,
         name=name,
     )
@@ -348,28 +401,39 @@ def list(
 @workflow.command(help="Retrieve the status of a workflow")
 def get(
     workflow_id: Annotated[str, typer.Argument()],
-    request: Annotated[
-        bool,
-        typer.Option("--request", help="Retrieve workflow request information"),
-    ] = False,
+    db_url: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--db-url",
+            "-D",
+            help="Your DBOS application database URL",
+        ),
+    ] = None,
 ) -> None:
-    config = load_config(silent=True)
-    sys_db = SystemDatabase(config["database"])
-    print(
-        jsonpickle.encode(get_workflow(sys_db, workflow_id, request), unpicklable=False)
+    status = (
+        start_client(db_url=db_url)
+        .retrieve_workflow(workflow_id=workflow_id)
+        .get_status()
     )
+    print(jsonpickle.encode(status, unpicklable=False))
 
 
 @workflow.command(help="List the steps of a workflow")
 def steps(
     workflow_id: Annotated[str, typer.Argument()],
+    db_url: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--db-url",
+            "-D",
+            help="Your DBOS application database URL",
+        ),
+    ] = None,
 ) -> None:
-    config = load_config(silent=True)
-    sys_db = SystemDatabase(config["database"])
-    app_db = ApplicationDatabase(config["database"])
     print(
         jsonpickle.encode(
-            list_workflow_steps(sys_db, app_db, workflow_id), unpicklable=False
+            start_client(db_url=db_url).list_workflow_steps(workflow_id=workflow_id),
+            unpicklable=False,
         )
     )
 
@@ -379,74 +443,51 @@ def steps(
 )
 def cancel(
     uuid: Annotated[str, typer.Argument()],
-    host: Annotated[
+    db_url: Annotated[
         typing.Optional[str],
-        typer.Option("--host", "-H", help="Specify the admin host"),
-    ] = "localhost",
-    port: Annotated[
-        typing.Optional[int],
-        typer.Option("--port", "-p", help="Specify the admin port"),
-    ] = 3001,
+        typer.Option(
+            "--db-url",
+            "-D",
+            help="Your DBOS application database URL",
+        ),
+    ] = None,
 ) -> None:
-    response = requests.post(
-        f"http://{host}:{port}/workflows/{uuid}/cancel", json=[], timeout=5
-    )
-
-    if response.status_code == 204:
-        print(f"Workflow {uuid} has been cancelled")
-    else:
-        print(f"Failed to cancel workflow {uuid}. Status code: {response.status_code}")
+    start_client(db_url=db_url).cancel_workflow(workflow_id=uuid)
 
 
 @workflow.command(help="Resume a workflow that has been cancelled")
 def resume(
     uuid: Annotated[str, typer.Argument()],
-    host: Annotated[
+    db_url: Annotated[
         typing.Optional[str],
-        typer.Option("--host", "-H", help="Specify the admin host"),
-    ] = "localhost",
-    port: Annotated[
-        typing.Optional[int],
-        typer.Option("--port", "-p", help="Specify the admin port"),
-    ] = 3001,
+        typer.Option(
+            "--db-url",
+            "-D",
+            help="Your DBOS application database URL",
+        ),
+    ] = None,
 ) -> None:
-    response = requests.post(
-        f"http://{host}:{port}/workflows/{uuid}/resume", json=[], timeout=5
-    )
-
-    if response.status_code == 204:
-        print(f"Workflow {uuid} has been resumed")
-    else:
-        print(f"Failed to resume workflow {uuid}. Status code: {response.status_code}")
+    start_client(db_url=db_url).resume_workflow(workflow_id=uuid)
 
 
 @workflow.command(help="Restart a workflow from the beginning with a new id")
 def restart(
     uuid: Annotated[str, typer.Argument()],
-    host: Annotated[
+    db_url: Annotated[
         typing.Optional[str],
-        typer.Option("--host", "-H", help="Specify the admin host"),
-    ] = "localhost",
-    port: Annotated[
-        typing.Optional[int],
-        typer.Option("--port", "-p", help="Specify the admin port"),
-    ] = 3001,
+        typer.Option(
+            "--db-url",
+            "-D",
+            help="Your DBOS application database URL",
+        ),
+    ] = None,
 ) -> None:
-    response = requests.post(
-        f"http://{host}:{port}/workflows/{uuid}/restart",
-        json=[],
-        timeout=5,
+    status = (
+        start_client(db_url=db_url)
+        .fork_workflow(workflow_id=uuid, start_step=1)
+        .get_status()
     )
-
-    if response.status_code == 204:
-        print(f"Workflow {uuid} has been restarted")
-    else:
-        error_message = response.json().get("error", "Unknown error")
-        print(
-            f"Failed to restart workflow {uuid}. "
-            f"Status code: {response.status_code}. "
-            f"Error: {error_message}"
-        )
+    print(jsonpickle.encode(status, unpicklable=False))
 
 
 @workflow.command(
@@ -454,43 +495,41 @@ def restart(
 )
 def fork(
     uuid: Annotated[str, typer.Argument()],
-    host: Annotated[
-        typing.Optional[str],
-        typer.Option("--host", "-H", help="Specify the admin host"),
-    ] = "localhost",
-    port: Annotated[
-        typing.Optional[int],
-        typer.Option("--port", "-p", help="Specify the admin port"),
-    ] = 3001,
     step: Annotated[
-        typing.Optional[int],
+        int,
         typer.Option(
             "--step",
             "-s",
             help="Restart from this step (default: first step)",
         ),
     ] = 1,
+    db_url: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--db-url",
+            "-D",
+            help="Your DBOS application database URL",
+        ),
+    ] = None,
 ) -> None:
-    print(f"Forking workflow {uuid} from step {step}")
-    response = requests.post(
-        f"http://{host}:{port}/workflows/{uuid}/fork",
-        json={"start_step": step},
-        timeout=5,
+    status = (
+        start_client(db_url=db_url)
+        .fork_workflow(workflow_id=uuid, start_step=step)
+        .get_status()
     )
-
-    if response.status_code == 204:
-        print(f"Workflow {uuid} has been forked")
-    else:
-        error_message = response.json().get("error", "Unknown error")
-        print(
-            f"Failed to fork workflow {uuid}. "
-            f"Status code: {response.status_code}. "
-            f"Error: {error_message}"
-        )
+    print(jsonpickle.encode(status, unpicklable=False))
 
 
 @queue.command(name="list", help="List enqueued functions for your application")
 def list_queue(
+    db_url: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--db-url",
+            "-D",
+            help="Your DBOS application database URL",
+        ),
+    ] = None,
     limit: Annotated[
         typing.Optional[int],
         typer.Option("--limit", "-l", help="Limit the results returned"),
@@ -535,21 +574,31 @@ def list_queue(
             help="Retrieve functions on this queue",
         ),
     ] = None,
-    request: Annotated[
+    sort_desc: Annotated[
         bool,
-        typer.Option("--request", help="Retrieve workflow request information"),
+        typer.Option(
+            "--sort-desc",
+            "-d",
+            help="Sort the results in descending order",
+        ),
     ] = False,
+    offset: Annotated[
+        typing.Optional[int],
+        typer.Option(
+            "--offset",
+            "-o",
+            help="Offset for pagination",
+        ),
+    ] = None,
 ) -> None:
-    config = load_config(silent=True)
-    sys_db = SystemDatabase(config["database"])
-    workflows = list_queued_workflows(
-        sys_db=sys_db,
+    workflows = start_client(db_url=db_url).list_queued_workflows(
         limit=limit,
+        offset=offset,
+        sort_desc=sort_desc,
         start_time=start_time,
         end_time=end_time,
         queue_name=queue_name,
         status=status,
-        request=request,
         name=name,
     )
     print(jsonpickle.encode(workflows, unpicklable=False))

{dbos-0.27.0a3 → dbos-0.27.0a4}/pyproject.toml

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

{dbos-0.27.0a3 → dbos-0.27.0a4}/tests/conftest.py

@@ -31,7 +31,7 @@ def default_config() -> ConfigFile:
             "hostname": "localhost",
             "port": 5432,
             "username": "postgres",
-            "password": os.environ["PGPASSWORD"],
+            "password": os.environ.get("PGPASSWORD", "dbos"),
             "app_db_name": "dbostestpy",
         },
     }

{dbos-0.27.0a3 → dbos-0.27.0a4}/tests/test_client.py

@@ -1,4 +1,3 @@
-import json
 import math
 import os
 import runpy
@@ -6,14 +5,13 @@ import subprocess
 import sys
 import time
 import uuid
-from typing import Any, Optional, TypedDict, cast
+from typing import Any, Optional, TypedDict
 
 import pytest
 import sqlalchemy as sa
 
-from dbos import DBOS, ConfigFile, DBOSClient, EnqueueOptions, Queue, SetWorkflowID
+from dbos import DBOS, ConfigFile, DBOSClient, EnqueueOptions, SetWorkflowID
 from dbos._dbos import WorkflowHandle, WorkflowHandleAsync
-from dbos._schemas.system_database import SystemSchema
 from dbos._sys_db import SystemDatabase
 from dbos._utils import GlobalParams
 from tests.client_collateral import event_test, retrieve_test, send_test
@@ -47,17 +45,30 @@ def test_client_enqueue_and_get_result(dbos: DBOS, client: DBOSClient) -> None:
     result = handle.get_result()
     assert result == '42-test-{"first": "John", "last": "Doe", "age": 30}'
 
+    list_results = client.list_workflows()
+    assert len(list_results) == 1
+    assert list_results[0].workflow_id == wfid
+    assert list_results[0].status == "SUCCESS"
+
 
 def test_enqueue_with_timeout(dbos: DBOS, client: DBOSClient) -> None:
     run_client_collateral()
 
+    wfid = str(uuid.uuid4())
     options: EnqueueOptions = {
         "queue_name": "test_queue",
         "workflow_name": "blocked_workflow",
-        "workflow_timeout": 0.1,
+        "workflow_timeout": 1,
+        "workflow_id": wfid,
     }
 
     handle: WorkflowHandle[str] = client.enqueue(options)
+
+    list_results = client.list_queued_workflows()
+    assert len(list_results) == 1
+    assert list_results[0].workflow_id == wfid
+    assert list_results[0].status in ["PENDING", "ENQUEUED"]
+
     with pytest.raises(Exception) as exc_info:
         handle.get_result()
     assert "was cancelled" in str(exc_info.value)

{dbos-0.27.0a3 → dbos-0.27.0a4}/tests/test_package.py

@@ -139,7 +139,13 @@ def test_reset(postgres_db_engine: sa.Engine) -> None:
             assert result == 1
 
         # Call reset and verify it's destroyed
-        subprocess.check_call(["dbos", "reset", "-y"], cwd=temp_path)
+        db_url = postgres_db_engine.url.set(database="reset_app").render_as_string(
+            hide_password=False
+        )
+        subprocess.check_call(
+            ["dbos", "reset", "-y", "--db-url", db_url, "--sys-db-name", sysdb_name],
+            cwd=temp_path,
+        )
         with postgres_db_engine.connect() as c:
             c.execution_options(isolation_level="AUTOCOMMIT")
             result = c.execute(
@@ -150,8 +156,11 @@ def test_reset(postgres_db_engine: sa.Engine) -> None:
             assert result == 0
 
 
-def test_list_commands() -> None:
+def test_workflow_commands(postgres_db_engine: sa.Engine) -> None:
     app_name = "reset-app"
+    db_url = postgres_db_engine.url.set(database="dbos_toolbox").render_as_string(
+        hide_password=False
+    )
     with tempfile.TemporaryDirectory() as temp_path:
         subprocess.check_call(
             ["dbos", "init", app_name, "--template", "dbos-toolbox"],
@@ -179,17 +188,78 @@ def test_list_commands() -> None:
                     time.sleep(1)
             time.sleep(1)  # So the queued workflows can start
         finally:
+            # Because the toolbox steps sleep for 5 seconds, all the steps should be PENDING
             os.kill(process.pid, signal.SIGINT)
             process.wait()
 
         # Verify the output is valid JSON
-        output = subprocess.check_output(["dbos", "workflow", "list"], cwd=temp_path)
+        output = subprocess.check_output(
+            ["dbos", "workflow", "list", "--db-url", db_url], 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
+            ["dbos", "workflow", "queue", "list", "--db-url", db_url], cwd=temp_path
         )
-        data = json.loads(output)
-        assert isinstance(data, list) and len(data) == 10
+        workflows = json.loads(output)
+        assert isinstance(workflows, list) and len(workflows) == 10
+        for wf in workflows:
+            output = subprocess.check_output(
+                ["dbos", "workflow", "get", wf["workflow_id"], "--db-url", db_url],
+                cwd=temp_path,
+            )
+            get_wf_data = json.loads(output)
+            assert isinstance(get_wf_data, dict)
+            assert get_wf_data["workflow_id"] == wf["workflow_id"]
+
+        # workflow ID is a preffix to each step ID
+        wf_id = "-".join(workflows[0]["workflow_id"].split("-")[:-1])
+        get_steps_output = subprocess.check_output(
+            ["dbos", "workflow", "steps", wf_id, "--db-url", db_url], cwd=temp_path
+        )
+        get_steps_data = json.loads(get_steps_output)
+        assert isinstance(get_steps_data, list)
+        assert len(get_steps_data) == 10
+
+        # cancel the workflow and check the status is CANCELED
+        subprocess.check_output(
+            ["dbos", "workflow", "cancel", wf_id, "--db-url", db_url], cwd=temp_path
+        )
+        output = subprocess.check_output(
+            ["dbos", "workflow", "get", wf_id], cwd=temp_path
+        )
+        get_wf_data = json.loads(output)
+        assert isinstance(get_wf_data, dict)
+        assert get_wf_data["status"] == "CANCELLED"
+
+        # resume the workflow and check the status is ENQUEUED
+        subprocess.check_output(
+            ["dbos", "workflow", "resume", wf_id, "--db-url", db_url], cwd=temp_path
+        )
+        output = subprocess.check_output(
+            ["dbos", "workflow", "get", wf_id], cwd=temp_path
+        )
+        get_wf_data = json.loads(output)
+        assert isinstance(get_wf_data, dict)
+        assert get_wf_data["status"] == "ENQUEUED"
+
+        # restart the workflow and check it has a new ID and its status is ENQUEUED
+        output = subprocess.check_output(
+            ["dbos", "workflow", "restart", wf_id, "--db-url", db_url], cwd=temp_path
+        )
+        restart_wf_data = json.loads(output)
+        assert isinstance(restart_wf_data, dict)
+        assert restart_wf_data["workflow_id"] != wf_id
+        assert restart_wf_data["status"] == "ENQUEUED"
+
+        # fork the workflow at step 5 and check it has a new ID and its status is ENQUEUED
+        output = subprocess.check_output(
+            ["dbos", "workflow", "fork", wf_id, "--step", "5", "--db-url", db_url],
+            cwd=temp_path,
+        )
+        fork_wf_data = json.loads(output)
+        assert isinstance(fork_wf_data, dict)
+        assert fork_wf_data["workflow_id"] != wf_id
+        assert fork_wf_data["status"] == "ENQUEUED"