dbression 0.1.2__tar.gz → 0.3.0__tar.gz

{dbression-0.1.2 → dbression-0.3.0}/CHANGELOG.md

@@ -7,17 +7,46 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
 
+## [0.3.0] — 2026-06-08
+
+### Added
+
+- **Single-file runs.** `dbression run path/to/MyTest.test.md` (or `.wiki`) now runs a
+  single test, mirroring DBFit: a file is one *Test* (many fixtures), a directory is a
+  *Suite*. The containing directory's `SuiteSetUp` / `SuiteTearDown` and `_root`
+  (connection + `DatabaseEnvironment`) are included automatically. A self-contained
+  `.test.md` carrying its own `<!-- dbression:env=… -->` / `<!-- dbression:connection=… -->`
+  directives runs standalone.
+- **Live progress.** Runs now show a spinner, an `x/y fixtures` counter, elapsed time, and
+  a status line naming the fixture/query currently executing. On by default at a TTY;
+  silenced automatically when output is piped or in CI. Toggle with `--progress` /
+  `--no-progress`.
+- **`--details` / `-d`.** Prints each fixture's result green/red as it runs (DBFit-web-UI
+  style), so a `.test.md` viewed in `glow` has a matching colored CLI run alongside it.
+
+## [0.2.0] — 2026-06-01
+
+### Added
+
+- **SQLite as a `DatabaseEnvironment`.** Use `DatabaseEnvironment | sqlite` (alias
+  `sqlite3`) with `service=:memory:` or `service=<path-to-db-file>` in
+  `connection.properties`. No native deps — uses the Python stdlib `sqlite3`
+  driver via SQLAlchemy. `Execute Procedure` does not apply (SQLite has no
+  stored procedures); everything else (`Query`, `Execute`, `Insert`, `Delete`,
+  `Inspect *`, `Update`, captures, substitutions) works the same as on the
+  other backends.
+
 ## [0.1.2] — 2026-06-01
 
-SQL Server live-verification release. A real-world MSSQL DBFit suite (WD-Gehsteig
-regression tests, stored-procedure-driven, square-bracket identifiers throughout)
+SQL Server live-verification release. A real-world MSSQL DBFit suite (regression tests,
+stored-procedure-driven, square-bracket identifiers throughout)
 runs end-to-end against an MSSQL Server 2019 via `pymssql` with no changes to the
 underlying `.wiki` files.
 
 ### Fixed
 
 - **Console reporter swallowed `[…]` in failure details.** Rich's inline-markup
-  parser interpreted MSSQL square-bracket identifiers like `[wdg].PLAENE` as
+  parser interpreted MSSQL square-bracket identifiers like `[dbo].ORDER` as
   style tags and stripped them from the displayed SQL — making failure output
   misleading. Reporter now prints fixture details with `markup=False`, so the
   SQL you see is the SQL that ran.
@@ -120,7 +149,9 @@ with code paths in place for SQL Server and Oracle.
   reject `python-oracledb` thin-mode authentication. Configuration is via
   `DBRESSION_ORACLE_CLIENT_LIB_DIR`.
 
-[Unreleased]: https://github.com/angrydat/dbression/compare/v0.1.2...HEAD
+[Unreleased]: https://github.com/angrydat/dbression/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/angrydat/dbression/releases/tag/v0.3.0
+[0.2.0]: https://github.com/angrydat/dbression/releases/tag/v0.2.0
 [0.1.2]: https://github.com/angrydat/dbression/releases/tag/v0.1.2
 [0.1.1]: https://github.com/angrydat/dbression/releases/tag/v0.1.1
 [0.1.0]: https://github.com/angrydat/dbression/releases/tag/v0.1.0

