pytest-dblift 0.1.0__tar.gz

pytest_dblift-0.1.0/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: pytest-dblift
+Version: 0.1.0
+Summary: pytest plugin for DBLift migrations
+Author: DBLift
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/dblift/dblift
+Classifier: Framework :: Pytest
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: dblift>=3.9
+Requires-Dist: pytest>=7.3
+Requires-Dist: sqlalchemy>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest-xdist>=3.3; extra == "dev"
+
+# pytest-dblift
+
+pytest plugin for [DBLift](https://github.com/dblift/dblift). It applies your migrations in tests and exposes a `DBLiftClient`.
+
+This is a **separate PyPI package**, not `dblift[pytest]`.
+
+## Install
+
+SQLite (default, stdlib driver):
+
+```bash
+pip install pytest-dblift
+```
+
+Any other engine: install the matching dblift extra so the native driver is present. The plugin does not install drivers and does not open a second connection — it calls `create_engine(url)` then `DBLiftClient.from_sqlalchemy`.
+
+```bash
+pip install pytest-dblift "dblift[postgresql]"
+pytest --dblift-url "postgresql+psycopg://user:pass@localhost/app_test"
+```
+
+## Quickstart
+
+```python
+def test_schema(dblift_migrated_db, dblift_client):
+    info = dblift_client.info()
+    assert info.pending_migrations == []
+```
+
+`dblift_migrated_db` applies pending migrations (function scope). `dblift_client` is a session-scoped `DBLiftClient`. No fixture is autouse: request what you need.
+
+## Fixtures
+
+| Fixture | Scope | Role |
+| --- | --- | --- |
+| `dblift_config` | session | Dict with `url`, `migrations_dir`, optional `schema`. Override in `conftest.py`. |
+| `dblift_engine` | session | SQLAlchemy engine from that URL. Override to inject your app engine. |
+| `dblift_client` | session | `DBLiftClient.from_sqlalchemy(...)`. |
+| `dblift_migrated_db` | function | `client.migrate()`, then yield the client. |
+| `dblift_empty_db` | function | `client.clean(clean_enabled=True)`, then yield the client. |
+| `dblift_validate` | function | Callable: `dblift_validate(**kwargs)` runs `client.validate` and asserts success. |
+| `dblift_undo` | function | Callable: `dblift_undo(**kwargs)` runs `client.undo` and asserts success. Does not migrate. |
+
+Undo uses companion `U*` scripts (same as dblift). There is no `undo()` function inside a `V*.py` file.
+
+```python
+def test_rollback(dblift_migrated_db, dblift_undo):
+    result = dblift_undo(target_version="0")
+    assert result.success
+```
+
+Override config in `tests/conftest.py`:
+
+```python
+import pytest
+
+@pytest.fixture(scope="session")
+def dblift_config():
+    return {
+        "url": "postgresql+psycopg://user:pass@localhost/app_test",
+        "migrations_dir": "migrations",
+    }
+```
+
+## CLI options
+
+| Option | What it does |
+| --- | --- |
+| `--dblift-url` | Database URL when `dblift_config` is not overridden. Default: a temp SQLite **file**. |
+| `--dblift-migrations-dir` | One migrations directory (not a comma-separated list). Default: `migrations`. |
+
+pytest-xdist: only the default SQLite file is per-worker (`test_gw0.db`, …). A URL you pass with `--dblift-url` is used as-is.

pytest_dblift-0.1.0/README.md

@@ -0,0 +1,72 @@
+# pytest-dblift
+
+pytest plugin for [DBLift](https://github.com/dblift/dblift). It applies your migrations in tests and exposes a `DBLiftClient`.
+
+This is a **separate PyPI package**, not `dblift[pytest]`.
+
+## Install
+
+SQLite (default, stdlib driver):
+
+```bash
+pip install pytest-dblift
+```
+
+Any other engine: install the matching dblift extra so the native driver is present. The plugin does not install drivers and does not open a second connection — it calls `create_engine(url)` then `DBLiftClient.from_sqlalchemy`.
+
+```bash
+pip install pytest-dblift "dblift[postgresql]"
+pytest --dblift-url "postgresql+psycopg://user:pass@localhost/app_test"
+```
+
+## Quickstart
+
+```python
+def test_schema(dblift_migrated_db, dblift_client):
+    info = dblift_client.info()
+    assert info.pending_migrations == []
+```
+
+`dblift_migrated_db` applies pending migrations (function scope). `dblift_client` is a session-scoped `DBLiftClient`. No fixture is autouse: request what you need.
+
+## Fixtures
+
+| Fixture | Scope | Role |
+| --- | --- | --- |
+| `dblift_config` | session | Dict with `url`, `migrations_dir`, optional `schema`. Override in `conftest.py`. |
+| `dblift_engine` | session | SQLAlchemy engine from that URL. Override to inject your app engine. |
+| `dblift_client` | session | `DBLiftClient.from_sqlalchemy(...)`. |
+| `dblift_migrated_db` | function | `client.migrate()`, then yield the client. |
+| `dblift_empty_db` | function | `client.clean(clean_enabled=True)`, then yield the client. |
+| `dblift_validate` | function | Callable: `dblift_validate(**kwargs)` runs `client.validate` and asserts success. |
+| `dblift_undo` | function | Callable: `dblift_undo(**kwargs)` runs `client.undo` and asserts success. Does not migrate. |
+
+Undo uses companion `U*` scripts (same as dblift). There is no `undo()` function inside a `V*.py` file.
+
+```python
+def test_rollback(dblift_migrated_db, dblift_undo):
+    result = dblift_undo(target_version="0")
+    assert result.success
+```
+
+Override config in `tests/conftest.py`:
+
+```python
+import pytest
+
+@pytest.fixture(scope="session")
+def dblift_config():
+    return {
+        "url": "postgresql+psycopg://user:pass@localhost/app_test",
+        "migrations_dir": "migrations",
+    }
+```
+
+## CLI options
+
+| Option | What it does |
+| --- | --- |
+| `--dblift-url` | Database URL when `dblift_config` is not overridden. Default: a temp SQLite **file**. |
+| `--dblift-migrations-dir` | One migrations directory (not a comma-separated list). Default: `migrations`. |
+
+pytest-xdist: only the default SQLite file is per-worker (`test_gw0.db`, …). A URL you pass with `--dblift-url` is used as-is.

pytest_dblift-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=83.0.0", "wheel>=0.46.2"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pytest-dblift"
+version = "0.1.0"
+description = "pytest plugin for DBLift migrations"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "Apache-2.0" }
+authors = [{ name = "DBLift" }]
+dependencies = [
+    "dblift>=3.9",
+    "pytest>=7.3",
+    "sqlalchemy>=2.0",
+]
+classifiers = [
+    "Framework :: Pytest",
+    "License :: OSI Approved :: Apache Software License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+urls = { Homepage = "https://github.com/dblift/dblift" }
+
+[project.entry-points.pytest11]
+dblift = "pytest_dblift.plugin"
+
+[project.optional-dependencies]
+dev = ["pytest-xdist>=3.3"]
+
+[tool.setuptools.packages.find]
+include = ["pytest_dblift*"]

pytest_dblift-0.1.0/pytest_dblift/__init__.py

@@ -0,0 +1,3 @@
+"""pytest-dblift: pytest plugin for DBLift migrations."""
+
+__version__ = "0.1.0"

pytest_dblift-0.1.0/pytest_dblift/_client.py

@@ -0,0 +1,71 @@
+"""URL resolution and DBLiftClient construction for pytest-dblift fixtures."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from api import DBLiftClient
+
+
+def _worker_id(config: pytest.Config) -> str:
+    """Return xdist worker id ('gw0', ...) or 'master' when not under xdist."""
+    workerinput = getattr(config, "workerinput", None)
+    if workerinput:
+        return workerinput.get("workerid", "master")
+    return "master"
+
+
+def default_sqlite_file_url(
+    tmp_path_factory: pytest.TempPathFactory, config: pytest.Config | None = None
+) -> str:
+    """Session-scoped temp SQLite file URL. Under xdist, suffix the filename with the worker id."""
+    base = tmp_path_factory.mktemp("dblift_pytest", numbered=True)
+    wid = _worker_id(config) if config is not None else "master"
+    if wid != "master":
+        db_path = base / f"test_{wid}.db"
+    else:
+        db_path = base / "test.db"
+    return f"sqlite:///{db_path}"
+
+
+def resolve_dblift_config(
+    pytestconfig: pytest.Config,
+    *,
+    tmp_path_factory: pytest.TempPathFactory,
+) -> dict[str, Any]:
+    """Build config dict from CLI options + defaults.
+
+    Returns dict with 'url' and 'migrations_dir' (absolute path str).
+    A relative migrations dir is resolved against pytest rootdir.
+    """
+    url = pytestconfig.getoption("--dblift-url")
+    if not url:
+        url = default_sqlite_file_url(tmp_path_factory, pytestconfig)
+
+    raw_mig = pytestconfig.getoption("--dblift-migrations-dir") or "migrations"
+    rootdir = getattr(pytestconfig, "rootdir", None) or Path.cwd()
+    rootdir = Path(rootdir)
+    mig_path = Path(raw_mig)
+    if not mig_path.is_absolute():
+        mig_path = (rootdir / mig_path).resolve()
+
+    return {
+        "url": url,
+        "migrations_dir": str(mig_path),
+    }
+
+
+def create_dblift_client(
+    engine: Any,
+    *,
+    migrations_dir: str | Path | list[str | Path] | None,
+    schema: str | None = None,
+) -> DBLiftClient:
+    return DBLiftClient.from_sqlalchemy(
+        engine,
+        migrations_dir=migrations_dir,
+        schema=schema,
+    )

pytest_dblift-0.1.0/pytest_dblift/fixtures.py

@@ -0,0 +1,84 @@
+"""pytest-dblift fixtures.
+
+Session scope for config/engine/client. Function scope for migrate/clean/validate/undo.
+No autouse: tests opt in by requesting a fixture.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Callable, Iterator
+
+import pytest
+from sqlalchemy import create_engine
+
+from api import DBLiftClient
+
+from ._client import create_dblift_client, resolve_dblift_config
+
+
+@pytest.fixture(scope="session")
+def dblift_config(
+    pytestconfig: pytest.Config, tmp_path_factory: pytest.TempPathFactory
+) -> dict[str, Any]:
+    """Session config from CLI or temp SQLite. Overridable in consumer conftest.py."""
+    return resolve_dblift_config(pytestconfig, tmp_path_factory=tmp_path_factory)
+
+
+@pytest.fixture(scope="session")
+def dblift_engine(dblift_config: dict[str, Any]) -> Iterator[Any]:
+    engine = create_engine(dblift_config["url"])
+    yield engine
+    engine.dispose()
+
+
+@pytest.fixture(scope="session")
+def dblift_client(dblift_engine: Any, dblift_config: dict[str, Any]) -> Iterator[DBLiftClient]:
+    client = create_dblift_client(
+        dblift_engine,
+        migrations_dir=dblift_config.get("migrations_dir"),
+        schema=dblift_config.get("schema"),
+    )
+    yield client
+    client.close()
+
+
+@pytest.fixture
+def dblift_migrated_db(dblift_client: DBLiftClient) -> Iterator[DBLiftClient]:
+    result = dblift_client.migrate()
+    assert getattr(result, "success", False), (
+        f"migrate failed: {getattr(result, 'error_message', result)}"
+    )
+    yield dblift_client
+
+
+@pytest.fixture
+def dblift_empty_db(dblift_client: DBLiftClient) -> Iterator[DBLiftClient]:
+    result = dblift_client.clean(clean_enabled=True)
+    assert getattr(result, "success", False), (
+        f"clean failed: {getattr(result, 'error_message', result)}"
+    )
+    yield dblift_client
+
+
+@pytest.fixture
+def dblift_validate(dblift_client: DBLiftClient) -> Callable[..., Any]:
+    def _run_validate(**kwargs: Any) -> Any:
+        result = dblift_client.validate(**kwargs)
+        assert getattr(result, "success", False), (
+            f"validate failed: {getattr(result, 'error_message', result)}"
+        )
+        return result
+
+    return _run_validate
+
+
+@pytest.fixture
+def dblift_undo(dblift_client: DBLiftClient) -> Callable[..., Any]:
+    def _run_undo(**kwargs: Any) -> Any:
+        result = dblift_client.undo(**kwargs)
+        assert getattr(result, "success", False), (
+            f"undo failed: {getattr(result, 'error_message', result)}"
+        )
+        return result
+
+    return _run_undo

pytest_dblift-0.1.0/pytest_dblift/plugin.py

@@ -0,0 +1,31 @@
+"""pytest11 entry: CLI options and fixture loading."""
+
+from __future__ import annotations
+
+import pytest
+
+pytest_plugins = ["pytest_dblift.fixtures"]
+
+
+def pytest_addoption(parser: pytest.Parser) -> None:
+    group = parser.getgroup("dblift", "dblift pytest integration")
+    group.addoption(
+        "--dblift-url",
+        action="store",
+        default=None,
+        help="Database URL for dblift (e.g. sqlite:////tmp/test.db or postgresql+psycopg://...). "
+        "Used when no dblift_config fixture override is provided.",
+    )
+    group.addoption(
+        "--dblift-migrations-dir",
+        action="store",
+        default="migrations",
+        help="Path to the migrations directory. Defaults to migrations.",
+    )
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    config.addinivalue_line(
+        "markers",
+        "dblift: marks tests as using dblift fixtures (provided by pytest-dblift)",
+    )

pytest_dblift-0.1.0/pytest_dblift.egg-info/PKG-INFO

@@ -0,0 +1,92 @@
+Metadata-Version: 2.4
+Name: pytest-dblift
+Version: 0.1.0
+Summary: pytest plugin for DBLift migrations
+Author: DBLift
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/dblift/dblift
+Classifier: Framework :: Pytest
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: dblift>=3.9
+Requires-Dist: pytest>=7.3
+Requires-Dist: sqlalchemy>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest-xdist>=3.3; extra == "dev"
+
+# pytest-dblift
+
+pytest plugin for [DBLift](https://github.com/dblift/dblift). It applies your migrations in tests and exposes a `DBLiftClient`.
+
+This is a **separate PyPI package**, not `dblift[pytest]`.
+
+## Install
+
+SQLite (default, stdlib driver):
+
+```bash
+pip install pytest-dblift
+```
+
+Any other engine: install the matching dblift extra so the native driver is present. The plugin does not install drivers and does not open a second connection — it calls `create_engine(url)` then `DBLiftClient.from_sqlalchemy`.
+
+```bash
+pip install pytest-dblift "dblift[postgresql]"
+pytest --dblift-url "postgresql+psycopg://user:pass@localhost/app_test"
+```
+
+## Quickstart
+
+```python
+def test_schema(dblift_migrated_db, dblift_client):
+    info = dblift_client.info()
+    assert info.pending_migrations == []
+```
+
+`dblift_migrated_db` applies pending migrations (function scope). `dblift_client` is a session-scoped `DBLiftClient`. No fixture is autouse: request what you need.
+
+## Fixtures
+
+| Fixture | Scope | Role |
+| --- | --- | --- |
+| `dblift_config` | session | Dict with `url`, `migrations_dir`, optional `schema`. Override in `conftest.py`. |
+| `dblift_engine` | session | SQLAlchemy engine from that URL. Override to inject your app engine. |
+| `dblift_client` | session | `DBLiftClient.from_sqlalchemy(...)`. |
+| `dblift_migrated_db` | function | `client.migrate()`, then yield the client. |
+| `dblift_empty_db` | function | `client.clean(clean_enabled=True)`, then yield the client. |
+| `dblift_validate` | function | Callable: `dblift_validate(**kwargs)` runs `client.validate` and asserts success. |
+| `dblift_undo` | function | Callable: `dblift_undo(**kwargs)` runs `client.undo` and asserts success. Does not migrate. |
+
+Undo uses companion `U*` scripts (same as dblift). There is no `undo()` function inside a `V*.py` file.
+
+```python
+def test_rollback(dblift_migrated_db, dblift_undo):
+    result = dblift_undo(target_version="0")
+    assert result.success
+```
+
+Override config in `tests/conftest.py`:
+
+```python
+import pytest
+
+@pytest.fixture(scope="session")
+def dblift_config():
+    return {
+        "url": "postgresql+psycopg://user:pass@localhost/app_test",
+        "migrations_dir": "migrations",
+    }
+```
+
+## CLI options
+
+| Option | What it does |
+| --- | --- |
+| `--dblift-url` | Database URL when `dblift_config` is not overridden. Default: a temp SQLite **file**. |
+| `--dblift-migrations-dir` | One migrations directory (not a comma-separated list). Default: `migrations`. |
+
+pytest-xdist: only the default SQLite file is per-worker (`test_gw0.db`, …). A URL you pass with `--dblift-url` is used as-is.

pytest_dblift-0.1.0/pytest_dblift.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+pytest_dblift/__init__.py
+pytest_dblift/_client.py
+pytest_dblift/fixtures.py
+pytest_dblift/plugin.py
+pytest_dblift.egg-info/PKG-INFO
+pytest_dblift.egg-info/SOURCES.txt
+pytest_dblift.egg-info/dependency_links.txt
+pytest_dblift.egg-info/entry_points.txt
+pytest_dblift.egg-info/requires.txt
+pytest_dblift.egg-info/top_level.txt
+tests/test_fixtures_sqlite.py
+tests/test_plugin_options.py
+tests/test_undo.py
+tests/test_xdist_isolation.py

pytest_dblift-0.1.0/pytest_dblift.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pytest_dblift-0.1.0/pytest_dblift.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[pytest11]
+dblift = pytest_dblift.plugin

pytest_dblift-0.1.0/pytest_dblift.egg-info/requires.txt

@@ -0,0 +1,6 @@
+dblift>=3.9
+pytest>=7.3
+sqlalchemy>=2.0
+
+[dev]
+pytest-xdist>=3.3

pytest_dblift-0.1.0/pytest_dblift.egg-info/top_level.txt

@@ -0,0 +1 @@
+pytest_dblift

pytest_dblift-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pytest_dblift-0.1.0/tests/test_fixtures_sqlite.py

@@ -0,0 +1,96 @@
+"""SQLite tests for pytest-dblift helpers and fixtures."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import pytest
+from sqlalchemy import text
+
+from api import DBLiftClient
+
+
+def test_resolve_dblift_config_reads_cli_url(
+    tmp_path_factory: pytest.TempPathFactory,
+) -> None:
+    from pytest_dblift._client import resolve_dblift_config
+
+    class DummyConfig:
+        rootdir = "/tmp"
+
+        def getoption(self, name: str, default: Any = None) -> Any:
+            if name == "--dblift-url":
+                return "sqlite:////tmp/dblift_custom_test.db"
+            if name == "--dblift-migrations-dir":
+                return "migrations"
+            return default
+
+    cfg = resolve_dblift_config(DummyConfig(), tmp_path_factory=tmp_path_factory)
+    assert "dblift_custom_test.db" in cfg["url"]
+    assert "migrations" in cfg["migrations_dir"]
+
+
+def test_worker_id_master_without_xdist(pytestconfig: pytest.Config) -> None:
+    from pytest_dblift._client import _worker_id
+
+    if getattr(pytestconfig, "workerinput", None):
+        pytest.skip("this assertion is for a non-xdist controller process")
+    assert _worker_id(pytestconfig) == "master"
+
+
+def test_dblift_config_defaults_to_sqlite_file(dblift_config: dict[str, Any]) -> None:
+    assert "sqlite" in dblift_config["url"]
+    assert ":memory:" not in dblift_config["url"]
+    assert (Path(dblift_config["migrations_dir"]) / "V1__init.sql").is_file()
+
+
+def test_dblift_engine_connects(dblift_engine: Any, dblift_config: dict[str, Any]) -> None:
+    from sqlalchemy.engine import Engine
+
+    assert isinstance(dblift_engine, Engine)
+    with dblift_engine.connect() as conn:
+        conn.execute(text("SELECT 1"))
+    rendered = dblift_engine.url.render_as_string(hide_password=False)
+    assert rendered.startswith("sqlite")
+
+
+def test_dblift_client_is_public_client(dblift_client: DBLiftClient) -> None:
+    assert isinstance(dblift_client, DBLiftClient)
+    info = dblift_client.info()
+    assert hasattr(info, "pending_migrations")
+
+
+def test_migrated_db_applies_migrations(
+    dblift_migrated_db: DBLiftClient, dblift_engine: Any
+) -> None:
+    assert dblift_migrated_db.info().pending_migrations == []
+    with dblift_engine.connect() as conn:
+        count = conn.execute(text("SELECT COUNT(*) FROM pytest_dblift_smoke")).scalar()
+        assert count == 0
+
+
+def test_empty_db_cleans_schema(
+    dblift_migrated_db: DBLiftClient, dblift_empty_db: DBLiftClient, dblift_engine: Any
+) -> None:
+    with dblift_engine.connect() as conn:
+        try:
+            conn.execute(text("SELECT COUNT(*) FROM pytest_dblift_smoke"))
+            exists = True
+        except Exception:
+            exists = False
+    assert not exists
+
+
+def test_validate_callable_succeeds(
+    dblift_migrated_db: DBLiftClient, dblift_validate: Any
+) -> None:
+    dblift_migrated_db.migrate()
+    result = dblift_validate()
+    assert result.success is True
+    result2 = dblift_validate(target_version=None)
+    assert result2.success is True
+
+
+def test_dblift_validate_is_callable(dblift_validate: Any) -> None:
+    assert callable(dblift_validate)

pytest_dblift-0.1.0/tests/test_plugin_options.py

@@ -0,0 +1,20 @@
+"""CLI options registered by the pytest-dblift plugin."""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+
+
+def test_help_lists_dblift_url_and_migrations_dir() -> None:
+    result = subprocess.run(
+        [sys.executable, "-m", "pytest", "--help"],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+    assert result.returncode == 0, result.stderr
+    help_text = result.stdout
+    assert "--dblift-url" in help_text
+    assert "--dblift-migrations-dir" in help_text
+    assert "--dblift-no-migrate" not in help_text

pytest_dblift-0.1.0/tests/test_undo.py

@@ -0,0 +1,36 @@
+"""dblift_undo uses companion U* scripts, not an undo() function inside V*.py."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from sqlalchemy import text
+
+from api import DBLiftClient
+
+
+def test_dblift_undo_reverts_via_companion_script(
+    dblift_migrated_db: DBLiftClient,
+    dblift_undo: Any,
+    dblift_engine: Any,
+) -> None:
+    with dblift_engine.connect() as conn:
+        conn.execute(text("INSERT INTO pytest_dblift_smoke (name) VALUES ('before-undo')"))
+        conn.commit()
+        count = conn.execute(text("SELECT COUNT(*) FROM pytest_dblift_smoke")).scalar()
+        assert count == 1
+
+    result = dblift_undo(target_version="0")
+    assert result.success is True
+
+    with dblift_engine.connect() as conn:
+        try:
+            conn.execute(text("SELECT COUNT(*) FROM pytest_dblift_smoke"))
+            exists = True
+        except Exception:
+            exists = False
+    assert not exists
+
+
+def test_dblift_undo_is_callable(dblift_undo: Any) -> None:
+    assert callable(dblift_undo)

pytest_dblift-0.1.0/tests/test_xdist_isolation.py

@@ -0,0 +1,35 @@
+"""Default SQLite URLs are per xdist worker."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import pytest
+from sqlalchemy import text
+
+from pytest_dblift._client import _worker_id
+
+
+def test_xdist_worker_isolation(
+    pytestconfig: pytest.Config,
+    dblift_config: dict[str, Any],
+    dblift_migrated_db: Any,
+    dblift_engine: Any,
+) -> None:
+    wid = _worker_id(pytestconfig)
+    url = dblift_config["url"]
+
+    if wid != "master":
+        assert wid in url, (
+            f"worker isolation missing: worker {wid!r} not in default url {url!r}"
+        )
+
+    assert "sqlite" in url and ":memory:" not in url
+    tag = f"iso-{wid}"
+    with dblift_engine.connect() as conn:
+        conn.execute(text("INSERT INTO pytest_dblift_smoke (name) VALUES (:n)"), {"n": tag})
+        conn.commit()
+        cnt = conn.execute(
+            text("SELECT COUNT(*) FROM pytest_dblift_smoke WHERE name = :n"), {"n": tag}
+        ).scalar()
+        assert cnt == 1