dbos 1.15.0a1__tar.gz → 1.15.0a2__tar.gz

{dbos-1.15.0a1 → dbos-1.15.0a2}/PKG-INFO

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

{dbos-1.15.0a1 → dbos-1.15.0a2}/dbos/_client.py

@@ -22,11 +22,7 @@ from dbos._sys_db import SystemDatabase
 if TYPE_CHECKING:
     from dbos._dbos import WorkflowHandle, WorkflowHandleAsync
 
-from dbos._dbos_config import (
-    get_application_database_url,
-    get_system_database_url,
-    is_valid_database_url,
-)
+from dbos._dbos_config import get_system_database_url, is_valid_database_url
 from dbos._error import DBOSException, DBOSNonExistentWorkflowError
 from dbos._registrations import DEFAULT_MAX_RECOVERY_ATTEMPTS
 from dbos._serialization import WorkflowInputs
@@ -118,6 +114,9 @@ class WorkflowHandleClientAsyncPolling(Generic[R]):
 
 
 class DBOSClient:
+
+    _app_db: ApplicationDatabase | None = None
+
     def __init__(
         self,
         database_url: Optional[str] = None,  # DEPRECATED
@@ -126,13 +125,8 @@ class DBOSClient:
         application_database_url: Optional[str] = None,
         system_database: Optional[str] = None,  # DEPRECATED
     ):
-        application_database_url = get_application_database_url(
-            {
-                "system_database_url": system_database_url,
-                "database_url": (
-                    database_url if database_url else application_database_url
-                ),
-            }
+        application_database_url = (
+            database_url if database_url else application_database_url
         )
         system_database_url = get_system_database_url(
             {
@@ -142,7 +136,8 @@ class DBOSClient:
             }
         )
         assert is_valid_database_url(system_database_url)
-        assert is_valid_database_url(application_database_url)
+        if application_database_url:
+            assert is_valid_database_url(application_database_url)
         # We only create database connections but do not run migrations
         self._sys_db = SystemDatabase.create(
             system_database_url=system_database_url,
@@ -153,14 +148,15 @@ class DBOSClient:
             },
         )
         self._sys_db.check_connection()
-        self._app_db = ApplicationDatabase.create(
-            database_url=application_database_url,
-            engine_kwargs={
-                "pool_timeout": 30,
-                "max_overflow": 0,
-                "pool_size": 2,
-            },
-        )
+        if application_database_url:
+            self._app_db = ApplicationDatabase.create(
+                database_url=application_database_url,
+                engine_kwargs={
+                    "pool_timeout": 30,
+                    "max_overflow": 0,
+                    "pool_size": 2,
+                },
+            )
 
     def destroy(self) -> None:
         self._sys_db.destroy()

{dbos-1.15.0a1 → dbos-1.15.0a2}/dbos/_core.py