{dbression-0.1.2 → dbression-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dbression
-Version: 0.1.2
+Version: 0.3.0
 Summary: Rage-quit your flaky DB regressions — modern, lightweight, multi-DB regression testing.
 Project-URL: Homepage, https://angrydata.info/dbression
 Project-URL: Repository, https://github.com/angrydat/dbression
@@ -9,7 +9,7 @@ Project-URL: Changelog, https://github.com/angrydat/dbression/blob/main/CHANGELO
 Author-email: Jürgen Zornig <info@angrydata.info>
 License: MIT
 License-File: LICENSE
-Keywords: database,dbfit,fitnesse,markdown,oracle,postgres,regression,sql,sqlserver,testing
+Keywords: database,dbfit,fitnesse,markdown,oracle,postgres,regression,sql,sqlite,sqlserver,testing
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -35,6 +35,10 @@ Requires-Dist: sqlalchemy>=2.0
 Requires-Dist: typer>=0.12
 Description-Content-Type: text/markdown
 
+<p align="center">
+  <img src="https://raw.githubusercontent.com/angrydat/dbression/main/docs/dbression_head.png" alt="dbression — database regression testing for schema changes, migrations, and critical queries" width="820">
+</p>
+
 # dbression
 
 > ### Rage-quit your flaky DB regressions.
@@ -48,19 +52,19 @@ anywhere. `dbression` is a Python re-implementation in the spirit of the fantast
 
 ```text
 $ dbression run tests/
-dbression 0.1.2 — Suite: tests @ postgresql+psycopg://wlk:***@db01/wlk
+dbression 0.3.0 — Suite: tests @ postgresql+psycopg://foo:***@db01/bar
 
 ✓ HelloSql                                  0.004s
   CommonSuite/
-    MerklisteSuite/
+    ChangelistSuite/
       ✓ AAddBasicTest                       0.027s
       ✓ BAddNormalizationTest               0.029s
       ✓ CAddWhitelistTest                   0.025s
       ✓ DAddInvalidArgsTest                 0.014s
       ✓ ERemTest                            0.052s
-      ✓ FViewWbTest                         1.236s
-  EreignisSuite/
-    WaldbrandSuite/
+      ✓ FViewTest                           1.236s
+  EventsSuite/
+    FireSuite/
       ✓ LookupTest                          0.157s
       ✗ SchemaTest                          0.013s
 
@@ -92,7 +96,8 @@ the model gets every detail it needs to suggest a fix, no screenshots, no contex
 
 ```bash
 # install (we use uv, but pip works too)
-uv tool install git+https://github.com/angrydat/dbression.git
+uv tool install dbression          # or: pipx install dbression
+                                   # or: pip install dbression
 
 # run
 dbression run tests/
@@ -272,7 +277,10 @@ dbression:
 ## CLI cheat sheet
 
 ```bash
-dbression run <suite-path>                   # run an entire (sub-)suite
+dbression run <suite-path>                   # run an entire (sub-)suite (a directory)
+dbression run <path>/MyTest.test.md          # run a single test file (its SuiteSetUp/_root come along)
+dbression run <path> -d                      # --details: print each fixture green/red as it runs
+dbression run <path> --no-progress           # disable the live spinner / x-of-y counter
 dbression run <path> -v                      # show every fixture table, not just the page line
 dbression run <path> --tag critical          # only run pages tagged `critical`
 dbression run <path> --skip-tag NotOnCI      # skip pages tagged `NotOnCI`
@@ -284,37 +292,9 @@ dbression convert file.wiki -o out.test.md   # single file with explicit output
 dbression version
 ```
 
-## How it works
-
-```
-┌─────────────────────────────────────────────────────────┐
-│  CLI (typer)        dbression run tests/  [--flags]     │
-└─────────────────────────────────────────────────────────┘
-                              │
-                              ▼
-┌─────────────────────┐  ┌───────────────────────────────┐
-│  Parser             │  │  Engine Factory (SQLAlchemy)  │
-│  Wiki → AST         │  │  ┌──────────┐ ┌──────────┐    │
-│  • !- -! escapes    │  │  │ psycopg  │ │ oracledb │    │
-│  • q'~ ~' quoting   │  │  │ (Postgres│ │  (thin)  │    │
-│  • Nested suites    │  │  └──────────┘ └──────────┘    │
-│  • YAML front matter│  │  ┌──────────────────────┐     │
-└─────────┬───────────┘  │  │ pymssql (SQL Server) │     │
-          │              │  └──────────────────────┘     │
-          ▼              └───────────┬───────────────────┘
-┌─────────────────────────────────────┴───────────────────┐
-│  Runner — one TX per suite, savepoints per test         │
-│  Symbol engine: >>capture, <<read, :bind, _:text-subst  │
-│  Fixture registry — pluggable via decorator             │
-└─────────────────────┬───────────────────────────────────┘
-                      ▼
-┌─────────────────────────────────────────────────────────┐
-│  Reporters                                              │
-│  • Rich console (default)                               │
-│  • JUnit XML (--junit-xml)                              │
-│  • JSON (--json)                                        │
-└─────────────────────────────────────────────────────────┘
-```
+A run shows a live spinner with an `x/y fixtures` counter and the currently-executing
+query (auto-disabled when piped or in CI). Add `-d`/`--details` to stream a colored
+pass/fail line per fixture — handy next to a `.test.md` you're previewing in `glow`.
 
 ## Status
 
@@ -328,6 +308,7 @@ Postgres, Oracle and SQL Server. Honest state of the parts:
 | PostgreSQL | ✅ verified against a real-world suite     |
 | Oracle | ✅ verified against a real-world 19c suite via `oracledb` (thin) |
 | SQL Server | ✅ verified against a real-world suite via `pymssql` |
+| SQLite | ✅ via stdlib `sqlite3` — no procedures (the DB has none) |
 | JUnit XML + JSON output | ✅                                        |
 | `.test.md` native Markdown format + `dbression convert` | ✅                                        |
 | Plugin entry-points for custom fixtures | ✅                                        |

{dbression-0.1.2 → dbression-0.3.0}/README.md

@@ -1,3 +1,7 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/angrydat/dbression/main/docs/dbression_head.png" alt="dbression — database regression testing for schema changes, migrations, and critical queries" width="820">
+</p>
+
 # dbression
 
 > ### Rage-quit your flaky DB regressions.
@@ -11,19 +15,19 @@ anywhere. `dbression` is a Python re-implementation in the spirit of the fantast
 
 ```text
 $ dbression run tests/
-dbression 0.1.2 — Suite: tests @ postgresql+psycopg://wlk:***@db01/wlk
+dbression 0.3.0 — Suite: tests @ postgresql+psycopg://foo:***@db01/bar
 
 ✓ HelloSql                                  0.004s
   CommonSuite/
-    MerklisteSuite/
+    ChangelistSuite/
       ✓ AAddBasicTest                       0.027s
       ✓ BAddNormalizationTest               0.029s
       ✓ CAddWhitelistTest                   0.025s
       ✓ DAddInvalidArgsTest                 0.014s
       ✓ ERemTest                            0.052s
-      ✓ FViewWbTest                         1.236s
-  EreignisSuite/
-    WaldbrandSuite/
+      ✓ FViewTest                           1.236s
+  EventsSuite/
+    FireSuite/
       ✓ LookupTest                          0.157s
       ✗ SchemaTest                          0.013s
 
@@ -55,7 +59,8 @@ the model gets every detail it needs to suggest a fix, no screenshots, no contex
 
 ```bash
 # install (we use uv, but pip works too)
-uv tool install git+https://github.com/angrydat/dbression.git
+uv tool install dbression          # or: pipx install dbression
+                                   # or: pip install dbression
 
 # run
 dbression run tests/
@@ -235,7 +240,10 @@ dbression:
 ## CLI cheat sheet
 
 ```bash
-dbression run <suite-path>                   # run an entire (sub-)suite
+dbression run <suite-path>                   # run an entire (sub-)suite (a directory)
+dbression run <path>/MyTest.test.md          # run a single test file (its SuiteSetUp/_root come along)
+dbression run <path> -d                      # --details: print each fixture green/red as it runs
+dbression run <path> --no-progress           # disable the live spinner / x-of-y counter
 dbression run <path> -v                      # show every fixture table, not just the page line
 dbression run <path> --tag critical          # only run pages tagged `critical`
 dbression run <path> --skip-tag NotOnCI      # skip pages tagged `NotOnCI`
@@ -247,37 +255,9 @@ dbression convert file.wiki -o out.test.md   # single file with explicit output
 dbression version
 ```
 
-## How it works
-
-```
-┌─────────────────────────────────────────────────────────┐
-│  CLI (typer)        dbression run tests/  [--flags]     │
-└─────────────────────────────────────────────────────────┘
-                              │
-                              ▼
-┌─────────────────────┐  ┌───────────────────────────────┐
-│  Parser             │  │  Engine Factory (SQLAlchemy)  │
-│  Wiki → AST         │  │  ┌──────────┐ ┌──────────┐    │
-│  • !- -! escapes    │  │  │ psycopg  │ │ oracledb │    │
-│  • q'~ ~' quoting   │  │  │ (Postgres│ │  (thin)  │    │
-│  • Nested suites    │  │  └──────────┘ └──────────┘    │
-│  • YAML front matter│  │  ┌──────────────────────┐     │
-└─────────┬───────────┘  │  │ pymssql (SQL Server) │     │
-          │              │  └──────────────────────┘     │
-          ▼              └───────────┬───────────────────┘
-┌─────────────────────────────────────┴───────────────────┐
-│  Runner — one TX per suite, savepoints per test         │
-│  Symbol engine: >>capture, <<read, :bind, _:text-subst  │
-│  Fixture registry — pluggable via decorator             │
-└─────────────────────┬───────────────────────────────────┘
-                      ▼
-┌─────────────────────────────────────────────────────────┐
-│  Reporters                                              │
-│  • Rich console (default)                               │
-│  • JUnit XML (--junit-xml)                              │
-│  • JSON (--json)                                        │
-└─────────────────────────────────────────────────────────┘
-```
+A run shows a live spinner with an `x/y fixtures` counter and the currently-executing
+query (auto-disabled when piped or in CI). Add `-d`/`--details` to stream a colored
+pass/fail line per fixture — handy next to a `.test.md` you're previewing in `glow`.
 
 ## Status
 
@@ -291,6 +271,7 @@ Postgres, Oracle and SQL Server. Honest state of the parts:
 | PostgreSQL | ✅ verified against a real-world suite     |
 | Oracle | ✅ verified against a real-world 19c suite via `oracledb` (thin) |
 | SQL Server | ✅ verified against a real-world suite via `pymssql` |
+| SQLite | ✅ via stdlib `sqlite3` — no procedures (the DB has none) |
 | JUnit XML + JSON output | ✅                                        |
 | `.test.md` native Markdown format + `dbression convert` | ✅                                        |
 | Plugin entry-points for custom fixtures | ✅                                        |

{dbression-0.1.2 → dbression-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "dbression"
-version = "0.1.2"
+version = "0.3.0"
 description = "Rage-quit your flaky DB regressions — modern, lightweight, multi-DB regression testing."
 readme = "README.md"
 license = { text = "MIT" }
@@ -16,6 +16,7 @@ keywords = [
     "postgres",
     "oracle",
     "sqlserver",
+    "sqlite",
     "sql",
     "markdown",
     "fitnesse",

{dbression-0.1.2 → dbression-0.3.0}/src/dbression/cli.py

@@ -8,11 +8,17 @@ import typer
 from rich.console import Console
 
 from dbression import __version__
-from dbression.parser import parse_suite
+from dbression.parser import parse_suite, parse_test_file
 from dbression.parser.markdown_writer import page_to_markdown
 from dbression.parser.wiki import parse_wiki
-from dbression.report import print_suite_result, write_json_report, write_junit_xml
-from dbression.runner import TagFilter, build_engine_for_suite, run_suite
+from dbression.report import (
+    ProgressObserver,
+    make_progress,
+    print_suite_result,
+    write_json_report,
+    write_junit_xml,
+)
+from dbression.runner import TagFilter, build_engine_for_suite, count_fixtures, run_suite
 
 app = typer.Typer(
     name="dbression",
@@ -37,7 +43,12 @@ def version() -> None:
 
 @app.command()
 def run(
-    path: Annotated[Path, typer.Argument(help="Path to the suite (directory containing _root.wiki)")],
+    path: Annotated[
+        Path,
+        typer.Argument(
+            help="A suite directory (with _root.wiki) OR a single test file (.test.md / .wiki)"
+        ),
+    ],
     commit_mode: Annotated[
         str,
         typer.Option(
@@ -48,6 +59,21 @@ def run(
     verbose: Annotated[
         bool, typer.Option("-v", "--verbose", help="Print every fixture table, not just the page line")
     ] = False,
+    details: Annotated[
+        bool,
+        typer.Option(
+            "-d",
+            "--details",
+            help="Print each fixture's result (green/red) live as it runs, DBFit-web-UI style",
+        ),
+    ] = False,
+    progress: Annotated[
+        bool | None,
+        typer.Option(
+            "--progress/--no-progress",
+            help="Live spinner + x/y fixture counter (default: on when stdout is a terminal)",
+        ),
+    ] = None,
     tag: Annotated[
         list[str] | None,
         typer.Option(
@@ -68,10 +94,7 @@ def run(
         typer.Option("--json", help="Write a JSON report to this path (LLM / tooling)"),
     ] = None,
 ) -> None:
-    """Run a dbression suite and produce pytest-style reporting."""
-    if not path.is_dir():
-        console.print(f"[red]Not a directory:[/red] {path}")
-        raise typer.Exit(2)
+    """Run a dbression test (single file) or suite (directory) with live progress."""
     if commit_mode not in ("test", "page"):
         console.print(
             f"[red]Invalid commit-mode: {commit_mode!r} (allowed: test, page)[/red]"
@@ -80,14 +103,52 @@ def run(
 
     tag_filter = TagFilter(only=tuple(tag or ()), skip=tuple(skip_tag or ()))
 
-    suite = parse_suite(path)
+    if path.is_dir():
+        suite = parse_suite(path)
+        kind = "Suite"
+    elif path.is_file():
+        try:
+            suite = parse_test_file(path)
+        except ValueError as e:
+            console.print(f"[red]{e}[/red]")
+            raise typer.Exit(2)
+        kind = "Test"
+    else:
+        console.print(f"[red]Path does not exist:[/red] {path}")
+        raise typer.Exit(2)
+
     engine = build_engine_for_suite(suite)
     console.print(
-        f"dbression {__version__} — Suite: [bold]{suite.name}[/bold] @ "
+        f"dbression {__version__} — {kind}: [bold]{suite.name}[/bold] @ "
         f"{engine.url.render_as_string(hide_password=True)}\n"
     )
+
+    # Progress is on by default at a TTY; --progress / --no-progress override.
+    use_progress = console.is_terminal if progress is None else progress
+    total = count_fixtures(suite, tag_filter)
+
     try:
-        result = run_suite(suite, engine, commit_mode=commit_mode, tag_filter=tag_filter)  # type: ignore[arg-type]
+        if use_progress:
+            with make_progress(console) as prog:
+                task = prog.add_task("starting…", total=total or None)
+                observer = ProgressObserver(console, prog, task, details=details)
+                result = run_suite(
+                    suite,
+                    engine,
+                    commit_mode=commit_mode,  # type: ignore[arg-type]
+                    tag_filter=tag_filter,
+                    observer=observer,
+                )
+        else:
+            # No live bar (piped / CI). Still stream colored detail lines if asked.
+            observer = ProgressObserver(console, details=details) if details else None
+            result = run_suite(
+                suite,
+                engine,
+                commit_mode=commit_mode,  # type: ignore[arg-type]
+                tag_filter=tag_filter,
+                observer=observer,
+            )
     finally:
         engine.dispose()
     print_suite_result(result, console, verbose=verbose)

{dbression-0.1.2 → dbression-0.3.0}/src/dbression/db/engine.py

@@ -41,6 +41,7 @@ def _maybe_init_oracle_thick() -> None:
 _POSTGRES_ALIASES = {"postgres", "postgresql", "pg"}
 _ORACLE_ALIASES = {"oracle"}
 _MSSQL_ALIASES = {"sqlserver", "mssql", "ms-sql"}
+_SQLITE_ALIASES = {"sqlite", "sqlite3"}
 
 
 def make_engine(environment: str, config: ConnectionConfig) -> Engine:
@@ -55,6 +56,8 @@ def make_engine(environment: str, config: ConnectionConfig) -> Engine:
         url = _build_oracle_url(config, extra)
     elif env in _MSSQL_ALIASES:
         url = _build_mssql_url(config, extra)
+    elif env in _SQLITE_ALIASES:
+        url = _build_sqlite_url(config, extra)
     else:
         raise ValueError(f"Unknown DatabaseEnvironment: {environment!r}")
 
@@ -116,6 +119,30 @@ def _build_mssql_url(cfg: ConnectionConfig, extra: dict[str, str]) -> URL | str:
     )
 
 
+def _build_sqlite_url(cfg: ConnectionConfig, extra: dict[str, str]) -> URL | str:
+    """SQLite via the Python stdlib ``sqlite3`` driver. No native deps.
+
+    Path source order:
+
+    * ``connection-string=sqlite:///…``  — taken verbatim
+    * ``service=:memory:``               — in-memory DB
+    * ``service=<file-path>``            — file-backed DB (absolute or relative)
+    * ``database=<file-path>`` (extras)  — fallback alias
+
+    SQLite has no auth — ``username`` / ``password`` in connection.properties are
+    ignored. Stored procedures and `Execute Procedure` won't work (SQLite has none).
+    """
+    if cfg.connection_string:
+        return cfg.connection_string
+    path = cfg.service or extra.get("database") or ":memory:"
+    # SQLAlchemy SQLite URLs:
+    #   sqlite:///:memory:       — in-memory
+    #   sqlite:///relative.db    — relative to cwd (3 slashes)
+    #   sqlite:////abs/path.db   — absolute (4 slashes; the leading `/` of the path
+    #                              concatenates with the 3-slash prefix)
+    return f"sqlite:///{path}"
+
+
 def _split_host_port(service: str | None) -> tuple[str | None, int | None]:
     if not service:
         return None, None

dbression-0.3.0/src/dbression/parser/__init__.py

@@ -0,0 +1,12 @@
+from dbression.parser.ast import Directive, Page, Suite, Table
+from dbression.parser.wiki import parse_suite, parse_test_file, parse_wiki
+
+__all__ = [
+    "Directive",
+    "Page",
+    "Suite",
+    "Table",
+    "parse_suite",
+    "parse_test_file",
+    "parse_wiki",
+]

{dbression-0.1.2 → dbression-0.3.0}/src/dbression/parser/wiki.py

@@ -203,3 +203,66 @@ def parse_suite(root: Path) -> Suite:
     # Stable, deterministic order of test pages (alphabetical).
     suite.pages.sort(key=lambda p: p.name)
     return suite
+
+
+def _discover_special_pages(root: Path) -> dict[str, Page]:
+    """Parse only ``_root`` / ``SuiteSetUp`` / ``SuiteTearDown`` in `root` (md > wiki).
+
+    Used by single-file runs to pull in the surrounding directory's connection config
+    and setup/teardown without dragging in sibling test pages.
+    """
+    from dbression.parser.markdown import MARKDOWN_TEST_SUFFIX, parse_markdown
+
+    wanted = {"_root", "SuiteSetUp", "SuiteTearDown"}
+    if not root.is_dir():
+        return {}
+    found: dict[str, tuple[Path, str]] = {}
+    for entry in sorted(root.iterdir()):
+        if entry.is_dir():
+            continue
+        if entry.name.endswith(MARKDOWN_TEST_SUFFIX):
+            pn = entry.name[: -len(MARKDOWN_TEST_SUFFIX)]
+            if pn in wanted:
+                found[pn] = (entry, "md")
+        elif entry.suffix == ".wiki":
+            pn = entry.stem
+            if pn in wanted:
+                found.setdefault(pn, (entry, "wiki"))
+    out: dict[str, Page] = {}
+    for pn, (p, fmt) in found.items():
+        out[pn] = parse_markdown(p) if fmt == "md" else parse_wiki(p)
+    return out
+
+
+def parse_test_file(path: Path) -> Suite:
+    """Parse a single test FILE (``.test.md`` or ``.wiki``) into a runnable one-page Suite.
+
+    DBFit semantics: a file is one **Test** (many fixtures/assertions); a directory is a
+    **Suite**. When a single test is run, the surrounding directory's ``SuiteSetUp`` /
+    ``SuiteTearDown`` and ``_root`` (``DatabaseEnvironment`` + ``ConnectUsingFile``) are
+    included — just like opening a single page in the DBFit web UI runs its SuiteSetUp.
+
+    A self-contained ``.test.md`` that carries its own ``<!-- dbression:env=… -->`` /
+    ``<!-- dbression:connection=… -->`` directives runs standalone: those become the
+    suite's engine config (resolved relative to the file's directory).
+    """
+    from dbression.parser.markdown import MARKDOWN_TEST_SUFFIX, parse_markdown
+
+    if not path.is_file():
+        raise ValueError(f"Not a file: {path}")
+    if path.name.endswith(MARKDOWN_TEST_SUFFIX):
+        page = parse_markdown(path)
+    elif path.suffix == ".wiki":
+        page = parse_wiki(path)
+    else:
+        raise ValueError(f"Not a runnable test file (expected .test.md or .wiki): {path}")
+
+    root = path.parent
+    suite = Suite(root=root, name=page.name, pages=[page])
+    specials = _discover_special_pages(root)
+    suite.setup = specials.get("SuiteSetUp")
+    suite.teardown = specials.get("SuiteTearDown")
+    # Engine config precedence: a real `_root` in the directory wins; otherwise the test
+    # file's own env/connection directives make it self-contained.
+    suite.root_page = specials.get("_root") or page
+    return suite

{dbression-0.1.2 → dbression-0.3.0}/src/dbression/report/__init__.py

@@ -1,11 +1,19 @@
 """Reporters for SuiteResult data.
 
 * `console`     — pytest-style rich output (default CLI output)
+* `progress`    — live spinner + x/y counter + per-fixture detail lines (`--details`)
 * `junit`       — JUnit XML for Bitbucket Pipelines, Jenkins, GitLab, etc.
 * `json_report` — JSON for LLM tooling, custom dashboards, diff analyses
 """
 from dbression.report.console import print_suite_result
 from dbression.report.json_report import write_json_report
 from dbression.report.junit import write_junit_xml
+from dbression.report.progress import ProgressObserver, make_progress
 
-__all__ = ["print_suite_result", "write_json_report", "write_junit_xml"]
+__all__ = [
+    "ProgressObserver",
+    "make_progress",
+    "print_suite_result",
+    "write_json_report",
+    "write_junit_xml",
+]

dbression-0.3.0/src/dbression/report/progress.py

@@ -0,0 +1,113 @@
+"""Live progress + optional per-fixture detail output for ``dbression run``.
+
+Two things this module provides:
+
+* :func:`make_progress` — a Rich ``Progress`` with a spinner, an ``x/y`` fixture counter,
+  the elapsed time, and a status line showing which fixture/query is currently running.
+* :class:`ProgressObserver` — a :class:`~dbression.runner.RunObserver` that drives the
+  progress bar and, in ``--details`` mode, prints a colored pass/fail line per fixture
+  (DBFit-web-UI style) above the live bar.
+
+The observer is deliberately defensive about Rich markup: fixture names and SQL contain
+``[…]`` (MSSQL identifiers, array literals) which Rich would otherwise interpret as style
+tags. All dynamic text is rendered through ``rich.text.Text`` (no markup parsing).
+"""
+from __future__ import annotations
+
+from rich.console import Console
+from rich.progress import (
+    BarColumn,
+    MofNCompleteColumn,
+    Progress,
+    SpinnerColumn,
+    TextColumn,
+    TimeElapsedColumn,
+)
+from rich.text import Text
+
+from dbression.fixtures.base import FixtureResult
+from dbression.parser.ast import Table
+from dbression.runner import RunObserver
+
+
+def make_progress(console: Console) -> Progress:
+    """Build the live progress display (spinner + status + x/y counter + elapsed)."""
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(bar_width=None),
+        MofNCompleteColumn(),
+        TextColumn("fixtures"),
+        TimeElapsedColumn(),
+        console=console,
+        transient=True,  # clear the bar when done so the summary stands alone
+    )
+
+
+def _fixture_preview(table: Table, maxlen: int = 72) -> str:
+    """A one-line, whitespace-collapsed preview of what this fixture runs."""
+    text = " ".join(str(a) for a in table.header_args)
+    text = " ".join(text.split())
+    if len(text) > maxlen:
+        text = text[: maxlen - 1] + "…"
+    return text
+
+
+class ProgressObserver(RunObserver):
+    """Drive a Rich ``Progress`` task and optionally print per-fixture detail lines.
+
+    Works in two modes:
+
+    * with a ``progress``/``task_id`` (TTY): updates the live bar and, if ``details``,
+      prints detail lines above it via the progress console.
+    * without a progress bar (non-TTY but ``details`` requested): prints detail lines
+      straight to ``console``.
+    """
+
+    def __init__(
+        self,
+        console: Console,
+        progress: Progress | None = None,
+        task_id: int | None = None,
+        *,
+        details: bool = False,
+    ) -> None:
+        self.console = console
+        self.progress = progress
+        self.task_id = task_id
+        self.details = details
+
+    def _out(self) -> Console:
+        return self.progress.console if self.progress is not None else self.console
+
+    def on_fixture_start(self, page_name: str, table: Table) -> None:
+        if self.progress is None or self.task_id is None:
+            return
+        preview = _fixture_preview(table)
+        label = f"{page_name} › {table.name}"
+        if preview:
+            label += f": {preview}"
+        # Description is rendered with markup; Text() keeps brackets literal.
+        self.progress.update(self.task_id, description=Text(label, style="cyan"))
+
+    def on_fixture_end(
+        self, page_name: str, table: Table, result: FixtureResult, duration: float
+    ) -> None:
+        if self.progress is not None and self.task_id is not None:
+            self.progress.advance(self.task_id)
+        if not self.details:
+            return
+        line = Text()
+        if result.passed:
+            line.append("✓ ", style="bold green")
+        else:
+            line.append("✗ ", style="bold red")
+        line.append(page_name, style="bold")
+        line.append(" › ")
+        line.append(table.name, style="" if result.passed else "red")
+        line.append(f"  {duration * 1000:.0f}ms", style="dim")
+        self._out().print(line)
+        if result.message:
+            self._out().print(
+                Text("    " + result.message, style="dim" if result.passed else "red")
+            )

{dbression-0.1.2 → dbression-0.3.0}/src/dbression/runner.py

@@ -18,6 +18,23 @@ from dbression.symbols import SymbolTable
 CommitMode = Literal["test", "page"]
 
 
+class RunObserver:
+    """Hook for live run feedback. Default methods are no-ops — subclass to react.
+
+    The runner calls ``on_fixture_start`` immediately before a fixture table is evaluated
+    and ``on_fixture_end`` once its result is known, for every fixture that actually runs
+    (suite directives like ``DatabaseEnvironment`` are skipped, matching ``count_fixtures``).
+    """
+
+    def on_fixture_start(self, page_name: str, table: Table) -> None:  # noqa: D401
+        ...
+
+    def on_fixture_end(
+        self, page_name: str, table: Table, result: FixtureResult, duration: float
+    ) -> None:
+        ...
+
+
 @dataclass(slots=True)
 class TableResult:
     name: str
@@ -70,6 +87,31 @@ def _is_suite_directive(table: Table) -> bool:
     return norm in _SUITE_DIRECTIVE_FIXTURES
 
 
+def _count_page_fixtures(page: Page | None) -> int:
+    if page is None:
+        return 0
+    return sum(1 for t in page.tables if not _is_suite_directive(t))
+
+
+def count_fixtures(suite: Suite, tag_filter: "TagFilter | None" = None) -> int:
+    """Count the fixtures that will actually run — for an ``x/y`` progress total.
+
+    Mirrors what ``_run_page_in_tx`` executes: SuiteSetUp + tag-allowed test pages +
+    SuiteTearDown, recursively through sub-suites, skipping suite-directive tables.
+    May slightly overcount when a page or setup fails early (remaining fixtures are then
+    skipped) — that only means the bar stops short of 100%, which is itself informative.
+    """
+    n = _count_page_fixtures(suite.setup)
+    for page in suite.pages:
+        if tag_filter is not None and not tag_filter.page_allowed(page):
+            continue
+        n += _count_page_fixtures(page)
+    n += _count_page_fixtures(suite.teardown)
+    for sub in suite.subsuites:
+        n += count_fixtures(sub, tag_filter)
+    return n
+
+
 def _scan_engine_config(page: Page | None) -> tuple[str | None, str | None]:
     """Scan a page for `DatabaseEnvironment` and `ConnectUsingFile` directives."""
     if page is None:
@@ -164,6 +206,7 @@ def run_suite(
     symbols: SymbolTable | None = None,
     tag_filter: TagFilter | None = None,
     stored: dict[str, StoredQuery] | None = None,
+    observer: RunObserver | None = None,
 ) -> SuiteResult:
     """Run a suite recursively (including sub-suites).
 
@@ -186,7 +229,7 @@ def run_suite(
                 # SuiteSetUp — runs inside the suite TX, no commit/rollback of its own.
                 if suite.setup is not None:
                     result.setup_result = _run_page_in_tx(
-                        suite.setup, conn, symbols, stored, isolate=False
+                        suite.setup, conn, symbols, stored, isolate=False, observer=observer
                     )
                     if not result.setup_result.passed:
                         result.error = f"SuiteSetUp failed: {result.setup_result.name}"
@@ -197,13 +240,15 @@ def run_suite(
                     if tag_filter is not None and not tag_filter.page_allowed(page):
                         continue
                     isolate = commit_mode == "test"
-                    pr = _run_page_in_tx(page, conn, symbols, stored, isolate=isolate)
+                    pr = _run_page_in_tx(
+                        page, conn, symbols, stored, isolate=isolate, observer=observer
+                    )
                     result.pages.append(pr)
 
                 # Sub-suites: recursive, with their own engine if directives differ.
                 for sub in suite.subsuites:
                     sub_res = _run_subsuite(
-                        sub, engine, conn, commit_mode, symbols, tag_filter, stored
+                        sub, engine, conn, commit_mode, symbols, tag_filter, stored, observer
                     )
                     result.subsuites.append(sub_res)
 
@@ -212,7 +257,7 @@ def run_suite(
                 # connection stays valid.
                 if suite.teardown is not None:
                     result.teardown_result = _run_page_in_tx(
-                        suite.teardown, conn, symbols, stored, isolate=False
+                        suite.teardown, conn, symbols, stored, isolate=False, observer=observer
                     )
             finally:
                 # Defensive rollback of the entire suite TX. If TearDown already rolled
@@ -233,6 +278,7 @@ def _run_subsuite(
     symbols: SymbolTable,
     tag_filter: TagFilter | None = None,
     stored: dict[str, StoredQuery] | None = None,
+    observer: RunObserver | None = None,
 ) -> SuiteResult:
     """Run a sub-suite. If it has its own engine directives, use a local engine; otherwise
     run on the parent engine (with its own connection, for clean TX isolation).
@@ -251,11 +297,13 @@ def _run_subsuite(
         except Exception as e:
             return SuiteResult(name=sub.name, error=f"Engine build: {type(e).__name__}: {e}")
         try:
-            return run_suite(sub, sub_engine, commit_mode, symbols, tag_filter, stored)
+            return run_suite(
+                sub, sub_engine, commit_mode, symbols, tag_filter, stored, observer
+            )
         finally:
             sub_engine.dispose()
 
-    return run_suite(sub, parent_engine, commit_mode, symbols, tag_filter, stored)
+    return run_suite(sub, parent_engine, commit_mode, symbols, tag_filter, stored, observer)
 
 
 def _run_page_in_tx(
@@ -264,6 +312,7 @@ def _run_page_in_tx(
     symbols: SymbolTable,
     stored: dict[str, StoredQuery],
     isolate: bool,
+    observer: RunObserver | None = None,
 ) -> PageResult:
     """Run all fixture tables of a page inside the existing suite TX.
 
@@ -278,6 +327,8 @@ def _run_page_in_tx(
         for table in page.tables:
             if _is_suite_directive(table):
                 continue
+            if observer is not None:
+                observer.on_fixture_start(page.name, table)
             start = time.perf_counter()
             fixture_cls = resolve_fixture(table.name)
             if fixture_cls is None:
@@ -294,9 +345,10 @@ def _run_page_in_tx(
                         message=f"Fixture crash: {type(e).__name__}",
                         details=str(e),
                     )
-            pr.tables.append(
-                TableResult(name=table.name, result=res, duration=time.perf_counter() - start)
-            )
+            duration = time.perf_counter() - start
+            pr.tables.append(TableResult(name=table.name, result=res, duration=duration))
+            if observer is not None:
+                observer.on_fixture_end(page.name, table, res, duration)
             if not res.passed:
                 if savepoint is not None and savepoint.is_active:
                     savepoint.rollback()

dbression-0.3.0/tests/test_progress_and_single_file.py

@@ -0,0 +1,128 @@
+"""Tests for the run observer, fixture counting, single-file runs, and the progress
+observer — all against in-memory SQLite (no server needed)."""
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+from rich.console import Console
+
+from dbression.fixtures.base import FixtureResult
+from dbression.parser import parse_suite, parse_test_file
+from dbression.parser.ast import Table
+from dbression.report.progress import ProgressObserver, _fixture_preview, make_progress
+from dbression.runner import (
+    RunObserver,
+    TagFilter,
+    build_engine_for_suite,
+    count_fixtures,
+    run_suite,
+)
+
+
+@pytest.fixture
+def demo_suite(tmp_path: Path) -> Path:
+    (tmp_path / "connection.properties").write_text("service=:memory:\n")
+    (tmp_path / "_root.wiki").write_text(
+        "!|DatabaseEnvironment|sqlite|\n|ConnectUsingFile|connection.properties|\n"
+    )
+    (tmp_path / "SuiteSetUp.test.md").write_text(
+        "# Setup\n\n### Execute\n```sql\ncreate table t (n int)\n```\n\n"
+        "### Execute\n```sql\ninsert into t values (1),(2),(3)\n```\n"
+    )
+    (tmp_path / "CountTest.test.md").write_text(
+        "# Count\n\n### Query\n```sql\nselect count(*) as c from t\n```\n\n| c |\n|---|\n| 3 |\n"
+    )
+    return tmp_path
+
+
+def test_count_fixtures_matches_observed(demo_suite: Path) -> None:
+    suite = parse_suite(demo_suite)
+    total = count_fixtures(suite, TagFilter())
+    # 2 setup Execute + 1 page Query = 3 (DatabaseEnvironment/ConnectUsingFile excluded)
+    assert total == 3
+
+    class Recorder(RunObserver):
+        def __init__(self) -> None:
+            self.started: list[str] = []
+            self.ended: list[bool] = []
+
+        def on_fixture_start(self, page_name: str, table: Table) -> None:
+            self.started.append(f"{page_name}:{table.name}")
+
+        def on_fixture_end(self, page_name, table, result, duration) -> None:
+            self.ended.append(result.passed)
+
+    rec = Recorder()
+    engine = build_engine_for_suite(suite)
+    try:
+        result = run_suite(suite, engine, observer=rec)
+    finally:
+        engine.dispose()
+
+    assert result.passed_count == 1
+    assert len(rec.started) == total
+    assert len(rec.ended) == total
+    assert all(rec.ended)
+
+
+def test_single_file_run_pulls_in_setup(demo_suite: Path) -> None:
+    """Running just the test file must still run SuiteSetUp + use _root connection."""
+    suite = parse_test_file(demo_suite / "CountTest.test.md")
+    assert suite.name == "CountTest"
+    assert suite.setup is not None  # SuiteSetUp pulled in
+    assert len(suite.pages) == 1  # exactly one test, no siblings
+
+    engine = build_engine_for_suite(suite)
+    try:
+        result = run_suite(suite, engine)
+    finally:
+        engine.dispose()
+    assert result.passed_count == 1, result.error
+
+
+def test_self_contained_markdown_file(tmp_path: Path) -> None:
+    (tmp_path / "connection.properties").write_text("service=:memory:\n")
+    f = tmp_path / "Solo.test.md"
+    f.write_text(
+        "# Solo\n\n<!-- dbression:env=sqlite -->\n"
+        "<!-- dbression:connection=connection.properties -->\n\n"
+        "### Query\n```sql\nselect 1 as n\n```\n\n| n |\n|---|\n| 1 |\n"
+    )
+    suite = parse_test_file(f)
+    assert suite.setup is None  # no SuiteSetUp in dir
+    engine = build_engine_for_suite(suite)  # config comes from the file's own directives
+    try:
+        result = run_suite(suite, engine)
+    finally:
+        engine.dispose()
+    assert result.passed_count == 1, result.error
+
+
+def test_parse_test_file_rejects_unknown_extension(tmp_path: Path) -> None:
+    bad = tmp_path / "notes.txt"
+    bad.write_text("hello")
+    with pytest.raises(ValueError):
+        parse_test_file(bad)
+
+
+def test_fixture_preview_collapses_and_truncates() -> None:
+    t = Table(name="Query", header_args=["select   *\n  from   foo"])
+    assert _fixture_preview(t) == "select * from foo"
+    long = Table(name="Query", header_args=["x" * 200])
+    assert len(_fixture_preview(long)) <= 72
+
+
+def test_progress_observer_handles_bracket_identifiers(demo_suite: Path) -> None:
+    """A fixture name/SQL with [brackets] must not break Rich markup parsing."""
+    console = Console(force_terminal=True, width=100)
+    with make_progress(console) as prog:
+        task = prog.add_task("…", total=2)
+        obs = ProgressObserver(console, prog, task, details=True)
+        tbl = Table(name="Query", header_args=["select * from [dbo].[ORDER]"])
+        obs.on_fixture_start("PageA", tbl)
+        obs.on_fixture_end("PageA", tbl, FixtureResult(passed=True, message="OK [x]"), 0.01)
+        obs.on_fixture_end(
+            "PageA", tbl, FixtureResult(passed=False, message="boom [y]"), 0.02
+        )
+    # No exception == markup-safe.

dbression-0.3.0/tests/test_sqlite_engine.py

@@ -0,0 +1,60 @@
+"""SQLite engine smoke test — confirm the DatabaseEnvironment dispatch and end-to-end
+Query / Execute against an in-memory SQLite DB."""
+from __future__ import annotations
+
+from sqlalchemy import text
+
+from dbression.db.connection import ConnectionConfig
+from dbression.db.engine import make_engine
+from dbression.fixtures import resolve_fixture
+from dbression.fixtures.base import FixtureContext
+from dbression.parser.ast import Table
+from dbression.symbols import SymbolTable
+
+
+def _ctx(conn):
+    return FixtureContext(conn=conn, symbols=SymbolTable(), stored={})
+
+
+def test_sqlite_memory_via_database_environment():
+    cfg = ConnectionConfig(service=":memory:")
+    eng = make_engine("sqlite", cfg)
+    with eng.connect() as c:
+        assert c.execute(text("select 1")).scalar() == 1
+
+
+def test_sqlite_file_path_url_shape(tmp_path):
+    db = tmp_path / "x.db"
+    cfg = ConnectionConfig(service=str(db))
+    eng = make_engine("sqlite", cfg)
+    # Absolute path → 4 slashes
+    assert str(eng.url).startswith("sqlite:////")
+    with eng.connect() as c:
+        c.execute(text("create table t (a int)"))
+        c.execute(text("insert into t values (42)"))
+        assert c.execute(text("select a from t")).scalar() == 42
+
+
+def test_sqlite_runs_query_fixture():
+    cfg = ConnectionConfig(service=":memory:")
+    eng = make_engine("sqlite", cfg)
+    with eng.begin() as conn:
+        conn.execute(text("create table t (n int, name text)"))
+        conn.execute(text("insert into t values (1, 'a'), (2, 'b')"))
+    with eng.connect() as conn:
+        cls = resolve_fixture("Query")
+        tbl = Table(
+            name="Query",
+            header_args=["select n, name from t order by n"],
+            headers=["n", "name"],
+            rows=[["1", "a"], ["2", "b"]],
+        )
+        res = cls().run(tbl, _ctx(conn))
+        assert res.passed, res.message
+
+
+def test_sqlite_alias_sqlite3_also_works():
+    cfg = ConnectionConfig(service=":memory:")
+    eng = make_engine("sqlite3", cfg)
+    with eng.connect() as c:
+        assert c.execute(text("select 1")).scalar() == 1

{dbression-0.1.2 → dbression-0.3.0}/uv.lock

@@ -132,7 +132,7 @@ wheels = [
 
 [[package]]
 name = "dbression"
-version = "0.1.2"
+version = "0.3.0"
 source = { editable = "." }
 dependencies = [
     { name = "markdown-it-py" },

dbression-0.1.2/src/dbression/parser/__init__.py

@@ -1,4 +0,0 @@
-from dbression.parser.ast import Directive, Page, Suite, Table
-from dbression.parser.wiki import parse_suite, parse_wiki
-
-__all__ = ["Directive", "Page", "Suite", "Table", "parse_suite", "parse_wiki"]