sqlbuild 0.82.2__tar.gz → 0.82.4__tar.gz

{sqlbuild-0.82.2 → sqlbuild-0.82.4}/Cargo.lock

@@ -572,7 +572,7 @@ checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
 [[package]]
 name = "sqlbuild-kata-native"
-version = "0.82.2"
+version = "0.82.4"
 dependencies = [
  "fensu-policy",
  "globset",

{sqlbuild-0.82.2 → sqlbuild-0.82.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.82.2
+Version: 0.82.4
 Requires-Dist: duckdb>=1.3.2
 Requires-Dist: filelock>=3.20.3
 Requires-Dist: polyglot-sql>=0.9.2

{sqlbuild-0.82.2 → sqlbuild-0.82.4}/crates/sqlbuild-kata-native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sqlbuild-kata-native"
-version = "0.82.2"
+version = "0.82.4"
 edition.workspace = true
 license.workspace = true
 publish.workspace = true

{sqlbuild-0.82.2 → sqlbuild-0.82.4}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "maturin"
 
 [project]
 name = "sqlbuild"
-version = "0.82.2"
+version = "0.82.4"
 description = "Typed, test-first SQL pipelines with local E2E testing"
 readme = "README.md"
 requires-python = ">=3.12"

{sqlbuild-0.82.2 → sqlbuild-0.82.4}/src/sqlbuild/cli/commands/_helpers/entry/dispatch.py

@@ -224,6 +224,7 @@ def dispatch_cli_command(*, args: CliNamespace, handlers: CliEntrypointHandlers)
                 cli_vars=args.vars,
                 json_output=args.json,
                 json_output_path=args.json_output,
+                concurrency=args.concurrency,
             )
         )
     if args.command == CliCommand.CHECK:

{sqlbuild-0.82.2 → sqlbuild-0.82.4}/src/sqlbuild/cli/commands/_helpers/entry/parser.py

