sqlbuild 0.38.0__tar.gz → 0.38.2__tar.gz

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

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

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [0.38.2](https://github.com/chio-labs/sqlbuild/compare/v0.38.1...v0.38.2) (2026-06-23)
+
+
+### Bug Fixes
+
+* **dbt:** improve target and routing resolution ([8235bc7](https://github.com/chio-labs/sqlbuild/commit/8235bc7f0667fb48a3fee55f4f4a762cedfa7706))
+* **dbt:** improve target and routing resolution ([5b03b6c](https://github.com/chio-labs/sqlbuild/commit/5b03b6cc3ee1a0eb22b28481ff7632c3a0ef2d0e))
+
+## [0.38.1](https://github.com/chio-labs/sqlbuild/compare/v0.38.0...v0.38.1) (2026-06-23)
+
+
+### Bug Fixes
+
+* **dbt:** preserve snowflake auth cache ([1ab74d0](https://github.com/chio-labs/sqlbuild/commit/1ab74d07d19a9491c5d52352dcc466a795633de6))
+* **dbt:** preserve snowflake auth cache ([e95e18a](https://github.com/chio-labs/sqlbuild/commit/e95e18acfc4aafd488bb71b8b65172f15cbecf29))
+
 ## [0.38.0](https://github.com/chio-labs/sqlbuild/compare/v0.37.7...v0.38.0) (2026-06-23)
 
 

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/PKG-INFO

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

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/pyproject.toml

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

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/src/sqlbuild/adapters/snowflake/client.py

@@ -69,6 +69,9 @@ class SnowflakeAdapter(BaseAdapter):
     adapter_name: ClassVar[str] = BuiltinAdapter.SNOWFLAKE.value
     sql_analysis_dialect_name: ClassVar[str | None] = "snowflake"
     max_identifier_length: ClassVar[int] = 255
+    connection_routing_keys: ClassVar[frozenset[str]] = frozenset(
+        {"source", "profile", "target", "project_dir", "profiles_dir"}
+    )
 
     def render_read_latest_fingerprints_sql(
         self,
@@ -1308,6 +1311,14 @@ class SnowflakeAdapter(BaseAdapter):
             ) from error
 
         connect_config: dict[str, Any] = dict(config)
+        for routing_key in self.connection_routing_keys:
+            connect_config.pop(routing_key, None)
+        authenticator: str = str(connect_config.get("authenticator", "")).lower()
+        if authenticator == "username_password_mfa":
+            connect_config.setdefault("client_request_mfa_token", True)
+            connect_config.setdefault("client_store_temporary_credential", True)
+        elif authenticator == "externalbrowser":
+            connect_config.setdefault("client_store_temporary_credential", True)
         role: object | None = connect_config.get("role")
         warehouse: object | None = connect_config.get("warehouse")
         database: object | None = connect_config.get("database")

sqlbuild-0.38.2/src/sqlbuild/cli/commands/main/dbt_debug.py

@@ -0,0 +1,48 @@
+"""CLI-owned dbt debug orchestration."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from sqlbuild.cli.commands.main.debug import run_debug as run_sqlbuild_debug
+from sqlbuild.integrations.dbt.pipeline.main.debug import debug_dbt_from_project
+from sqlbuild.shared.helpers.colors import supports_color
+from sqlbuild.shared.helpers.status import TransientStatusReporter
+
+
+def run_dbt_debug_command(project_dir: Path | None, args: tuple[str, ...], no_color: bool) -> int:
+    """Execute `sqb dbt debug`."""
+
+    effective_project_dir: Path = project_dir if project_dir is not None else Path.cwd()
+    use_color: bool = (not no_color) and supports_color()
+    dbt_status: TransientStatusReporter = TransientStatusReporter(
+        stream=sys.stderr,
+        use_color=use_color,
+    )
+    dbt_status.start("Running dbt debug...")
+    try:
+        dbt_returncode: int = debug_dbt_from_project(
+            project_dir=effective_project_dir,
+            args=args,
+            stdout_stream=sys.stdout,
+            stderr_stream=sys.stderr,
+        )
+    finally:
+        dbt_status.close()
+    sys.stdout.write("\n")
+    status: TransientStatusReporter = TransientStatusReporter(
+        stream=sys.stderr,
+        use_color=use_color,
+    )
+    status.start("Running SQLBuild diagnostics...")
+    try:
+        sqlbuild_returncode: int = run_sqlbuild_debug(
+            project_dir=project_dir,
+            no_color=no_color,
+            no_connection="--no-connection" in args,
+            json_output=False,
+        )
+    finally:
+        status.close()
+    return 0 if dbt_returncode == 0 and sqlbuild_returncode == 0 else 1

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/src/sqlbuild/cli/commands/main/dbt_init.py

@@ -11,7 +11,10 @@ from sqlbuild.cli.commands.main.helpers.dbt_init.branch_detection import (
 from sqlbuild.cli.commands.main.helpers.dbt_init.progress import DbtInitProgressReporter
 from sqlbuild.cli.commands.main.helpers.dbt_init.prompt import resolve_production_git_ref
 from sqlbuild.cli.commands.main.shared.exceptions import CliUserError
-from sqlbuild.integrations.dbt.main.profile_init import run_dbt_profile_init
+from sqlbuild.integrations.dbt.main.profile_init import (
+    _validate_dbt_profile_init_request,
+    run_dbt_profile_init,
+)
 from sqlbuild.integrations.dbt.models import (
     DbtInitProgressCallbacks,
     DbtInitRequest,
@@ -37,7 +40,12 @@ def run_dbt_init_command(
 ) -> int:
     """Execute SQLBuild-owned `sqb dbt init`."""
 
-    if dbt_project_dir is None:
+    resolved_dbt_project_dir: Path | None = (
+        None if dbt_project_dir is None else Path(dbt_project_dir)
+    )
+    if resolved_dbt_project_dir is None and (cwd / "dbt_project.yml").exists():
+        resolved_dbt_project_dir = Path(".")
+    if resolved_dbt_project_dir is None:
         raise CliUserError(
             "sqb dbt init requires --project-dir pointing at a dbt project",
             code="C242",
@@ -47,24 +55,36 @@ def run_dbt_init_command(
         stream=sys.stdout,
         use_color=use_color,
     )
+    base_request: DbtInitRequest = DbtInitRequest(
+        cwd=cwd,
+        dbt_project_dir=resolved_dbt_project_dir,
+        profiles_dir=None if profiles_dir is None else Path(profiles_dir),
+        profile_name=profile_name,
+        target_name=target_name,
+        sqb_output_dir=None if sqb_output_dir is None else Path(sqb_output_dir),
+        dry_run=dry_run,
+        overwrite=overwrite,
+        skip_dbt_debug=skip_dbt_debug,
+    )
+    _validate_dbt_profile_init_request(request=base_request)
     resolved_production_git_ref: str = resolve_production_git_ref(
         explicit_git_ref=production_git_ref,
         input_stream=sys.stdin,
         output_stream=sys.stdout,
         use_color=use_color,
-        default_ref=detect_default_production_git_ref(git_probe_dir=Path(dbt_project_dir)),
+        default_ref=detect_default_production_git_ref(git_probe_dir=cwd / resolved_dbt_project_dir),
     )
     result: DbtInitResult = run_dbt_profile_init(
         request=DbtInitRequest(
             cwd=cwd,
-            dbt_project_dir=Path(dbt_project_dir),
-            profiles_dir=None if profiles_dir is None else Path(profiles_dir),
-            profile_name=profile_name,
-            target_name=target_name,
-            sqb_output_dir=None if sqb_output_dir is None else Path(sqb_output_dir),
-            dry_run=dry_run,
-            overwrite=overwrite,
-            skip_dbt_debug=skip_dbt_debug,
+            dbt_project_dir=base_request.dbt_project_dir,
+            profiles_dir=base_request.profiles_dir,
+            profile_name=base_request.profile_name,
+            target_name=base_request.target_name,
+            sqb_output_dir=base_request.sqb_output_dir,
+            dry_run=base_request.dry_run,
+            overwrite=base_request.overwrite,
+            skip_dbt_debug=base_request.skip_dbt_debug,
             production_git_ref=resolved_production_git_ref,
             progress_callbacks=(
                 DbtInitProgressCallbacks(

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/src/sqlbuild/cli/commands/main/shared/helpers/connection/core.py

@@ -16,6 +16,9 @@ from sqlbuild.spec.models.project import resolve_effective_adapter_name
 _DUCKDB_SNOWFLAKE_LIKE_WARNING_KEYS: frozenset[str] = frozenset(
     {"account", "authenticator", "role", "token", "warehouse"}
 )
+_DBT_PROFILE_CONNECTION_ROUTING_KEYS: frozenset[str] = frozenset(
+    {"source", "profile", "target", "project_dir", "profiles_dir"}
+)
 
 
 def resolve_connection_config(
@@ -42,7 +45,12 @@ def resolve_connection_config(
         if resolved_dbt_profile is not None:
             for warning in resolved_dbt_profile.warnings:
                 print(f"Warning: {warning}", file=sys.stderr)
-            config = resolved_dbt_profile.connection
+            user_overrides: dict[str, object] = {
+                key: value
+                for key, value in raw_config.items()
+                if key not in _DBT_PROFILE_CONNECTION_ROUTING_KEYS
+            }
+            config = {**resolved_dbt_profile.connection, **user_overrides}
     elif config.get("source") == "dbt_profile":
         raise DbtProfileError("connection.source = 'dbt_profile' requires project configuration")
     _warn_if_duckdb_has_snowflake_like_keys(adapter_name=adapter_name, config=config)

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/src/sqlbuild/compiler/discovery/helpers/yml/project.py

@@ -704,11 +704,12 @@ def _load_local_dbt(*, payload: object, file_path: Path) -> LocalDbtConfig:
     mapping: dict[str, object] = _coerce_mapping(payload=payload, label="dbt", file_path=file_path)
     _validate_allowed_keys(
         mapping=mapping,
-        allowed_keys=frozenset({"vars"}),
+        allowed_keys=frozenset({"target", "vars"}),
         label="dbt",
         file_path=file_path,
     )
     return LocalDbtConfig(
+        target=_optional_str(payload=mapping, key="target"),
         vars=_load_object_mapping(payload=mapping.get("vars"), file_path=file_path),
     )
 

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/src/sqlbuild/integrations/dbt/helpers/config/core.py

@@ -6,7 +6,7 @@ from pathlib import Path
 
 from sqlbuild.integrations.dbt.exceptions import DbtInteropConfigError
 from sqlbuild.integrations.dbt.models import DbtCliConfigOverrides, ResolvedDbtConfig
-from sqlbuild.spec.models.project import DbtConfig
+from sqlbuild.spec.models.project import DbtConfig, LocalDbtConfig
 
 
 def resolve_dbt_config(
@@ -15,6 +15,7 @@ def resolve_dbt_config(
     config: DbtConfig,
     overrides: DbtCliConfigOverrides,
     require_project_dir: bool,
+    local_config: LocalDbtConfig | None = None,
 ) -> ResolvedDbtConfig:
     """Resolve dbt config from CLI overrides and project config."""
 
@@ -45,7 +46,13 @@ def resolve_dbt_config(
         project_root=project_root,
         raw_value=raw_target_path,
     )
-    target: str | None = overrides.target if overrides.target is not None else config.target
+    target: str | None = (
+        overrides.target
+        if overrides.target is not None
+        else local_config.target
+        if local_config is not None and local_config.target is not None
+        else config.target
+    )
 
     return ResolvedDbtConfig(
         project_dir=project_dir,

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/src/sqlbuild/integrations/dbt/helpers/planning/runtime.py

@@ -28,6 +28,7 @@ def resolve_dbt_plan_options(
     resolved: ResolvedDbtConfig = resolve_dbt_config(
         project_root=project_dir,
         config=discovered_inputs.project_config.dbt,
+        local_config=discovered_inputs.local_config.dbt,
         overrides=overrides,
         require_project_dir=True,
     )

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/src/sqlbuild/integrations/dbt/helpers/profile/init.py

@@ -30,10 +30,10 @@ def build_dbt_init_project(*, request: DbtInitRequest) -> DbtInitResult:
     """Create or render a minimal SQLBuild project from a dbt project."""
 
     dbt_project_dir: Path = _resolve_path(root=request.cwd, path=request.dbt_project_dir)
-    profiles_dir: Path = (
-        _resolve_path(root=request.cwd, path=request.profiles_dir)
-        if request.profiles_dir is not None
-        else default_profiles_dir()
+    profiles_dir: Path = _resolve_profiles_dir(
+        cwd=request.cwd,
+        dbt_project_dir=dbt_project_dir,
+        profiles_dir=request.profiles_dir,
     )
     output_dir: Path = (
         _resolve_path(root=request.cwd, path=request.sqb_output_dir)
@@ -113,6 +113,23 @@ def build_dbt_init_project(*, request: DbtInitRequest) -> DbtInitResult:
     )
 
 
+def validate_dbt_init_project(*, request: DbtInitRequest) -> None:
+    """Validate dbt init project/profile discovery before interactive prompting."""
+
+    dbt_project_dir: Path = _resolve_path(root=request.cwd, path=request.dbt_project_dir)
+    profiles_dir: Path = _resolve_profiles_dir(
+        cwd=request.cwd,
+        dbt_project_dir=dbt_project_dir,
+        profiles_dir=request.profiles_dir,
+    )
+    metadata: DbtProjectProfileMetadata = load_dbt_project_metadata(project_dir=dbt_project_dir)
+    profile_name: str = request.profile_name or metadata.profile_name
+    select_dbt_profile_output(
+        profile=load_raw_dbt_profile(profiles_dir=profiles_dir, profile_name=profile_name),
+        target_name=request.target_name,
+    )
+
+
 def _resolve_path(*, root: Path, path: Path) -> Path:
     expanded: Path = path.expanduser()
     if expanded.is_absolute():
@@ -120,6 +137,19 @@ def _resolve_path(*, root: Path, path: Path) -> Path:
     return (root / expanded).resolve()
 
 
+def _resolve_profiles_dir(*, cwd: Path, dbt_project_dir: Path, profiles_dir: Path | None) -> Path:
+    if profiles_dir is not None:
+        return _resolve_path(root=cwd, path=profiles_dir)
+    env_profiles_dir: str | None = os.environ.get("DBT_PROFILES_DIR")
+    if env_profiles_dir:
+        return _resolve_path(root=cwd, path=Path(env_profiles_dir))
+    if (dbt_project_dir / "profiles.yml").exists():
+        return dbt_project_dir
+    if (cwd / "profiles.yml").exists():
+        return cwd.resolve()
+    return default_profiles_dir()
+
+
 def _start_progress(callbacks: DbtInitProgressCallbacks, message: str) -> None:
     if callbacks.start is not None:
         callbacks.start(message)

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/src/sqlbuild/integrations/dbt/helpers/profile/normalize.py

@@ -130,40 +130,9 @@ def _normalize_postgres(*, resolved: ResolvedDbtProfileOutput) -> NormalizedDbtP
 
 def _normalize_snowflake(*, resolved: ResolvedDbtProfileOutput) -> NormalizedDbtProfileConnection:
     output: dict[str, object] = dict(resolved.output)
-    connection: dict[str, object] = _copy_present(
-        output,
-        (
-            "account",
-            "user",
-            "warehouse",
-            "database",
-            "schema",
-            "role",
-            "password",
-            "authenticator",
-            "private_key",
-            "private_key_path",
-            "private_key_passphrase",
-            "token",
-            "oauth_client_id",
-            "oauth_client_secret",
-            "query_tag",
-            "client_session_keep_alive",
-            "host",
-            "port",
-            "proxy_host",
-            "proxy_port",
-            "protocol",
-            "connect_retries",
-            "connect_timeout",
-            "retry_on_database_errors",
-            "retry_all",
-            "insecure_mode",
-            "reuse_connections",
-            "s3_stage_vpce_dns_name",
-            "platform_detection_timeout_seconds",
-        ),
-    )
+    connection: dict[str, object] = dict(output)
+    connection.pop("type", None)
+    connection.pop("threads", None)
     return NormalizedDbtProfileConnection(
         adapter=BuiltinAdapter.SNOWFLAKE.value,
         connection=connection,

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/src/sqlbuild/integrations/dbt/main/profile_init.py

@@ -2,7 +2,10 @@
 
 from __future__ import annotations
 
-from sqlbuild.integrations.dbt.helpers.profile.init import build_dbt_init_project
+from sqlbuild.integrations.dbt.helpers.profile.init import (
+    build_dbt_init_project,
+    validate_dbt_init_project,
+)
 from sqlbuild.integrations.dbt.models import DbtInitRequest, DbtInitResult
 
 
@@ -10,3 +13,9 @@ def run_dbt_profile_init(*, request: DbtInitRequest) -> DbtInitResult:
     """Create or render a minimal SQLBuild project from a dbt project."""
 
     return build_dbt_init_project(request=request)
+
+
+def _validate_dbt_profile_init_request(*, request: DbtInitRequest) -> None:
+    """Validate dbt profile init inputs without writing files or prompting."""
+
+    validate_dbt_init_project(request=request)

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/src/sqlbuild/integrations/dbt/pipeline/main/debug.py

@@ -30,6 +30,7 @@ def debug_dbt_from_project(
     resolved: ResolvedDbtConfig = resolve_dbt_config(
         project_root=project_dir,
         config=discovered_inputs.project_config.dbt,
+        local_config=discovered_inputs.local_config.dbt,
         overrides=parse_dbt_config_overrides(args),
         require_project_dir=True,
     )

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/src/sqlbuild/integrations/dbt/shared/helpers/connection.py

@@ -10,6 +10,10 @@ from sqlbuild.compiler.discovery.models import DiscoveredProjectInputs
 from sqlbuild.integrations.dbt.main.profile_connection import resolve_raw_dbt_profile_connection
 from sqlbuild.integrations.dbt.models import NormalizedDbtProfileConnection
 
+_DBT_PROFILE_CONNECTION_ROUTING_KEYS: frozenset[str] = frozenset(
+    {"source", "profile", "target", "project_dir", "profiles_dir"}
+)
+
 
 def resolve_connection_config(
     *,
@@ -32,7 +36,12 @@ def resolve_connection_config(
     if resolved_dbt_profile is not None:
         for warning in resolved_dbt_profile.warnings:
             print(f"Warning: {warning}", file=sys.stderr)
-        config = resolved_dbt_profile.connection
+        user_overrides: dict[str, object] = {
+            key: value
+            for key, value in raw_config.items()
+            if key not in _DBT_PROFILE_CONNECTION_ROUTING_KEYS
+        }
+        config = {**resolved_dbt_profile.connection, **user_overrides}
     database: object | None = config.get("database")
     if (
         adapter_name == BuiltinAdapter.DUCKDB

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/src/sqlbuild/spec/models/project.py

@@ -181,6 +181,7 @@ class DbtConfig:
 class LocalDbtConfig:
     """Local dbt interop configuration overrides."""
 
+    target: str | None = None
     vars: dict[str, object] = field(default_factory=dict)
 
 

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/tests/unit/src/sqlbuild/adapters/snowflake/_test_types.py

@@ -108,3 +108,10 @@ class SnowflakePruneSqlTestCase:
     schema: str
     retain_versions: int
     expected_fragments: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class SnowflakeConnectConfigTestCase:
+    description: str
+    config: dict[str, object]
+    expected_connect_kwargs: dict[str, object]

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/tests/unit/src/sqlbuild/adapters/snowflake/helpers.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import sys
+from types import ModuleType
 from typing import Any
 
 
@@ -77,3 +79,31 @@ class FakeSnowflakeMetadataConnection:
 
     def cursor(self) -> FakeSnowflakeMetadataCursor:
         return self._cursor
+
+
+class FakeSnowflakeRawConnection:
+    """Raw connector connection double for connect() tests."""
+
+    def cursor(self) -> Any:
+        raise AssertionError("connect test should not execute SQL")
+
+    def close(self) -> None:
+        pass
+
+
+def install_fake_snowflake_connector(monkeypatch: Any) -> dict[str, object]:
+    """Install a fake optional snowflake.connector module and capture connect kwargs."""
+
+    captured_kwargs: dict[str, object] = {}
+    snowflake_module: ModuleType = ModuleType("snowflake")
+    connector_module: ModuleType = ModuleType("snowflake.connector")
+
+    def connect(**kwargs: object) -> FakeSnowflakeRawConnection:
+        captured_kwargs.update(kwargs)
+        return FakeSnowflakeRawConnection()
+
+    connector_module.__dict__["connect"] = connect
+    snowflake_module.__dict__["connector"] = connector_module
+    monkeypatch.setitem(sys.modules, "snowflake", snowflake_module)
+    monkeypatch.setitem(sys.modules, "snowflake.connector", connector_module)
+    return captured_kwargs

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/tests/unit/src/sqlbuild/adapters/snowflake/test_client.py

@@ -23,6 +23,7 @@ from sqlbuild.compiler.compile.models.core import (
 from sqlbuild.compiler.compile.types import FunctionLanguage
 from sqlbuild.compiler.lineage.types import InferredNullability
 from tests.unit.src.sqlbuild.adapters.snowflake._test_types import (
+    SnowflakeConnectConfigTestCase,
     SnowflakeExpressionInferenceProfileTestCase,
     SnowflakeLoadSeedTestCase,
     SnowflakeMoveOrCopyRelationTestCase,
@@ -43,8 +44,62 @@ from tests.unit.src.sqlbuild.adapters.snowflake.helpers import (
     FakeSnowflakeDescribeCursor,
     FakeSnowflakeMetadataConnection,
     FakeSnowflakeMetadataCursor,
+    install_fake_snowflake_connector,
 )
 
+SNOWFLAKE_CONNECT_CONFIG_TEST_CASES: list[SnowflakeConnectConfigTestCase] = [
+    SnowflakeConnectConfigTestCase(
+        description="defaults MFA token cache flags for username password MFA",
+        config={
+            "account": "acct",
+            "user": "analytics",
+            "password": "secret",
+            "authenticator": "username_password_mfa",
+        },
+        expected_connect_kwargs={
+            "account": "acct",
+            "user": "analytics",
+            "password": "secret",
+            "authenticator": "username_password_mfa",
+            "client_request_mfa_token": True,
+            "client_store_temporary_credential": True,
+        },
+    ),
+    SnowflakeConnectConfigTestCase(
+        description="preserves explicit MFA token cache flags",
+        config={
+            "account": "acct",
+            "authenticator": "username_password_mfa",
+            "client_request_mfa_token": False,
+            "client_store_temporary_credential": False,
+        },
+        expected_connect_kwargs={
+            "account": "acct",
+            "authenticator": "username_password_mfa",
+            "client_request_mfa_token": False,
+            "client_store_temporary_credential": False,
+        },
+    ),
+    SnowflakeConnectConfigTestCase(
+        description="strips SQLBuild routing keys before connector call",
+        config={
+            "source": "explicit",
+            "profile": "analytics",
+            "target": "dev",
+            "project_dir": "dbt_project",
+            "profiles_dir": "profiles",
+            "account": "acct",
+            "authenticator": "programmatic_access_token",
+            "token": "secret-token",
+        },
+        expected_connect_kwargs={
+            "account": "acct",
+            "authenticator": "programmatic_access_token",
+            "token": "secret-token",
+        },
+    ),
+]
+
 
 @pytest.mark.parametrize(
     "test_case",
@@ -87,6 +142,23 @@ def test_given_snowflake_adapter_when_getting_inference_profile_then_returns_exp
     assert upper_rule((InferredNullability.NON_NULL,)) == test_case.expected_rule_results["UPPER"]
 
 
+@pytest.mark.parametrize(
+    "test_case",
+    SNOWFLAKE_CONNECT_CONFIG_TEST_CASES,
+    ids=[case.description for case in SNOWFLAKE_CONNECT_CONFIG_TEST_CASES],
+)
+def test_given_mfa_authenticator_when_connecting_then_uses_expected_token_cache_kwargs(
+    test_case: SnowflakeConnectConfigTestCase,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    captured_kwargs: dict[str, object] = install_fake_snowflake_connector(monkeypatch)
+    adapter: SnowflakeAdapter = SnowflakeAdapter()
+
+    adapter.connect(test_case.config)
+
+    assert captured_kwargs == test_case.expected_connect_kwargs
+
+
 @pytest.mark.parametrize(
     "test_case",
     [

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/tests/unit/src/sqlbuild/cli/commands/main/dbt/_test_types.py

@@ -27,6 +27,7 @@ class DbtDebugWrapperTestCase:
     expected_dbt_args: tuple[str, ...]
     expected_sqlbuild_no_connection: bool
     expected_exit_code: int
+    expected_stderr_fragments: tuple[str, ...] = ()
 
 
 @dataclass(frozen=True)
@@ -59,3 +60,18 @@ class DbtInitPromptTestCase:
     input_is_tty: bool
     expected_git_ref: str
     expected_output_fragments: tuple[str, ...] = ()
+
+
+@dataclass(frozen=True)
+class DbtInitProjectDirDefaultTestCase:
+    description: str
+    dbt_project_text: str
+    expected_dbt_project_dir: str
+
+
+@dataclass(frozen=True)
+class DbtInitValidationOrderTestCase:
+    description: str
+    input_text: str
+    expected_error_fragment: str
+    unexpected_output_fragments: tuple[str, ...]

{sqlbuild-0.38.0 → sqlbuild-0.38.2}/tests/unit/src/sqlbuild/cli/commands/main/dbt/test_dbt.py

@@ -75,6 +75,10 @@ DEBUG_WRAPPER_TEST_CASES: list[DbtDebugWrapperTestCase] = [
         expected_dbt_args=("--project-dir", "dbt_project", "--no-connection"),
         expected_sqlbuild_no_connection=True,
         expected_exit_code=0,
+        expected_stderr_fragments=(
+            "Running dbt debug...",
+            "Running SQLBuild diagnostics...",
+        ),
     ),
     DbtDebugWrapperTestCase(
         description="debug returns failure when dbt debug fails after SQLBuild diagnostics",
@@ -228,6 +232,7 @@ def test_given_dbt_execution_command_when_running_then_routes_expected_stream_an
 def test_given_dbt_debug_command_when_running_then_invokes_dbt_and_sqlbuild_debug(
     test_case: DbtDebugWrapperTestCase,
     monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
 ) -> None:
     dbt_calls: list[tuple[Path, tuple[str, ...], object, object]] = []
     sqlbuild_calls: list[tuple[Path | None, bool, bool, bool]] = []
@@ -277,6 +282,9 @@ def test_given_dbt_debug_command_when_running_then_invokes_dbt_and_sqlbuild_debu
     assert sqlbuild_calls == [
         (Path("/project"), True, test_case.expected_sqlbuild_no_connection, False)
     ]
+    captured: CaptureResult[str] = capsys.readouterr()
+    for fragment in test_case.expected_stderr_fragments:
+        assert fragment in captured.err
 
 
 @pytest.mark.parametrize(