sqlbuild 0.45.0__tar.gz → 0.45.1__tar.gz

sqlbuild-0.45.1/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.45.1"
+}

{sqlbuild-0.45.0 → sqlbuild-0.45.1}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.45.1](https://github.com/chio-labs/sqlbuild/compare/v0.45.0...v0.45.1) (2026-06-28)
+
+
+### Bug Fixes
+
+* **dbt:** defer clone pure dbt selections ([299fc98](https://github.com/chio-labs/sqlbuild/commit/299fc98c38782844ca4574068e87c3857717bfc6))
+* **dbt:** defer clone pure dbt selections ([978bbdd](https://github.com/chio-labs/sqlbuild/commit/978bbdd36dd8f91a2de8549fb7b8dbd0cb7929ed))
+
 ## [0.45.0](https://github.com/chio-labs/sqlbuild/compare/v0.44.4...v0.45.0) (2026-06-28)
 
 

{sqlbuild-0.45.0 → sqlbuild-0.45.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlbuild
-Version: 0.45.0
+Version: 0.45.1
 Summary: Typed, test-first SQL pipelines with local E2E testing
 License-File: LICENSE
 Requires-Python: >=3.12

{sqlbuild-0.45.0 → sqlbuild-0.45.1}/pyproject.toml

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

{sqlbuild-0.45.0 → sqlbuild-0.45.1}/src/sqlbuild/integrations/dbt/helpers/runtime/event_stream.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 import os
 import subprocess
+import time
 from collections.abc import Callable
 from pathlib import Path
 from typing import TextIO, cast
@@ -72,6 +73,7 @@ def execute_dbt_json_event_stream(
     results: list[DbtNodeExecutionResult] = []
     recorded_unique_ids: set[str] = set()
     started_indexes: dict[str, int] = {}
+    active_nodes: dict[str, tuple[str, float]] = {}
     display_index: int = 0
     status: TransientStatusReporter | None = _start_dbt_status(
         stream=stream,
@@ -128,6 +130,16 @@ def execute_dbt_json_event_stream(
                             display_index=display_index,
                             display_total=display_total,
                         )
+                        active_nodes[start_result.unique_id] = (
+                            start_result.node_name,
+                            time.monotonic(),
+                        )
+                        status = _update_active_node_status(
+                            status=status,
+                            active_nodes=active_nodes,
+                            stream=stream,
+                            use_color=use_color,
+                        )
                     continue
                 result: DbtNodeExecutionResult | None = parse_dbt_node_result(
                     event=event,
@@ -141,6 +153,7 @@ def execute_dbt_json_event_stream(
                 if status is not None:
                     status.close()
                     status = None
+                active_nodes.pop(result.unique_id, None)
                 results.append(result)
                 if on_node_result is not None:
                     on_node_result(result)
@@ -155,6 +168,12 @@ def execute_dbt_json_event_stream(
                     display_index=result_display_index,
                     display_total=display_total,
                 )
+                status = _update_active_node_status(
+                    status=status,
+                    active_nodes=active_nodes,
+                    stream=stream,
+                    use_color=use_color,
+                )
 
     returncode: int = process.wait()
     if status is not None:
@@ -173,6 +192,38 @@ def _start_dbt_status(*, stream: TextIO, use_color: bool) -> TransientStatusRepo
     return status
 
 
+def _update_active_node_status(
+    *,
+    status: TransientStatusReporter | None,
+    active_nodes: dict[str, tuple[str, float]],
+    stream: TextIO,
+    use_color: bool,
+) -> TransientStatusReporter | None:
+    if not stream.isatty() or not active_nodes:
+        return None
+    message: str = _format_active_node_status(active_nodes=active_nodes)
+    if status is None:
+        status = TransientStatusReporter(stream=stream, use_color=use_color)
+        status.start(message)
+        return status
+    status.update(message)
+    return status
+
+
+def _format_active_node_status(*, active_nodes: dict[str, tuple[str, float]]) -> str:
+    now: float = time.monotonic()
+    ordered: tuple[tuple[str, float], ...] = tuple(
+        sorted(active_nodes.values(), key=lambda item: item[1])
+    )
+    displayed: tuple[str, ...] = tuple(
+        f"{name} {max(0, int(now - started_at))}s" for name, started_at in ordered[:3]
+    )
+    extra_count: int = len(ordered) - len(displayed)
+    suffix: str = f", +{extra_count} more" if extra_count > 0 else ""
+    node_label: str = "node" if len(active_nodes) == 1 else "nodes"
+    return f"running {len(active_nodes)} dbt {node_label}: {', '.join(displayed)}{suffix}"
+
+
 def parse_dbt_node_start_message(*, event: dict[str, object]) -> str | None:
     """Parse a dbt node-start event into a user-facing progress message."""
 

{sqlbuild-0.45.0 → sqlbuild-0.45.1}/src/sqlbuild/integrations/dbt/pipeline/helpers/defer_clone.py

@@ -20,6 +20,7 @@ from sqlbuild.integrations.dbt.helpers.graph.core import (
     build_dbt_combined_graph,
     combined_graph_node_is_clonable,
     combined_graph_node_is_view,
+    dbt_model_graph_key,
     sqlbuild_model_graph_key,
 )
 from sqlbuild.integrations.dbt.helpers.manifest.core import build_dbt_manifest_index
@@ -84,6 +85,7 @@ def run_dbt_defer_clone_prephase(
     on_progress: Callable[[str], None] | None,
 ) -> None:
     if not unique_ids:
+        _report_progress(on_progress, "defer-clone enabled but no clonable dbt boundary resolved.")
         return
     production_ref: DbtProductionRefConfig = discovered_inputs.project_config.dbt.production_ref
     if production_ref.git_ref is None or production_ref.generate_schema_name_override is None:
@@ -155,12 +157,14 @@ def resolve_defer_clone_unique_ids(
     manifest: DbtManifestIndex,
     project: CompiledProject,
     selected_sqlbuild_model_names: tuple[str, ...],
+    selected_dbt_unique_ids: tuple[str, ...],
     required_dbt_unique_ids: tuple[str, ...],
 ) -> frozenset[str]:
-    """Resolve the first non-view dbt ancestors to clone for SQLBuild-selected boundaries."""
+    """Resolve the first non-view dbt ancestors to clone for selected boundaries."""
 
-    selected: frozenset[DbtCombinedGraphKey] = frozenset(
-        sqlbuild_model_graph_key(model_name) for model_name in selected_sqlbuild_model_names
+    selected: frozenset[DbtCombinedGraphKey] = _defer_clone_seed_keys(
+        selected_sqlbuild_model_names=selected_sqlbuild_model_names,
+        selected_dbt_unique_ids=selected_dbt_unique_ids,
     )
 
     def is_clonable(key: DbtCombinedGraphKey) -> bool:
@@ -190,6 +194,7 @@ def resolve_defer_clone_view_chain_terms(
     manifest: DbtManifestIndex,
     project: CompiledProject,
     selected_sqlbuild_model_names: tuple[str, ...],
+    selected_dbt_unique_ids: tuple[str, ...],
 ) -> tuple[str, ...]:
     """Return dbt model selector terms for view ancestors that must rebuild over clones."""
 
@@ -198,6 +203,7 @@ def resolve_defer_clone_view_chain_terms(
         manifest=manifest,
         project=project,
         selected_sqlbuild_model_names=selected_sqlbuild_model_names,
+        selected_dbt_unique_ids=selected_dbt_unique_ids,
     )
     terms: set[str] = set()
     view_key: DbtCombinedGraphKey
@@ -216,6 +222,7 @@ def resolve_defer_clone_view_chain_unique_ids(
     manifest: DbtManifestIndex,
     project: CompiledProject,
     selected_sqlbuild_model_names: tuple[str, ...],
+    selected_dbt_unique_ids: tuple[str, ...],
 ) -> frozenset[str]:
     """Return dbt model unique IDs for view ancestors that must rebuild over clones."""
 
@@ -224,6 +231,7 @@ def resolve_defer_clone_view_chain_unique_ids(
         manifest=manifest,
         project=project,
         selected_sqlbuild_model_names=selected_sqlbuild_model_names,
+        selected_dbt_unique_ids=selected_dbt_unique_ids,
     )
     return frozenset(
         view_key.name for view_key in view_chain if view_key.owner == DbtCombinedGraphOwner.DBT
@@ -236,9 +244,11 @@ def _resolve_defer_clone_view_chain_keys(
     manifest: DbtManifestIndex,
     project: CompiledProject,
     selected_sqlbuild_model_names: tuple[str, ...],
+    selected_dbt_unique_ids: tuple[str, ...],
 ) -> frozenset[DbtCombinedGraphKey]:
-    selected: frozenset[DbtCombinedGraphKey] = frozenset(
-        sqlbuild_model_graph_key(model_name) for model_name in selected_sqlbuild_model_names
+    selected: frozenset[DbtCombinedGraphKey] = _defer_clone_seed_keys(
+        selected_sqlbuild_model_names=selected_sqlbuild_model_names,
+        selected_dbt_unique_ids=selected_dbt_unique_ids,
     )
 
     def is_clonable(key: DbtCombinedGraphKey) -> bool:
@@ -257,6 +267,19 @@ def _resolve_defer_clone_view_chain_keys(
     )
 
 
+def _defer_clone_seed_keys(
+    *,
+    selected_sqlbuild_model_names: tuple[str, ...],
+    selected_dbt_unique_ids: tuple[str, ...],
+) -> frozenset[DbtCombinedGraphKey]:
+    return frozenset(
+        (
+            *(sqlbuild_model_graph_key(model_name) for model_name in selected_sqlbuild_model_names),
+            *(dbt_model_graph_key(unique_id) for unique_id in selected_dbt_unique_ids),
+        )
+    )
+
+
 def _write_defer_clone_dbt_fingerprints(
     *,
     result: CloneExecutionResult,

{sqlbuild-0.45.0 → sqlbuild-0.45.1}/src/sqlbuild/integrations/dbt/pipeline/main/execute.py

@@ -320,6 +320,7 @@ def execute_dbt_interop_from_project(
             manifest=manifest,
             project=project,
             selected_sqlbuild_model_names=plan.selection.sqlbuild_model_names,
+            selected_dbt_unique_ids=plan.dbt_selected_unique_ids,
             required_dbt_unique_ids=plan.selection.dbt_required_unique_ids,
         )
         if effective_defer_clone_from
@@ -344,6 +345,7 @@ def execute_dbt_interop_from_project(
             manifest=manifest,
             project=project,
             selected_sqlbuild_model_names=plan.selection.sqlbuild_model_names,
+            selected_dbt_unique_ids=plan.dbt_selected_unique_ids,
         )
         if effective_defer_clone_from
         else ()
@@ -354,6 +356,7 @@ def execute_dbt_interop_from_project(
             manifest=manifest,
             project=project,
             selected_sqlbuild_model_names=plan.selection.sqlbuild_model_names,
+            selected_dbt_unique_ids=plan.dbt_selected_unique_ids,
         )
         if effective_defer_clone_from
         else frozenset()

{sqlbuild-0.45.0 → sqlbuild-0.45.1}/tests/e2e/src/sqlbuild/cli/commands/main/dbt/helpers.py

@@ -111,6 +111,7 @@ def prepare_dbt_diff_workspace(
     production_ref_git_ref: str = "prod",
     include_second_model: bool = False,
     include_view_model: bool = False,
+    include_defer_clone_chain: bool = False,
 ) -> Path:
     """Build a dbt diff workspace with prod and feature branch order tables."""
 
@@ -144,6 +145,8 @@ def prepare_dbt_diff_workspace(
         _write_dbt_diff_customers_model(workspace=workspace)
     if include_view_model:
         write_dbt_clone_summary_view_model(workspace=workspace, amount_cents=900)
+    if include_defer_clone_chain:
+        write_dbt_defer_clone_chain_models(workspace=workspace)
     (profiles_dir / "profiles.yml").write_text(
         "analytics:\n"
         "  target: dev\n"
@@ -219,6 +222,22 @@ def write_dbt_clone_summary_view_model(*, workspace: Path, amount_cents: int) ->
     )
 
 
+def write_dbt_defer_clone_chain_models(*, workspace: Path) -> None:
+    """Write a dbt-only selected model behind a deferred view chain."""
+
+    workspace.joinpath("dbt_project", "models", "dbt_order_summary.sql").write_text(
+        "{{ config(materialized='view') }}\n\n"
+        "select order_id, amount_cents from {{ ref('dbt_orders') }}\n",
+        encoding="utf-8",
+    )
+    workspace.joinpath("dbt_project", "models", "dbt_bias.sql").write_text(
+        "{{ config(materialized='table') }}\n\n"
+        "select order_id, amount_cents as bias_amount_cents "
+        "from {{ ref('dbt_order_summary') }}\n",
+        encoding="utf-8",
+    )
+
+
 def drop_dbt_clone_origin_orders_relation(*, workspace: Path) -> None:
     """Drop the prod relation after manifest baseline creation for warning E2Es."""
 

{sqlbuild-0.45.0 → sqlbuild-0.45.1}/tests/e2e/src/sqlbuild/cli/commands/main/dbt/test_execute.py

@@ -646,3 +646,65 @@ def test_given_sqlbuild_downstream_when_dbt_building_with_defer_clone_then_clone
         tuple(query_duckdb(db_path=workspace / "warehouse.duckdb", sql=test_case.rows_sql))
         == test_case.expected_rows
     )
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        DbtCloneE2ETestCase(
+            description="dbt build defer-clones dbt boundary for pure dbt selection",
+            command=(
+                "--no-color",
+                "dbt",
+                "build",
+                "--select",
+                "dbt_bias",
+                "--defer-clone-from",
+            ),
+            expected_returncode=0,
+            expected_stdout_fragments=(
+                "Compiling dbt production ref git ref 'prod'",
+                "Cloning deferred dbt boundary relations",
+                "dbt execution",
+                "dbt_bias",
+                "SQLBuild (0 selected)",
+                "skipped: no SQLBuild work selected",
+                "Completed successfully.",
+            ),
+            expected_rows=((1, 900), (2, 900)),
+            rows_sql="SELECT order_id, bias_amount_cents FROM main.dbt_bias ORDER BY order_id",
+        )
+    ],
+    ids=["dbt build defer-clones dbt boundary for pure dbt selection"],
+)
+def test_given_pure_dbt_selection_when_building_with_defer_clone_then_clones_dbt_boundary(
+    tmp_path: Path,
+    test_case: DbtCloneE2ETestCase,
+) -> None:
+    skip_unless_dbt_is_runnable()
+    workspace: Path = prepare_dbt_diff_workspace(
+        tmp_path=tmp_path,
+        workspace_name="dbt_pure_defer_clone_workspace",
+        include_defer_clone_chain=True,
+    )
+    write_dbt_diff_orders_model(
+        workspace=workspace,
+        amount_cents=111,
+        order_ids=(1, 3),
+        include_unique_key=True,
+        include_cursor_meta=True,
+    )
+
+    result: subprocess.CompletedProcess[str] = run_sqb(
+        command=test_case.command,
+        project_dir=workspace / "sqlbuild_project",
+    )
+
+    assert result.returncode == test_case.expected_returncode, result.stdout + result.stderr
+    fragment: str
+    for fragment in test_case.expected_stdout_fragments:
+        assert fragment in result.stdout
+    assert (
+        tuple(query_duckdb(db_path=workspace / "warehouse.duckdb", sql=test_case.rows_sql))
+        == test_case.expected_rows
+    )

{sqlbuild-0.45.0 → sqlbuild-0.45.1}/tests/unit/src/sqlbuild/integrations/dbt/_test_types.py

@@ -513,8 +513,10 @@ class DbtDeferCloneViewChainTermsTestCase:
     manifest_data: dict[str, object]
     sqlbuild_model_sql_by_name: dict[str, str]
     selected_sqlbuild_model_names: tuple[str, ...]
+    selected_dbt_unique_ids: tuple[str, ...]
     expected_terms: tuple[str, ...]
     expected_unique_ids: frozenset[str]
+    expected_clone_unique_ids: frozenset[str]
 
 
 @dataclass(frozen=True)

sqlbuild-0.45.1/tests/unit/src/sqlbuild/integrations/dbt/test_defer_clone.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+import pytest
+
+from sqlbuild.compiler.compile.models.core import CompiledProject
+from sqlbuild.integrations.dbt.helpers.graph.core import build_dbt_combined_graph
+from sqlbuild.integrations.dbt.helpers.manifest.core import build_dbt_manifest_index
+from sqlbuild.integrations.dbt.manifest.models import DbtManifestIndex
+from sqlbuild.integrations.dbt.models import DbtCombinedGraph
+from sqlbuild.integrations.dbt.pipeline.helpers.defer_clone import (
+    resolve_defer_clone_unique_ids,
+    resolve_defer_clone_view_chain_terms,
+    resolve_defer_clone_view_chain_unique_ids,
+)
+from tests.unit.src.sqlbuild.integrations.dbt._test_types import (
+    DbtDeferCloneViewChainTermsTestCase,
+)
+from tests.unit.src.sqlbuild.integrations.dbt.helpers import (
+    build_compiled_project_with_model_specs,
+    build_manifest_data,
+    build_manifest_model_node,
+)
+
+DBT_DEFER_CLONE_VIEW_CHAIN_TEST_CASES: list[DbtDeferCloneViewChainTermsTestCase] = [
+    DbtDeferCloneViewChainTermsTestCase(
+        description="returns exact fqn selector for skipped dbt view ancestor",
+        manifest_data=build_manifest_data(
+            nodes=(
+                build_manifest_model_node(
+                    unique_id="model.analytics.dbt_orders",
+                    package_name="analytics",
+                    name="dbt_orders",
+                    relation_name="analytics.dbt_orders",
+                    materialized="table",
+                    fqn=("analytics", "marts", "dbt_orders"),
+                ),
+                build_manifest_model_node(
+                    unique_id="model.analytics.dbt_orders_view",
+                    package_name="analytics",
+                    name="dbt_orders_view",
+                    relation_name="analytics.dbt_orders_view",
+                    depends_on_nodes=("model.analytics.dbt_orders",),
+                    materialized="view",
+                    fqn=("analytics", "staging", "dbt_orders_view"),
+                ),
+            )
+        ),
+        sqlbuild_model_sql_by_name={
+            "downstream": 'select * from __dbt_ref("dbt_orders_view")',
+        },
+        selected_sqlbuild_model_names=("downstream",),
+        selected_dbt_unique_ids=(),
+        expected_terms=("fqn:analytics.staging.dbt_orders_view",),
+        expected_unique_ids=frozenset({"model.analytics.dbt_orders_view"}),
+        expected_clone_unique_ids=frozenset({"model.analytics.dbt_orders"}),
+    ),
+    DbtDeferCloneViewChainTermsTestCase(
+        description="returns boundary and view chain for selected dbt model",
+        manifest_data=build_manifest_data(
+            nodes=(
+                build_manifest_model_node(
+                    unique_id="model.analytics.boundary_table",
+                    package_name="analytics",
+                    name="boundary_table",
+                    relation_name="analytics.boundary_table",
+                    materialized="table",
+                    fqn=("analytics", "marts", "boundary_table"),
+                ),
+                build_manifest_model_node(
+                    unique_id="model.analytics.stale_view",
+                    package_name="analytics",
+                    name="stale_view",
+                    relation_name="analytics.stale_view",
+                    depends_on_nodes=("model.analytics.boundary_table",),
+                    materialized="view",
+                    fqn=("analytics", "marts", "stale_view"),
+                ),
+                build_manifest_model_node(
+                    unique_id="model.analytics.selected_model",
+                    package_name="analytics",
+                    name="selected_model",
+                    relation_name="analytics.selected_model",
+                    depends_on_nodes=("model.analytics.stale_view",),
+                    materialized="table",
+                    fqn=("analytics", "staging", "selected_model"),
+                ),
+            )
+        ),
+        sqlbuild_model_sql_by_name={},
+        selected_sqlbuild_model_names=(),
+        selected_dbt_unique_ids=("model.analytics.selected_model",),
+        expected_terms=("fqn:analytics.marts.stale_view",),
+        expected_unique_ids=frozenset({"model.analytics.stale_view"}),
+        expected_clone_unique_ids=frozenset({"model.analytics.boundary_table"}),
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    DBT_DEFER_CLONE_VIEW_CHAIN_TEST_CASES,
+    ids=[case.description for case in DBT_DEFER_CLONE_VIEW_CHAIN_TEST_CASES],
+)
+def test_given_dbt_view_boundary_when_resolving_defer_clone_view_chain_then_returns_exact_terms(
+    test_case: DbtDeferCloneViewChainTermsTestCase,
+) -> None:
+    manifest: DbtManifestIndex = build_dbt_manifest_index(raw_data=test_case.manifest_data)
+    project: CompiledProject = build_compiled_project_with_model_specs(
+        sql_by_model_name=test_case.sqlbuild_model_sql_by_name,
+        tags_by_model_name={},
+        path_by_model_name={},
+    )
+    graph: DbtCombinedGraph = build_dbt_combined_graph(manifest=manifest, project=project)
+
+    result: tuple[str, ...] = resolve_defer_clone_view_chain_terms(
+        graph=graph,
+        manifest=manifest,
+        project=project,
+        selected_sqlbuild_model_names=test_case.selected_sqlbuild_model_names,
+        selected_dbt_unique_ids=test_case.selected_dbt_unique_ids,
+    )
+    unique_ids: frozenset[str] = resolve_defer_clone_view_chain_unique_ids(
+        graph=graph,
+        manifest=manifest,
+        project=project,
+        selected_sqlbuild_model_names=test_case.selected_sqlbuild_model_names,
+        selected_dbt_unique_ids=test_case.selected_dbt_unique_ids,
+    )
+    clone_unique_ids: frozenset[str] = resolve_defer_clone_unique_ids(
+        graph=graph,
+        manifest=manifest,
+        project=project,
+        selected_sqlbuild_model_names=test_case.selected_sqlbuild_model_names,
+        selected_dbt_unique_ids=test_case.selected_dbt_unique_ids,
+        required_dbt_unique_ids=(),
+    )
+
+    assert result == test_case.expected_terms
+    assert unique_ids == test_case.expected_unique_ids
+    assert clone_unique_ids == test_case.expected_clone_unique_ids

sqlbuild-0.45.0/.release-please-manifest.json

@@ -1,3 +0,0 @@
-{
-  ".": "0.45.0"
-}

sqlbuild-0.45.0/tests/unit/src/sqlbuild/integrations/dbt/test_defer_clone.py

@@ -1,85 +0,0 @@
-from __future__ import annotations
-
-import pytest
-
-from sqlbuild.compiler.compile.models.core import CompiledProject
-from sqlbuild.integrations.dbt.helpers.graph.core import build_dbt_combined_graph
-from sqlbuild.integrations.dbt.helpers.manifest.core import build_dbt_manifest_index
-from sqlbuild.integrations.dbt.manifest.models import DbtManifestIndex
-from sqlbuild.integrations.dbt.models import DbtCombinedGraph
-from sqlbuild.integrations.dbt.pipeline.helpers.defer_clone import (
-    resolve_defer_clone_view_chain_terms,
-    resolve_defer_clone_view_chain_unique_ids,
-)
-from tests.unit.src.sqlbuild.integrations.dbt._test_types import (
-    DbtDeferCloneViewChainTermsTestCase,
-)
-from tests.unit.src.sqlbuild.integrations.dbt.helpers import (
-    build_compiled_project_with_model_specs,
-    build_manifest_data,
-    build_manifest_model_node,
-)
-
-
-@pytest.mark.parametrize(
-    "test_case",
-    [
-        DbtDeferCloneViewChainTermsTestCase(
-            description="returns exact fqn selector for skipped dbt view ancestor",
-            manifest_data=build_manifest_data(
-                nodes=(
-                    build_manifest_model_node(
-                        unique_id="model.analytics.dbt_orders",
-                        package_name="analytics",
-                        name="dbt_orders",
-                        relation_name="analytics.dbt_orders",
-                        materialized="table",
-                        fqn=("analytics", "marts", "dbt_orders"),
-                    ),
-                    build_manifest_model_node(
-                        unique_id="model.analytics.dbt_orders_view",
-                        package_name="analytics",
-                        name="dbt_orders_view",
-                        relation_name="analytics.dbt_orders_view",
-                        depends_on_nodes=("model.analytics.dbt_orders",),
-                        materialized="view",
-                        fqn=("analytics", "staging", "dbt_orders_view"),
-                    ),
-                )
-            ),
-            sqlbuild_model_sql_by_name={
-                "downstream": 'select * from __dbt_ref("dbt_orders_view")',
-            },
-            selected_sqlbuild_model_names=("downstream",),
-            expected_terms=("fqn:analytics.staging.dbt_orders_view",),
-            expected_unique_ids=frozenset({"model.analytics.dbt_orders_view"}),
-        ),
-    ],
-    ids=["returns exact fqn selector for skipped dbt view ancestor"],
-)
-def test_given_dbt_view_boundary_when_resolving_defer_clone_view_chain_then_returns_exact_terms(
-    test_case: DbtDeferCloneViewChainTermsTestCase,
-) -> None:
-    manifest: DbtManifestIndex = build_dbt_manifest_index(raw_data=test_case.manifest_data)
-    project: CompiledProject = build_compiled_project_with_model_specs(
-        sql_by_model_name=test_case.sqlbuild_model_sql_by_name,
-        tags_by_model_name={},
-        path_by_model_name={},
-    )
-    graph: DbtCombinedGraph = build_dbt_combined_graph(manifest=manifest, project=project)
-
-    result: tuple[str, ...] = resolve_defer_clone_view_chain_terms(
-        graph=graph,
-        manifest=manifest,
-        project=project,
-        selected_sqlbuild_model_names=test_case.selected_sqlbuild_model_names,
-    )
-    unique_ids: frozenset[str] = resolve_defer_clone_view_chain_unique_ids(
-        graph=graph,
-        manifest=manifest,
-        project=project,
-        selected_sqlbuild_model_names=test_case.selected_sqlbuild_model_names,
-    )
-
-    assert result == test_case.expected_terms
-    assert unique_ids == test_case.expected_unique_ids