@@ -896,7 +896,9 @@ def decorate_transaction(
                 raise DBOSWorkflowCancelledError(
                     f"Workflow {ctx.workflow_id} is cancelled. Aborting transaction {transaction_name}."
                 )
-
+            assert (
+                dbos._app_db
+            ), "Transactions can only be used if DBOS is configured with an application_database_url"
             with dbos._app_db.sessionmaker() as session:
                 attributes: TracedAttributes = {
                     "name": transaction_name,

{dbos-1.15.0a1 → dbos-1.15.0a2}/dbos/_dbos.py

@@ -409,13 +409,8 @@ class DBOS:
         return rv
 
     @property
-    def _app_db(self) -> ApplicationDatabase:
-        if self._app_db_field is None:
-            raise DBOSException(
-                "Application database accessed before DBOS was launched"
-            )
-        rv: ApplicationDatabase = self._app_db_field
-        return rv
+    def _app_db(self) -> ApplicationDatabase | None:
+        return self._app_db_field
 
     @property
     def _admin_server(self) -> AdminServer:
@@ -448,7 +443,6 @@ class DBOS:
             dbos_logger.info(f"Application version: {GlobalParams.app_version}")
             self._executor_field = ThreadPoolExecutor(max_workers=sys.maxsize)
             self._background_event_loop.start()
-            assert self._config["database_url"] is not None
             assert self._config["database"]["sys_db_engine_kwargs"] is not None
             self._sys_db_field = SystemDatabase.create(
                 system_database_url=get_system_database_url(self._config),
@@ -456,18 +450,20 @@ class DBOS:
                 debug_mode=debug_mode,
             )
             assert self._config["database"]["db_engine_kwargs"] is not None
-            self._app_db_field = ApplicationDatabase.create(
-                database_url=self._config["database_url"],
-                engine_kwargs=self._config["database"]["db_engine_kwargs"],
-                debug_mode=debug_mode,
-            )
+            if self._config["database_url"]:
+                self._app_db_field = ApplicationDatabase.create(
+                    database_url=self._config["database_url"],
+                    engine_kwargs=self._config["database"]["db_engine_kwargs"],
+                    debug_mode=debug_mode,
+                )
 
             if debug_mode:
                 return
 
             # Run migrations for the system and application databases
             self._sys_db.run_migrations()
-            self._app_db.run_migrations()
+            if self._app_db:
+                self._app_db.run_migrations()
 
             admin_port = self._config.get("runtimeConfig", {}).get("admin_port")
             if admin_port is None:

{dbos-1.15.0a1 → dbos-1.15.0a2}/dbos/_dbos_config.py

@@ -408,22 +408,20 @@ def process_config(
                 url = url.set(database=f"{url.database}{SystemSchema.sysdb_suffix}")
             data["system_database_url"] = url.render_as_string(hide_password=False)
 
-    # If a system database URL is provided but not an application database URL, set the
-    # application database URL to the system database URL.
+    # If a system database URL is provided but not an application database URL,
+    # do not create an application database.
     if data.get("system_database_url") and not data.get("database_url"):
         assert data["system_database_url"]
-        data["database_url"] = data["system_database_url"]
+        data["database_url"] = None
 
-    # If neither URL is provided, use a default SQLite database URL.
+    # If neither URL is provided, use a default SQLite system database URL.
     if not data.get("database_url") and not data.get("system_database_url"):
         _app_db_name = _app_name_to_db_name(data["name"])
-        data["system_database_url"] = data["database_url"] = (
-            f"sqlite:///{_app_db_name}.sqlite"
-        )
+        data["system_database_url"] = f"sqlite:///{_app_db_name}.sqlite"
+        data["database_url"] = None
 
     configure_db_engine_parameters(data["database"], connect_timeout=connect_timeout)
 
-    assert data["database_url"] is not None
     assert data["system_database_url"] is not None
     # Pretty-print connection information, respecting log level
     if not silent and logs["logLevel"] == "INFO" or logs["logLevel"] == "DEBUG":
@@ -431,7 +429,12 @@ def process_config(
             hide_password=True
         )
         print(f"DBOS system database URL: {printable_sys_db_url}")
-        if data["database_url"].startswith("sqlite"):
+        if data["database_url"]:
+            printable_app_db_url = make_url(data["database_url"]).render_as_string(
+                hide_password=True
+            )
+            print(f"DBOS application database URL: {printable_app_db_url}")
+        if data["system_database_url"].startswith("sqlite"):
             print(
                 f"Using SQLite as a system database. The SQLite system database is for development and testing. PostgreSQL is recommended for production use."
             )
@@ -615,12 +618,11 @@ def get_system_database_url(config: ConfigFile) -> str:
         )
 
 
-def get_application_database_url(config: ConfigFile) -> str:
+def get_application_database_url(config: ConfigFile) -> str | None:
     # For backwards compatibility, the application database URL is "database_url"
     if config.get("database_url"):
         assert config["database_url"]
         return config["database_url"]
     else:
-        # If the application database URL is not specified, set it to the system database URL
-        assert config["system_database_url"]
-        return config["system_database_url"]
+        # If the application database URL is not specified, return None
+        return None

{dbos-1.15.0a1 → dbos-1.15.0a2}/dbos/_workflow_commands.py

@@ -98,10 +98,10 @@ def get_workflow(sys_db: SystemDatabase, workflow_id: str) -> Optional[WorkflowS
 
 
 def list_workflow_steps(
-    sys_db: SystemDatabase, app_db: ApplicationDatabase, workflow_id: str
+    sys_db: SystemDatabase, app_db: Optional[ApplicationDatabase], workflow_id: str
 ) -> List[StepInfo]:
     steps = sys_db.get_workflow_steps(workflow_id)
-    transactions = app_db.get_transactions(workflow_id)
+    transactions = app_db.get_transactions(workflow_id) if app_db else []
     merged_steps = steps + transactions
     merged_steps.sort(key=lambda step: step["function_id"])
     return merged_steps
@@ -109,7 +109,7 @@ def list_workflow_steps(
 
 def fork_workflow(
     sys_db: SystemDatabase,
-    app_db: ApplicationDatabase,
+    app_db: Optional[ApplicationDatabase],
     workflow_id: str,
     start_step: int,
     *,
@@ -122,7 +122,8 @@ def fork_workflow(
         ctx.id_assigned_for_next_workflow = ""
     else:
         forked_workflow_id = str(uuid.uuid4())
-    app_db.clone_workflow_transactions(workflow_id, forked_workflow_id, start_step)
+    if app_db:
+        app_db.clone_workflow_transactions(workflow_id, forked_workflow_id, start_step)
     sys_db.fork_workflow(
         workflow_id,
         forked_workflow_id,
@@ -145,7 +146,10 @@ def garbage_collect(
     )
     if result is not None:
         cutoff_epoch_timestamp_ms, pending_workflow_ids = result
-        dbos._app_db.garbage_collect(cutoff_epoch_timestamp_ms, pending_workflow_ids)
+        if dbos._app_db:
+            dbos._app_db.garbage_collect(
+                cutoff_epoch_timestamp_ms, pending_workflow_ids
+            )
 
 
 def global_timeout(dbos: "DBOS", cutoff_epoch_timestamp_ms: int) -> None:

{dbos-1.15.0a1 → dbos-1.15.0a2}/dbos/cli/cli.py

@@ -38,7 +38,7 @@ class DefaultEncoder(json.JSONEncoder):
 
 def _get_db_url(
     *, system_database_url: Optional[str], application_database_url: Optional[str]
-) -> Tuple[str, str]:
+) -> Tuple[str, str | None]:
     """
     Get the database URL to use for the DBOS application.
     Order of precedence:
@@ -294,7 +294,8 @@ def migrate(
     )
 
     typer.echo(f"Starting DBOS migrations")
-    typer.echo(f"Application database: {sa.make_url(application_database_url)}")
+    if application_database_url:
+        typer.echo(f"Application database: {sa.make_url(application_database_url)}")
     typer.echo(f"System database: {sa.make_url(system_database_url)}")
 
     # First, run DBOS migrations on the system database and the application database
@@ -305,9 +306,10 @@ def migrate(
 
     # Next, assign permissions on the DBOS schema to the application role, if any
     if application_role:
-        grant_dbos_schema_permissions(
-            database_url=application_database_url, role_name=application_role
-        )
+        if application_database_url:
+            grant_dbos_schema_permissions(
+                database_url=application_database_url, role_name=application_role
+            )
         grant_dbos_schema_permissions(
             database_url=system_database_url, role_name=application_role
         )

{dbos-1.15.0a1 → dbos-1.15.0a2}/dbos/cli/migration.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 import sqlalchemy as sa
 import typer
 
@@ -5,7 +7,9 @@ from dbos._app_db import ApplicationDatabase
 from dbos._sys_db import SystemDatabase
 
 
-def migrate_dbos_databases(app_database_url: str, system_database_url: str) -> None:
+def migrate_dbos_databases(
+    app_database_url: Optional[str], system_database_url: str
+) -> None:
     app_db = None
     sys_db = None
     try:
@@ -17,16 +21,17 @@ def migrate_dbos_databases(app_database_url: str, system_database_url: str) -> N
                 "pool_size": 2,
             },
         )
-        app_db = ApplicationDatabase.create(
-            database_url=app_database_url,
-            engine_kwargs={
-                "pool_timeout": 30,
-                "max_overflow": 0,
-                "pool_size": 2,
-            },
-        )
         sys_db.run_migrations()
-        app_db.run_migrations()
+        if app_database_url:
+            app_db = ApplicationDatabase.create(
+                database_url=app_database_url,
+                engine_kwargs={
+                    "pool_timeout": 30,
+                    "max_overflow": 0,
+                    "pool_size": 2,
+                },
+            )
+            app_db.run_migrations()
     except Exception as e:
         typer.echo(f"DBOS migrations failed: {e}")
         raise typer.Exit(code=1)

{dbos-1.15.0a1 → dbos-1.15.0a2}/pyproject.toml

@@ -15,7 +15,7 @@ dependencies = [
 ]
 requires-python = ">=3.10"
 readme = "README.md"
-version = "1.15.0a1"
+version = "1.15.0a2"
 
 [project.license]
 text = "MIT"

{dbos-1.15.0a1 → dbos-1.15.0a2}/tests/script_without_fastapi.py

@@ -1,4 +1,5 @@
 import os
+
 from dbos import DBOS, DBOSConfig
 
 config: DBOSConfig = {
@@ -7,19 +8,23 @@ config: DBOSConfig = {
 }
 DBOS(config=config)
 
+
 @DBOS.step()
 def step_one() -> None:
     print("Step one completed!")
 
+
 @DBOS.step()
 def step_two() -> None:
     print("Step two completed!")
 
+
 @DBOS.workflow()
 def dbos_workflow() -> None:
     step_one()
     step_two()
 
+
 if __name__ == "__main__":
     DBOS.launch()
-    dbos_workflow()
+    dbos_workflow()

{dbos-1.15.0a1 → dbos-1.15.0a2}/tests/test_config.py

@@ -279,7 +279,7 @@ def test_process_config_only_system_database():
     configFile = process_config(data=config)
     assert configFile["name"] == "some-app"
     assert configFile["system_database_url"] == config["system_database_url"]
-    assert configFile["database_url"] == config["system_database_url"]
+    assert configFile["database_url"] is None
 
 
 def test_process_config_sqlite():
@@ -331,8 +331,8 @@ def test_process_config_load_defaults():
     }
     processed_config = process_config(data=config)
     assert processed_config["name"] == "some-app"
-    assert processed_config["database_url"] == f"sqlite:///some_app.sqlite"
-    assert processed_config["system_database_url"] == processed_config["database_url"]
+    assert processed_config["database_url"] is None
+    assert processed_config["system_database_url"] == f"sqlite:///some_app.sqlite"
     assert processed_config["database"]["db_engine_kwargs"] is not None
     assert processed_config["database"]["sys_db_engine_kwargs"] is not None
     assert processed_config["telemetry"]["logs"]["logLevel"] == "INFO"
@@ -346,8 +346,8 @@ def test_process_config_load_default_with_None_database_url():
     }
     processed_config = process_config(data=config)
     assert processed_config["name"] == "some-app"
-    assert processed_config["database_url"] == f"sqlite:///some_app.sqlite"
-    assert processed_config["system_database_url"] == processed_config["database_url"]
+    assert processed_config["database_url"] is None
+    assert processed_config["system_database_url"] == f"sqlite:///some_app.sqlite"
     assert processed_config["database"]["db_engine_kwargs"] is not None
     assert processed_config["database"]["sys_db_engine_kwargs"] is not None
     assert processed_config["telemetry"]["logs"]["logLevel"] == "INFO"
@@ -361,8 +361,8 @@ def test_process_config_load_default_with_empty_database_url():
     }
     processed_config = process_config(data=config)
     assert processed_config["name"] == "some-app"
-    assert processed_config["database_url"] == f"sqlite:///some_app.sqlite"
-    assert processed_config["system_database_url"] == processed_config["database_url"]
+    assert processed_config["database_url"] is None
+    assert processed_config["system_database_url"] == f"sqlite:///some_app.sqlite"
     assert processed_config["database"]["db_engine_kwargs"] is not None
     assert processed_config["database"]["sys_db_engine_kwargs"] is not None
     assert processed_config["telemetry"]["logs"]["logLevel"] == "INFO"
@@ -396,8 +396,8 @@ def test_config_mixed_params():
 
     configFile = process_config(data=config)
     assert configFile["name"] == "some-app"
-    assert configFile["database_url"] == f"sqlite:///some_app.sqlite"
-    assert configFile["system_database_url"] == configFile["database_url"]
+    assert configFile["database_url"] is None
+    assert configFile["system_database_url"] == f"sqlite:///some_app.sqlite"
     assert configFile["database"]["db_engine_kwargs"] is not None
     assert configFile["database"]["sys_db_engine_kwargs"] is not None
     assert configFile["telemetry"]["logs"]["logLevel"] == "INFO"

{dbos-1.15.0a1 → dbos-1.15.0a2}/tests/test_dbos.py

@@ -24,6 +24,7 @@ from dbos import (
 )
 
 # Private API because this is a test
+from dbos._client import DBOSClient
 from dbos._context import assert_current_dbos_context, get_local_dbos_context
 from dbos._error import (
     DBOSAwaitedWorkflowCancelledError,
@@ -1730,3 +1731,47 @@ def test_destroy(dbos: DBOS, config: DBOSConfig) -> None:
     blocking_event.set()
     with pytest.raises(DBOSException):
         handle.get_result()
+
+
+def test_without_appdb(config: DBOSConfig, cleanup_test_databases: None) -> None:
+    DBOS.destroy(destroy_registry=True)
+    config["application_database_url"] = None
+    dbos = DBOS(config=config)
+    DBOS.launch()
+    assert dbos._app_db is None
+
+    @DBOS.step()
+    def step() -> None:
+        return
+
+    @DBOS.workflow()
+    def workflow() -> str:
+        step()
+        step()
+        step()
+        assert DBOS.workflow_id
+        return DBOS.workflow_id
+
+    wfid = workflow()
+    assert wfid
+    steps = DBOS.list_workflow_steps(wfid)
+    assert len(steps) == 3
+    for s in steps:
+        assert s["function_name"] == step.__qualname__
+    forked_handle = DBOS.fork_workflow(wfid, start_step=1)
+    assert forked_handle.get_result() == forked_handle.workflow_id
+
+    @DBOS.transaction()
+    def transaction() -> None:
+        return
+
+    with pytest.raises(AssertionError):
+        transaction()
+
+    DBOS.destroy(destroy_registry=True)
+
+    client = DBOSClient(system_database_url=config["system_database_url"])
+    steps = client.list_workflow_steps(wfid)
+    assert len(steps) == 3
+    for s in steps:
+        assert s["function_name"] == step.__qualname__

{dbos-1.15.0a1 → dbos-1.15.0a2}/tests/test_package.py

@@ -28,9 +28,7 @@ def test_package(
         with db_engine.connect() as connection:
             connection.execution_options(isolation_level="AUTOCOMMIT")
             connection.execute(sa.text(f"DROP DATABASE IF EXISTS {app_db_name}"))
-            connection.execute(
-                sa.text(f"DROP DATABASE IF EXISTS {sys_db_name}")
-            )
+            connection.execute(sa.text(f"DROP DATABASE IF EXISTS {sys_db_name}"))
 
         with tempfile.TemporaryDirectory() as temp_path:
             temp_path = tempfile.mkdtemp(prefix="dbos-")
@@ -62,7 +60,9 @@ def test_package(
             )
 
             # Next, verify a simple DBOS-only script runs
-            subprocess.check_call(["python3", "tests/script_without_fastapi.py"], env=venv)
+            subprocess.check_call(
+                ["python3", "tests/script_without_fastapi.py"], env=venv
+            )
 
             # Install FastAPI into the virtual environment
             subprocess.check_call(

{dbos-1.15.0a1 → dbos-1.15.0a2}/tests/test_scheduler.py

@@ -121,6 +121,7 @@ def test_appdb_downtime(dbos: DBOS, skip_with_sqlite: None) -> None:
         wf_counter += 1
 
     time.sleep(2)
+    assert dbos._app_db
     simulate_db_restart(dbos._app_db.engine, 2)
     time.sleep(2)
     assert wf_counter > 2

{dbos-1.15.0a1 → dbos-1.15.0a2}/tests/test_schema_migration.py

@@ -186,65 +186,93 @@ def test_migrate(db_engine: sa.Engine, skip_with_sqlite: None) -> None:
     db_url = db_engine.url.set(database=database_name).set(drivername="postgresql")
     db_url_string = db_url.render_as_string(hide_password=False)
 
-    # Drop the DBOS database if it exists. Create a test role with no permissions.
-    with db_engine.connect() as connection:
-        connection.execution_options(isolation_level="AUTOCOMMIT")
-        connection.execute(
-            sa.text(f"DROP DATABASE IF EXISTS {database_name} WITH (FORCE)")
-        )
-        connection.execute(sa.text(f'DROP ROLE IF EXISTS "{role_name}"'))
-        connection.execute(
-            sa.text(
-                f"CREATE ROLE \"{role_name}\" WITH LOGIN PASSWORD '{role_password}'"
+    for use_app_db in [True, False]:
+        # Drop the DBOS database if it exists. Create a test role with no permissions.
+        with db_engine.connect() as connection:
+            connection.execution_options(isolation_level="AUTOCOMMIT")
+            connection.execute(
+                sa.text(f"DROP DATABASE IF EXISTS {database_name} WITH (FORCE)")
             )
-        )
-
-    # Using the admin role, create the DBOS database and verify it exists.
-    # Set permissions for the test role.
-    subprocess.check_call(
-        ["dbos", "migrate", "-D", db_url_string, "-s", db_url_string, "-r", role_name]
-    )
-    with db_engine.connect() as c:
-        c.execution_options(isolation_level="AUTOCOMMIT")
-        result = c.execute(
-            sa.text(
-                f"SELECT COUNT(*) FROM pg_database WHERE datname = '{database_name}'"
+            connection.execute(sa.text(f'DROP ROLE IF EXISTS "{role_name}"'))
+            connection.execute(
+                sa.text(
+                    f"CREATE ROLE \"{role_name}\" WITH LOGIN PASSWORD '{role_password}'"
+                )
             )
-        ).scalar()
-        assert result == 1
-
-    # Initialize DBOS with the test role. Verify various operations work.
-    test_db_url = (
-        db_url.set(username=role_name).set(password=role_password)
-    ).render_as_string(hide_password=False)
-    DBOS.destroy(destroy_registry=True)
-    config: DBOSConfig = {
-        "name": "test_migrate",
-        "database_url": test_db_url,
-        "system_database_url": test_db_url,
-    }
-    DBOS(config=config)
-
-    @DBOS.transaction()
-    def test_transaction() -> str:
-        rows = DBOS.sql_session.execute(sa.text("SELECT 1")).fetchall()
-        return str(rows[0][0])
-
-    @DBOS.workflow()
-    def test_workflow() -> str:
-        assert test_transaction() == "1"
-        id = DBOS.workflow_id
-        assert id
-        DBOS.set_event(id, id)
-        return id
 
-    DBOS.launch()
-
-    workflow_id = test_workflow()
-    assert workflow_id
-    assert DBOS.get_event(workflow_id, workflow_id) == workflow_id
-
-    steps = DBOS.list_workflow_steps(workflow_id)
-    assert len(steps) == 2
-    assert steps[0]["function_name"] == test_transaction.__qualname__
-    assert steps[1]["function_name"] == "DBOS.setEvent"
+        # Using the admin role, create the DBOS database and verify it exists.
+        # Set permissions for the test role.
+        if use_app_db:
+            subprocess.check_call(
+                [
+                    "dbos",
+                    "migrate",
+                    "-D",
+                    db_url_string,
+                    "-s",
+                    db_url_string,
+                    "-r",
+                    role_name,
+                ]
+            )
+        else:
+            subprocess.check_call(
+                ["dbos", "migrate", "-s", db_url_string, "-r", role_name]
+            )
+        with db_engine.connect() as c:
+            c.execution_options(isolation_level="AUTOCOMMIT")
+            result = c.execute(
+                sa.text(
+                    f"SELECT COUNT(*) FROM pg_database WHERE datname = '{database_name}'"
+                )
+            ).scalar()
+            assert result == 1
+
+        # Initialize DBOS with the test role. Verify various operations work.
+        test_db_url = (
+            db_url.set(username=role_name).set(password=role_password)
+        ).render_as_string(hide_password=False)
+        DBOS.destroy(destroy_registry=True)
+        config: DBOSConfig = {
+            "name": "test_migrate",
+            "database_url": test_db_url if use_app_db else None,
+            "system_database_url": test_db_url,
+        }
+        dbos = DBOS(config=config)
+        if not use_app_db:
+            assert dbos._app_db is None
+
+        @DBOS.transaction()
+        def test_transaction() -> str:
+            rows = DBOS.sql_session.execute(sa.text("SELECT 1")).fetchall()
+            return str(rows[0][0])
+
+        @DBOS.step()
+        def test_step() -> str:
+            return "1"
+
+        @DBOS.workflow()
+        def test_workflow() -> str:
+            if use_app_db:
+                assert test_transaction() == "1"
+            else:
+                assert test_step() == "1"
+            id = DBOS.workflow_id
+            assert id
+            DBOS.set_event(id, id)
+            return id
+
+        DBOS.launch()
+
+        workflow_id = test_workflow()
+        assert workflow_id
+        assert DBOS.get_event(workflow_id, workflow_id) == workflow_id
+
+        steps = DBOS.list_workflow_steps(workflow_id)
+        assert len(steps) == 2
+        assert (
+            steps[0]["function_name"] == test_transaction.__qualname__
+            if use_app_db
+            else test_step.__qualname__
+        )
+        assert steps[1]["function_name"] == "DBOS.setEvent"

{dbos-1.15.0a1 → dbos-1.15.0a2}/tests/test_workflow_management.py

@@ -669,6 +669,7 @@ def test_garbage_collection(dbos: DBOS, skip_with_sqlite_imprecise_time: None) -
     assert len(workflows) == 2
     assert workflows[0].workflow_id == handle.workflow_id
     # Verify txn outputs are preserved only for the remaining workflows
+    assert dbos._app_db
     with dbos._app_db.engine.begin() as c:
         rows = c.execute(
             sa.select(