@@ -226,6 +226,7 @@ def _add_quality_parsers(
     test_parser.add_argument("--no-sql-validation", action="store_true", default=False)
     test_parser.add_argument("--json", action="store_true", default=False)
     test_parser.add_argument("--target", default=None)
+    test_parser.add_argument("--concurrency", type=int, default=None)
     _ = add_execution_json_output_arg(test_parser)
     _ = add_select_args(test_parser)
     _ = add_vars_args(test_parser)

{sqlbuild-0.82.2 → sqlbuild-0.82.4}/src/sqlbuild/cli/commands/_helpers/entry/parsing.py

@@ -120,7 +120,13 @@ def parse_cli_invocation(
             and not any(option in args.dbt_args for option in DBT_VERBOSE_OPTIONS)
         ):
             args.dbt_args.append("--verbose")
-        if args.command in {CliCommand.AUDIT, CliCommand.BUILD, CliCommand.LOAD, CliCommand.SEED}:
+        if args.command in {
+            CliCommand.AUDIT,
+            CliCommand.BUILD,
+            CliCommand.LOAD,
+            CliCommand.SEED,
+            CliCommand.TEST,
+        }:
             try:
                 args.concurrency = resolve_env_default_concurrency(args.concurrency)
             except argparse.ArgumentTypeError as error:

{sqlbuild-0.82.2 → sqlbuild-0.82.4}/src/sqlbuild/cli/commands/_helpers/test/execution.py

@@ -11,6 +11,7 @@ from sqlbuild.cli.commands._helpers.test.sql_progress import (
     test_outcome_status,
 )
 from sqlbuild.cli.commands.models import (
+    TestCommandRequest,
     TestExecutionPreparation,
     TestInvocation,
 )
@@ -28,6 +29,7 @@ from sqlbuild.cli.progress.classes.nested_command_progress_callbacks import (
 from sqlbuild.compiler.pipeline.models import CompilePipelineResult
 from sqlbuild.compiler.planner.models import SqlTestPlanEntry
 from sqlbuild.executor.pipeline.main.run import run_test_pipeline
+from sqlbuild.executor.pipeline.models import TestPipelineCallbacks
 from sqlbuild.executor.testing.main.resource_id import sql_test_resource_id
 from sqlbuild.executor.testing.models import SqlTestExecutionResult
 from sqlbuild.presentation.classes.cli_style import CliStyle
@@ -37,12 +39,18 @@ from sqlbuild.presentation.main.surface_header import format_surface_header
 
 def prepare_test_execution(
     *,
+    request: TestCommandRequest,
     invocation: TestInvocation,
     pipeline_result: CompilePipelineResult,
 ) -> TestExecutionPreparation:
     """Prepare nested progress reporting and write the test section header."""
 
     test_count: int = len(pipeline_result.plan_output.test_entries)
+    effective_concurrency: int = resolve_test_concurrency(
+        request=request,
+        pipeline_result=pipeline_result,
+    )
+    worker_count: int = min(effective_concurrency, test_count)
     model_names: set[str] = set()
     for entry in pipeline_result.plan_output.test_entries:
         for step in entry.chain:
@@ -80,6 +88,22 @@ def prepare_test_execution(
         progress=progress,
         execution_connection_progress=execution_connection_progress,
         preflight_progress=preflight_progress,
+        effective_concurrency=effective_concurrency,
+        worker_count=worker_count,
+    )
+
+
+def resolve_test_concurrency(
+    *,
+    request: TestCommandRequest,
+    pipeline_result: CompilePipelineResult,
+) -> int:
+    """Resolve CLI override before the project-wide concurrency setting."""
+
+    return (
+        request.concurrency
+        if request.concurrency is not None
+        else pipeline_result.project.settings.concurrency
     )
 
 
@@ -102,29 +126,32 @@ def execute_test_plan(
             plan=pipeline_result.plan_output,
             connection_config=invocation.connection_config,
             adapter=invocation.adapter,
-            on_connection_start=preparation.execution_connection_progress.on_connection_start,
-            on_connection_complete=lambda connection_count, elapsed_seconds: (
-                preparation.execution_connection_progress.on_connection_complete(
-                    connection_count=connection_count, elapsed_seconds=elapsed_seconds
-                )
-            ),
-            on_connection_error=lambda connection_count, elapsed_seconds: (
-                preparation.execution_connection_progress.on_connection_error(
-                    connection_count=connection_count, elapsed_seconds=elapsed_seconds
-                )
-            ),
-            on_progress=preparation.preflight_progress.report_preflight_progress,
-            on_test_start=lambda entry: preparation.progress.on_item_start(
-                group_name=_test_group_name_from_entry(entry),
-                item_name=format_parameterized_test_label(
-                    name=entry.name,
-                    source_path=entry.source_path,
-                    parameter_schema=entry.parameter_schema,
-                    parameter_values=entry.parameter_values,
+            max_concurrency=preparation.effective_concurrency,
+            callbacks=TestPipelineCallbacks(
+                on_connection_start=(preparation.execution_connection_progress.on_connection_start),
+                on_connection_complete=lambda connection_count, elapsed_seconds: (
+                    preparation.execution_connection_progress.on_connection_complete(
+                        connection_count=connection_count, elapsed_seconds=elapsed_seconds
+                    )
+                ),
+                on_connection_error=lambda connection_count, elapsed_seconds: (
+                    preparation.execution_connection_progress.on_connection_error(
+                        connection_count=connection_count, elapsed_seconds=elapsed_seconds
+                    )
+                ),
+                on_progress=preparation.preflight_progress.report_preflight_progress,
+                on_test_start=lambda entry: preparation.progress.on_item_start(
+                    group_name=_test_group_name_from_entry(entry),
+                    item_name=format_parameterized_test_label(
+                        name=entry.name,
+                        source_path=entry.source_path,
+                        parameter_schema=entry.parameter_schema,
+                        parameter_values=entry.parameter_values,
+                    ),
+                    canonical_resource_name=entry.name,
                 ),
-                canonical_resource_name=entry.name,
+                on_test_complete=on_complete,
             ),
-            on_test_complete=on_complete,
             run_id=pipeline_result.project.run_id,
         )
     finally:
@@ -174,6 +201,9 @@ def _build_on_complete(
 
 
 def _test_group_name_from_entry(entry: SqlTestPlanEntry) -> str:
+    for step in entry.chain:
+        if step.expected_cte_sql is not None:
+            return step.model_name
     if entry.chain:
         return entry.chain[0].model_name
     return "(unknown)"

{sqlbuild-0.82.2 → sqlbuild-0.82.4}/src/sqlbuild/cli/commands/main/execution/_test.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from sqlbuild.cli.commands._helpers.test.execution import (
     execute_test_plan,
     prepare_test_execution,
+    resolve_test_concurrency,
 )
 from sqlbuild.cli.commands._helpers.test.invocation import resolve_test_invocation
 from sqlbuild.cli.commands._helpers.test.outputs import (
@@ -27,19 +28,20 @@ def run_test(request: TestCommandRequest) -> int:
     """Execute the test command."""
 
     invocation: TestInvocation = resolve_test_invocation(request=request)
+    pipeline_result: CompilePipelineResult = compile_test_plan(
+        request=request,
+        invocation=invocation,
+    )
     invocation.progress_stream.write("\n")
     write_execution_header(
         stream=invocation.progress_stream,
         command="sqb test",
         target=None,
-        concurrency=1,
+        concurrency=resolve_test_concurrency(request=request, pipeline_result=pipeline_result),
         use_color=invocation.use_color,
     )
-    pipeline_result: CompilePipelineResult = compile_test_plan(
-        request=request,
-        invocation=invocation,
-    )
     preparation: TestExecutionPreparation = prepare_test_execution(
+        request=request,
         invocation=invocation,
         pipeline_result=pipeline_result,
     )

{sqlbuild-0.82.2 → sqlbuild-0.82.4}/src/sqlbuild/cli/commands/models.py

@@ -1262,6 +1262,7 @@ class TestCommandRequest:
     cli_vars: dict[str, object] | None = None
     json_output: bool = False
     json_output_path: Path | None = None
+    concurrency: int | None = None
 
 
 @dataclass(frozen=True)
@@ -1312,6 +1313,8 @@ class TestExecutionPreparation:
     progress: NestedCommandProgressCallbacks
     execution_connection_progress: ConnectionProgressReporter
     preflight_progress: TransientStatusReporter
+    effective_concurrency: int
+    worker_count: int
 
 
 @dataclass(frozen=True)

{sqlbuild-0.82.2 → sqlbuild-0.82.4}/src/sqlbuild/compiler/planner/_helpers/sql_tests/assembly.py

@@ -102,10 +102,11 @@ def plan_test(
     expected_names: tuple[str, ...] = tuple(
         dict.fromkeys((*model_payload.expected_model_names, *assertion_target_names))
     )
-    ordered_names: tuple[str, ...] = _topo_sort_expected(
+    ordered_names: tuple[str, ...] = _topo_sort_model_chain(
         expected_names=expected_names,
         model_map=model_map,
         model_query_overrides=model_payload.model_query_overrides,
+        mock_ref_names=frozenset(mock_refs),
     )
 
     warnings: list[PlanWarning] = []
@@ -723,30 +724,14 @@ def _build_helper_with_clause(
     return "WITH " + ", ".join(parts)
 
 
-def _topo_sort_expected(
+def _topo_sort_model_chain(
     *,
     expected_names: tuple[str, ...],
     model_map: dict[str, CompiledModel],
     model_query_overrides: dict[str, str],
+    mock_ref_names: frozenset[str],
 ) -> tuple[str, ...]:
-    """Sort expected model names in dependency order."""
-
-    expected_set: frozenset[str] = frozenset(expected_names)
-    deps: dict[str, set[str]] = {}
-    name: str
-    for name in expected_names:
-        model: CompiledModel | None = model_map.get(name)
-        if model is None:
-            deps[name] = set()
-            continue
-        query_sql: str = model_query_overrides.get(name, model.query_sql)
-        model_refs: set[str] = set()
-        match: re.Match[str]
-        for match in _REF_PATTERN.finditer(query_sql):
-            ref_name: str = match.group(1)
-            if ref_name in expected_set:
-                model_refs.add(ref_name)
-        deps[name] = model_refs
+    """Sort asserted models and their unmocked model dependencies in execution order."""
 
     ordered: list[str] = []
     visited: set[str] = set()
@@ -755,9 +740,17 @@ def _topo_sort_expected(
         if node in seen:
             return seen, result
         seen = seen | {node}
-        dep: str
-        for dep in sorted(deps.get(node, set())):
-            seen, result = _visit(node=dep, seen=seen, result=result)
+        model: CompiledModel | None = model_map.get(node)
+        if model is not None:
+            query_sql: str = model_query_overrides.get(node, model.query_sql)
+            dependency_names: set[str] = {
+                match.group(1)
+                for match in _REF_PATTERN.finditer(query_sql)
+                if match.group(1) not in mock_ref_names and match.group(1) in model_map
+            }
+            dependency_name: str
+            for dependency_name in sorted(dependency_names):
+                seen, result = _visit(node=dependency_name, seen=seen, result=result)
         return seen, [*result, node]
 
     for name in sorted(expected_names):

{sqlbuild-0.82.2 → sqlbuild-0.82.4}/src/sqlbuild/executor/pipeline/_helpers/testing.py

@@ -2,9 +2,14 @@
 
 from __future__ import annotations
 
+import queue
+import threading
 import time
 from collections.abc import Callable, Iterable
-from typing import Any
+from concurrent.futures import Future, ThreadPoolExecutor
+from contextvars import copy_context
+from dataclasses import dataclass, field
+from typing import Any, cast
 from uuid import uuid4
 
 from sqlbuild.adapter.contract.classes.base_adapter import BaseAdapter
@@ -18,13 +23,17 @@ from sqlbuild.compiler.compile.types import FunctionLanguage
 from sqlbuild.compiler.planner.models import FunctionPlanEntry, PlanOutput, SqlTestPlanEntry
 from sqlbuild.executor.build.models import FunctionExecutionResult
 from sqlbuild.executor.functions.main._execute import execute_function
+from sqlbuild.executor.pipeline._helpers.connections import (
+    close_connections,
+    open_worker_connections,
+)
+from sqlbuild.executor.pipeline.models import TestPipelineCallbacks
 from sqlbuild.executor.scheduling.types import ExecutionStatus
 from sqlbuild.executor.testing.constants import SQL_TEST_EXECUTION_ERROR_CODE
 from sqlbuild.executor.testing.main._execute import execute_sql_test
 from sqlbuild.executor.testing.main.resource_id import sql_test_resource_id
 from sqlbuild.executor.testing.models import SqlTestExecutionResult, StepResult
 from sqlbuild.executor.testing.types import SqlTestOutcome
-from sqlbuild.runtime.contracts.types import ConnectionElapsedCallback
 from sqlbuild.runtime.observability.classes.operation_lifecycle import OperationLifecycle
 from sqlbuild.runtime.observability.classes.resource_attempt_lifecycle import (
     ResourceAttemptLifecycle,
@@ -32,37 +41,59 @@ from sqlbuild.runtime.observability.classes.resource_attempt_lifecycle import (
 from sqlbuild.runtime.observability.models import OperationAttributes
 
 
+@dataclass
+class _AuthoredStartCoordinator:
+    condition: threading.Condition = field(default_factory=threading.Condition)
+    next_index: int = 0
+
+    def wait(self, *, index: int) -> None:
+        with self.condition:
+            _ = self.condition.wait_for(lambda: self.next_index == index)
+            self.next_index += 1
+            self.condition.notify_all()
+
+
 def run_test_pipeline(
     *,
     plan: PlanOutput,
     connection_config: dict[str, object],
     adapter: BaseAdapter,
-    on_connection_start: Callable[[int], None] | None = None,
-    on_connection_complete: ConnectionElapsedCallback | None = None,
-    on_connection_error: ConnectionElapsedCallback | None = None,
-    on_progress: Callable[[str], None] | None = None,
-    on_test_start: Callable[[SqlTestPlanEntry], None] | None = None,
-    on_test_complete: Callable[[SqlTestExecutionResult], None] | None = None,
+    callbacks: TestPipelineCallbacks | None = None,
     run_id: str | None = None,
+    max_concurrency: int = 1,
 ) -> tuple[SqlTestExecutionResult, ...]:
     """Execute all SQL unit tests from a compiled plan."""
 
-    if on_connection_start is not None:
-        on_connection_start(1)
+    entries: tuple[SqlTestPlanEntry, ...] = plan.test_entries
+    if not entries:
+        return ()
+    resolved_callbacks: TestPipelineCallbacks = callbacks or TestPipelineCallbacks()
+    worker_count: int = min(max(1, max_concurrency), len(entries))
+    if resolved_callbacks.on_connection_start is not None:
+        resolved_callbacks.on_connection_start(worker_count)
     canonical_run_id: str = run_id or uuid4().hex
     start: float = time.monotonic()
     try:
-        connection: Any = adapter.connect(connection_config)
-    except Exception:
-        if on_connection_error is not None:
-            on_connection_error(1, elapsed_seconds=time.monotonic() - start)
+        connections: tuple[Any, ...] = open_worker_connections(
+            adapter=adapter,
+            connection_config=connection_config,
+            connection_count=worker_count,
+        )
+    except BaseException:
+        if resolved_callbacks.on_connection_error is not None:
+            resolved_callbacks.on_connection_error(
+                worker_count, elapsed_seconds=time.monotonic() - start
+            )
         raise
-    if on_connection_complete is not None:
-        on_connection_complete(1, elapsed_seconds=time.monotonic() - start)
+    if resolved_callbacks.on_connection_complete is not None:
+        resolved_callbacks.on_connection_complete(
+            worker_count, elapsed_seconds=time.monotonic() - start
+        )
+    active_error: BaseException | None = None
     try:
         preflight_start: float = time.monotonic()
-        if on_progress is not None:
-            on_progress("Preparing test functions...")
+        if resolved_callbacks.on_progress is not None:
+            resolved_callbacks.on_progress("Preparing test functions...")
         missing_functions_by_test: dict[CompiledObjectKey, tuple[str, ...]] = {}
         if any(entry.function_deps for entry in plan.test_entries):
             with OperationLifecycle(
@@ -74,44 +105,152 @@ def run_test_pipeline(
                 missing_functions_by_test = _prepare_test_functions(
                     plan=plan,
                     adapter=adapter,
-                    connection=connection,
+                    connection=connections[0],
                 )
-        if on_progress is not None:
-            on_progress(f"Prepared test functions. ({time.monotonic() - preflight_start:.2f}s)")
-        results: list[SqlTestExecutionResult] = []
-        entry: SqlTestPlanEntry
-        for entry in plan.test_entries:
-            missing_functions: tuple[str, ...] = missing_functions_by_test.get(entry.key, ())
-            resource_name: str = _test_resource_name(entry)
-            with ResourceAttemptLifecycle(
-                resource_id=sql_test_resource_id(
-                    test_name=entry.name,
-                    source_path=entry.source_path,
-                    block_index=entry.block_index,
-                    case_name=entry.case_name,
-                ),
-                resource_kind="test",
-                resource_name=resource_name,
-                run_id=canonical_run_id,
-            ) as lifecycle:
-                if on_test_start is not None:
-                    on_test_start(entry)
-                result: SqlTestExecutionResult = (
-                    _build_missing_function_result(
-                        test_entry=entry,
-                        missing_functions=missing_functions,
-                    )
-                    if missing_functions
-                    else execute_sql_test(test_entry=entry, adapter=adapter, connection=connection)
+        if resolved_callbacks.on_progress is not None:
+            resolved_callbacks.on_progress(
+                f"Prepared test functions. ({time.monotonic() - preflight_start:.2f}s)"
+            )
+        results: tuple[SqlTestExecutionResult, ...] = _run_tests(
+            entries=entries,
+            adapter=adapter,
+            connections=connections,
+            worker_count=worker_count,
+            missing_functions_by_test=missing_functions_by_test,
+            on_test_start=resolved_callbacks.on_test_start,
+            on_test_complete=resolved_callbacks.on_test_complete,
+            run_id=canonical_run_id,
+        )
+        return results
+    except BaseException as error:
+        active_error = error
+        raise
+    finally:
+        close_connections(adapter=adapter, connections=connections, active_error=active_error)
+
+
+def _run_tests(
+    *,
+    entries: tuple[SqlTestPlanEntry, ...],
+    adapter: BaseAdapter,
+    connections: tuple[Any, ...],
+    worker_count: int,
+    missing_functions_by_test: dict[CompiledObjectKey, tuple[str, ...]],
+    on_test_start: Callable[[SqlTestPlanEntry], None] | None,
+    on_test_complete: Callable[[SqlTestExecutionResult], None] | None,
+    run_id: str,
+) -> tuple[SqlTestExecutionResult, ...]:
+    if worker_count == 1:
+        serial_results: list[SqlTestExecutionResult] = []
+        for entry in entries:
+            result: SqlTestExecutionResult = _execute_test_entry(
+                entry=entry,
+                adapter=adapter,
+                connection=connections[0],
+                missing_functions=missing_functions_by_test.get(entry.key, ()),
+                on_test_start=on_test_start,
+                before_test_start=None,
+                run_id=run_id,
+            )
+            serial_results.append(result)
+            if on_test_complete is not None:
+                on_test_complete(result)
+        return tuple(serial_results)
+
+    connection_pool: queue.Queue[Any] = queue.Queue()
+    for connection in connections:
+        connection_pool.put(connection)
+    start_coordinator: _AuthoredStartCoordinator = _AuthoredStartCoordinator()
+
+    with ThreadPoolExecutor(max_workers=worker_count) as executor:
+        submitted_futures: list[Future[SqlTestExecutionResult]] = []
+        for index, entry in enumerate(entries):
+            submitted_futures.append(
+                cast(
+                    Future[SqlTestExecutionResult],
+                    executor.submit(
+                        copy_context().run,
+                        _execute_test_entry_with_pooled_connection,
+                        entry=entry,
+                        adapter=adapter,
+                        connection_pool=connection_pool,
+                        missing_functions=missing_functions_by_test.get(entry.key, ()),
+                        on_test_start=on_test_start,
+                        before_test_start=lambda index=index: start_coordinator.wait(index=index),
+                        run_id=run_id,
+                    ),
                 )
-                if result.outcome != SqlTestOutcome.PASS:
-                    lifecycle.failed(error_code=result.error_code)
-            results.append(result)
+            )
+        concurrent_results: list[SqlTestExecutionResult] = []
+        for future in submitted_futures:
+            result = future.result()
+            concurrent_results.append(result)
             if on_test_complete is not None:
                 on_test_complete(result)
-        return tuple(results)
+        return tuple(concurrent_results)
+
+
+def _execute_test_entry_with_pooled_connection(
+    *,
+    entry: SqlTestPlanEntry,
+    adapter: BaseAdapter,
+    connection_pool: queue.Queue[Any],
+    missing_functions: tuple[str, ...],
+    on_test_start: Callable[[SqlTestPlanEntry], None] | None,
+    before_test_start: Callable[[], None] | None,
+    run_id: str,
+) -> SqlTestExecutionResult:
+    connection: Any = connection_pool.get()
+    try:
+        return _execute_test_entry(
+            entry=entry,
+            adapter=adapter,
+            connection=connection,
+            missing_functions=missing_functions,
+            on_test_start=on_test_start,
+            before_test_start=before_test_start,
+            run_id=run_id,
+        )
     finally:
-        adapter.close(connection)
+        connection_pool.put(connection)
+
+
+def _execute_test_entry(
+    *,
+    entry: SqlTestPlanEntry,
+    adapter: BaseAdapter,
+    connection: Any,
+    missing_functions: tuple[str, ...],
+    on_test_start: Callable[[SqlTestPlanEntry], None] | None,
+    before_test_start: Callable[[], None] | None,
+    run_id: str,
+) -> SqlTestExecutionResult:
+    with ResourceAttemptLifecycle(
+        resource_id=sql_test_resource_id(
+            test_name=entry.name,
+            source_path=entry.source_path,
+            block_index=entry.block_index,
+            case_name=entry.case_name,
+        ),
+        resource_kind="test",
+        resource_name=_test_resource_name(entry),
+        run_id=run_id,
+    ) as lifecycle:
+        if before_test_start is not None:
+            before_test_start()
+        if on_test_start is not None:
+            on_test_start(entry)
+        result: SqlTestExecutionResult = (
+            _build_missing_function_result(
+                test_entry=entry,
+                missing_functions=missing_functions,
+            )
+            if missing_functions
+            else execute_sql_test(test_entry=entry, adapter=adapter, connection=connection)
+        )
+        if result.outcome != SqlTestOutcome.PASS:
+            lifecycle.failed(error_code=result.error_code)
+        return result
 
 
 def _test_resource_name(entry: SqlTestPlanEntry) -> str:

{sqlbuild-0.82.2 → sqlbuild-0.82.4}/src/sqlbuild/executor/pipeline/models.py

@@ -6,7 +6,7 @@ from collections.abc import Callable
 from dataclasses import dataclass
 from typing import Any
 
-from sqlbuild.compiler.planner.models import AuditPlanEntry
+from sqlbuild.compiler.planner.models import AuditPlanEntry, SqlTestPlanEntry
 from sqlbuild.executor.auditing.models import AuditExecutionResult
 from sqlbuild.executor.build.models import (
     BuildCallbacks,
@@ -14,6 +14,7 @@ from sqlbuild.executor.build.models import (
     BuildInitialState,
     BuildRuntimeParams,
 )
+from sqlbuild.executor.testing.models import SqlTestExecutionResult
 from sqlbuild.runtime.contracts.types import ConnectionElapsedCallback
 
 
@@ -30,6 +31,18 @@ class AuditPipelineCallbacks:
     on_audit_error: Callable[[AuditPlanEntry], None] | None = None
 
 
+@dataclass(frozen=True)
+class TestPipelineCallbacks:
+    """Optional connection, setup, and item callbacks for SQL test execution."""
+
+    on_connection_start: Callable[[int], None] | None = None
+    on_connection_complete: ConnectionElapsedCallback | None = None
+    on_connection_error: ConnectionElapsedCallback | None = None
+    on_progress: Callable[[str], None] | None = None
+    on_test_start: Callable[[SqlTestPlanEntry], None] | None = None
+    on_test_complete: Callable[[SqlTestExecutionResult], None] | None = None
+
+
 @dataclass(frozen=True)
 class AuditExecutionFailure:
     """Safe public description of one standalone audit runtime failure."""