sqlbuild 0.37.5__tar.gz → 0.37.6__tar.gz

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

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

{sqlbuild-0.37.5 → sqlbuild-0.37.6}/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.37.6](https://github.com/chio-labs/sqlbuild/compare/v0.37.5...v0.37.6) (2026-06-23)
+
+
+### Bug Fixes
+
+* **dbt:** clarify reuse skip messaging, detect default branch, accept  trailing global flags ([cd3d093](https://github.com/chio-labs/sqlbuild/commit/cd3d093a6b4732d17b01d76b468271f166373139))
+* **dbt:** clarify reuse skip messaging, detect default branch, accept trailing global flags ([7d0a3b7](https://github.com/chio-labs/sqlbuild/commit/7d0a3b77a4185bd976628eb7957eb619f7ce6284))
+
 ## [0.37.5](https://github.com/chio-labs/sqlbuild/compare/v0.37.4...v0.37.5) (2026-06-23)
 
 

{sqlbuild-0.37.5 → sqlbuild-0.37.6}/PKG-INFO

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

{sqlbuild-0.37.5 → sqlbuild-0.37.6}/pyproject.toml

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

{sqlbuild-0.37.5 → sqlbuild-0.37.6}/src/sqlbuild/cli/commands/main/dbt_init.py

@@ -5,6 +5,9 @@ from __future__ import annotations
 import sys
 from pathlib import Path
 
+from sqlbuild.cli.commands.main.helpers.dbt_init.branch_detection import (
+    detect_default_production_git_ref,
+)
 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
@@ -49,6 +52,7 @@ def run_dbt_init_command(
         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)),
     )
     result: DbtInitResult = run_dbt_profile_init(
         request=DbtInitRequest(

{sqlbuild-0.37.5 → sqlbuild-0.37.6}/src/sqlbuild/cli/commands/main/entry.py

@@ -607,7 +607,17 @@ def _main_with_dependencies(
             "diff",
             "clone",
         }:
-            args.dbt_args = unknown_args
+            dbt_passthrough_args: list[str] = []
+            dbt_arg: str
+            for dbt_arg in unknown_args:
+                if dbt_arg == "--no-color":
+                    args.no_color = True
+                    continue
+                if dbt_arg == "--debug":
+                    args.debug = True
+                    continue
+                dbt_passthrough_args.append(dbt_arg)
+            args.dbt_args = dbt_passthrough_args
         elif unknown_args:
             parser.error(f"unrecognized arguments: {' '.join(unknown_args)}")
         if args.command in {CliCommand.BUILD, CliCommand.LOAD, CliCommand.SEED}:

{sqlbuild-0.37.5 → sqlbuild-0.37.6}/src/sqlbuild/cli/commands/main/helpers/dbt_auto_init.py

@@ -6,6 +6,9 @@ import sys
 from pathlib import Path
 from typing import TextIO
 
+from sqlbuild.cli.commands.main.helpers.dbt_init.branch_detection import (
+    detect_default_production_git_ref,
+)
 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.compiler.discovery.constants import PROJECT_CONFIG_FILENAME
@@ -48,6 +51,7 @@ def ensure_sqlbuild_project_for_dbt_command(
         input_stream=sys.stdin,
         output_stream=progress_stream,
         use_color=use_color,
+        default_ref=detect_default_production_git_ref(git_probe_dir=dbt_project_dir),
     )
     result: DbtInitResult = run_dbt_profile_init(
         request=DbtInitRequest(

sqlbuild-0.37.6/src/sqlbuild/cli/commands/main/helpers/dbt_init/branch_detection.py

@@ -0,0 +1,68 @@
+"""Best-effort production default branch detection for dbt reuse setup."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+_FALLBACK_DEFAULT_BRANCH: str = "main"
+_COMMON_DEFAULT_BRANCHES: tuple[str, ...] = ("main", "master")
+
+
+def detect_default_production_git_ref(*, git_probe_dir: Path) -> str:
+    """Detect a sensible production git ref, defaulting to 'main' when unknown."""
+
+    git_root: str | None = _git_text(
+        args=("-C", str(git_probe_dir), "rev-parse", "--show-toplevel")
+    )
+    if git_root is None:
+        return _FALLBACK_DEFAULT_BRANCH
+    remote_head: str | None = _remote_head_branch(git_root=git_root)
+    if remote_head is not None:
+        return remote_head
+    existing_common: str | None = _first_existing_common_branch(git_root=git_root)
+    if existing_common is not None:
+        return existing_common
+    current_branch: str | None = _git_text(args=("-C", git_root, "branch", "--show-current"))
+    if current_branch:
+        return current_branch
+    return _FALLBACK_DEFAULT_BRANCH
+
+
+def _remote_head_branch(*, git_root: str) -> str | None:
+    head_ref: str | None = _git_text(
+        args=("-C", git_root, "symbolic-ref", "refs/remotes/origin/HEAD")
+    )
+    if head_ref is None:
+        return None
+    branch: str = head_ref.removeprefix("refs/remotes/origin/")
+    if not branch or branch == head_ref:
+        return None
+    return branch
+
+
+def _first_existing_common_branch(*, git_root: str) -> str | None:
+    branch: str
+    for branch in _COMMON_DEFAULT_BRANCHES:
+        verified: str | None = _git_text(
+            args=("-C", git_root, "rev-parse", "--verify", "--quiet", f"refs/heads/{branch}")
+        )
+        if verified is not None:
+            return branch
+    return None
+
+
+def _git_text(*, args: tuple[str, ...]) -> str | None:
+    try:
+        result: subprocess.CompletedProcess[str] = subprocess.run(
+            ("git", *args),
+            capture_output=True,
+            check=False,
+            text=True,
+        )
+    except FileNotFoundError:
+        return None
+    if result.returncode != 0:
+        return None
+    output: str = result.stdout.strip()
+    return output or None

{sqlbuild-0.37.5 → sqlbuild-0.37.6}/src/sqlbuild/cli/commands/main/helpers/dbt_init/prompt.py

@@ -13,12 +13,12 @@ def resolve_production_git_ref(
     input_stream: TextIO,
     output_stream: TextIO,
     use_color: bool,
+    default_ref: str = "main",
 ) -> str:
     """Return the production-shaped git ref to write into dbt reuse config."""
 
     if explicit_git_ref is not None and explicit_git_ref.strip():
         return explicit_git_ref.strip()
-    default_ref: str = "main"
     if not input_stream.isatty():
         return default_ref
     style: CliStyle = CliStyle(use_color=use_color)

{sqlbuild-0.37.5 → sqlbuild-0.37.6}/src/sqlbuild/integrations/dbt/exceptions.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from sqlbuild.integrations.dbt.types import DbtReuseUnavailableReason
+
 
 class DbtInteropError(ValueError):
     """Base class for expected dbt interop errors."""
@@ -38,6 +40,17 @@ class DbtReuseUnavailableError(DbtInteropError):
 
     code: str = "C243"
 
+    def __init__(
+        self,
+        message: str,
+        *,
+        reason: DbtReuseUnavailableReason,
+        code: str | None = None,
+        help: str | None = None,
+    ) -> None:
+        super().__init__(message, code=code, help=help)
+        self.reason = reason
+
 
 class DbtProfileError(DbtInteropConfigError):
     """Raised when a dbt profile cannot be resolved for SQLBuild."""

{sqlbuild-0.37.5 → sqlbuild-0.37.6}/src/sqlbuild/integrations/dbt/helpers/reuse/reuse_from.py

@@ -20,6 +20,7 @@ from sqlbuild.integrations.dbt.models import (
     DbtCommandResult,
     DbtReuseFromCompileResult,
 )
+from sqlbuild.integrations.dbt.types import DbtReuseUnavailableReason
 from sqlbuild.spec.models.project import DbtReuseFromConfig
 
 
@@ -111,6 +112,7 @@ def _git_root(*, path: Path) -> Path:
     if result.returncode != 0:
         raise DbtReuseUnavailableError(
             "dbt reuse_from requires the SQLBuild project to be in a git repository",
+            reason=DbtReuseUnavailableReason.NO_GIT_REPOSITORY,
             help=result.stderr or result.stdout or None,
         )
     return Path(result.stdout.strip()).resolve()
@@ -123,6 +125,7 @@ def _relative_to_git_root(*, path: Path, git_root: Path, label: str) -> Path:
     except ValueError as error:
         raise DbtReuseUnavailableError(
             f"dbt reuse_from requires the {label} to be inside the git repository",
+            reason=DbtReuseUnavailableReason.PROJECT_OUTSIDE_GIT_ROOT,
             help=f"{resolved_path} is not under {git_root}.",
         ) from error
 
@@ -137,6 +140,7 @@ def _raise_if_current_branch(*, git_root: Path, git_ref: str) -> None:
     if current_branch and current_branch == git_ref:
         raise DbtReuseUnavailableError(
             "dbt reuse_from git_ref must not be the current branch",
+            reason=DbtReuseUnavailableReason.GIT_REF_IS_CURRENT_BRANCH,
             help=(
                 "Choose a production-shaped branch or tag that differs from the active "
                 "worktree branch."
@@ -159,6 +163,7 @@ def _refresh_git_ref_for_archive(*, git_root: Path, git_ref: str) -> str:
     if result.returncode != 0:
         raise DbtReuseUnavailableError(
             "dbt reuse_from git_ref could not be refreshed from its remote",
+            reason=DbtReuseUnavailableReason.REMOTE_REFRESH_FAILED,
             help=result.stderr or result.stdout or None,
         )
     return remote_ref
@@ -180,6 +185,7 @@ def _raise_if_missing_git_ref(
         )
     raise DbtReuseUnavailableError(
         f"dbt reuse_from git_ref '{configured_ref}' does not exist in this repository",
+        reason=DbtReuseUnavailableReason.GIT_REF_MISSING,
         help=(
             f"SQLBuild tried to archive git ref '{configured_ref}' from {git_root}. "
             "Choose the branch or tag that represents production, then update "

{sqlbuild-0.37.5 → sqlbuild-0.37.6}/src/sqlbuild/integrations/dbt/pipeline/helpers/reuse_plan.py

@@ -30,6 +30,7 @@ from sqlbuild.integrations.dbt.models import (
     DbtReusePlanningResult,
 )
 from sqlbuild.integrations.dbt.shared.helpers.connection import resolve_connection_config
+from sqlbuild.integrations.dbt.types import DbtReuseUnavailableReason
 from sqlbuild.spec.models.project import DbtReuseFromConfig
 
 
@@ -63,7 +64,7 @@ def build_dbt_reuse_plan_output(
         )
     except DbtReuseUnavailableError as error:
         if warnings is not None:
-            warnings.append(f"dbt reuse_from skipped: {error.message}. Running standard build.")
+            warnings.append(_reuse_unavailable_message(error=error, git_ref=reuse_from.git_ref))
         return None
     reuse_manifest: DbtManifestIndex = build_dbt_manifest_index(
         raw_data=json.loads(compile_result.manifest_contents)
@@ -213,3 +214,34 @@ def build_dbt_dependency_baseline_plan_output(
         ),
         dbt_model_plan=dbt_model_plan,
     )
+
+
+def _reuse_unavailable_message(*, error: DbtReuseUnavailableError, git_ref: str | None) -> str:
+    ref: str = git_ref or "production"
+    if error.reason is DbtReuseUnavailableReason.NO_GIT_REPOSITORY:
+        return (
+            "dbt reuse-from-production is enabled but inactive: this project is not in a "
+            "git repository, so there is no production branch to reuse tables from. Built "
+            "normally. Run inside your dbt project's git repository to enable reuse."
+        )
+    if error.reason is DbtReuseUnavailableReason.GIT_REF_IS_CURRENT_BRANCH:
+        return (
+            f"dbt reuse-from-production is enabled but inactive: you are on branch '{ref}', "
+            "the configured production ref, so there is nothing to reuse. Built normally. "
+            "Switch to a feature branch to reuse unchanged production tables."
+        )
+    if error.reason is DbtReuseUnavailableReason.GIT_REF_MISSING:
+        return (
+            f"dbt reuse-from-production is enabled but git ref '{ref}' was not found. Set "
+            "[dbt.reuse_from].git_ref to your production branch or tag. Built normally."
+        )
+    if error.reason is DbtReuseUnavailableReason.PROJECT_OUTSIDE_GIT_ROOT:
+        return (
+            "dbt reuse-from-production is enabled but inactive: the project is outside the "
+            "git repository root, so its history cannot be read. Built normally. "
+            f"{error.help or ''}".rstrip()
+        )
+    return (
+        f"dbt reuse-from-production is enabled but git ref '{ref}' could not be refreshed "
+        "from its remote. Built normally with local history. Check network or remote access."
+    )

{sqlbuild-0.37.5 → sqlbuild-0.37.6}/src/sqlbuild/integrations/dbt/types.py

@@ -169,3 +169,13 @@ class DbtReuseMetadataStatus(StrEnum):
     """dbt reuse_from fingerprint metadata status values."""
 
     SUCCESS = "success"
+
+
+class DbtReuseUnavailableReason(StrEnum):
+    """Why reuse_from could not run, to drive clear user-facing messaging."""
+
+    NO_GIT_REPOSITORY = "no_git_repository"
+    PROJECT_OUTSIDE_GIT_ROOT = "project_outside_git_root"
+    GIT_REF_IS_CURRENT_BRANCH = "git_ref_is_current_branch"
+    GIT_REF_MISSING = "git_ref_missing"
+    REMOTE_REFRESH_FAILED = "remote_refresh_failed"

{sqlbuild-0.37.5 → sqlbuild-0.37.6}/tests/e2e/src/sqlbuild/cli/commands/main/dbt/_test_types.py

@@ -346,6 +346,14 @@ class DbtInitInvalidReuseRefE2ETestCase:
     expected_stdout_fragments: tuple[str, ...]
 
 
+@dataclass(frozen=True)
+class DbtInitDetectedReuseRefE2ETestCase:
+    description: str
+    production_ref: str
+    expected_config_git_ref: str
+    unexpected_stdout_fragments: tuple[str, ...]
+
+
 @dataclass(frozen=True)
 class DbtPhase11ExecutionTestCase:
     description: str

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

@@ -91,12 +91,13 @@ def write_dbt_init_orders_model(*, workspace: Path, amount_cents: int) -> None:
 def initialize_dbt_init_git_repo(*, workspace: Path, production_ref: str) -> None:
     """Create a production ref and feature branch for generated reuse config E2Es."""
 
-    _run_git(args=("init",), cwd=workspace)
+    _run_git(args=("init", "--initial-branch=main"), cwd=workspace)
     _run_git(args=("config", "user.email", "sqlbuild@example.invalid"), cwd=workspace)
     _run_git(args=("config", "user.name", "SQLBuild Test"), cwd=workspace)
     _run_git(args=("add", "."), cwd=workspace)
     _run_git(args=("commit", "-m", "prod baseline"), cwd=workspace)
-    _run_git(args=("branch", production_ref), cwd=workspace)
+    if production_ref != "main":
+        _run_git(args=("branch", production_ref), cwd=workspace)
     _run_git(args=("checkout", "-b", "feature"), cwd=workspace)
 
 

{sqlbuild-0.37.5 → sqlbuild-0.37.6}/tests/e2e/src/sqlbuild/cli/commands/main/dbt/test_init.py

@@ -8,6 +8,7 @@ import pytest
 from tests.e2e.src.sqlbuild.cli.commands.main.dbt._test_types import (
     DbtAutoInitE2ETestCase,
     DbtCliFlagAmbiguityE2ETestCase,
+    DbtInitDetectedReuseRefE2ETestCase,
     DbtInitDuckDbE2ETestCase,
     DbtInitGeneratedReuseE2ETestCase,
     DbtInitInteractiveE2ETestCase,
@@ -272,8 +273,8 @@ def test_given_tty_when_running_dbt_init_then_prompts_and_renders_color(
         DbtInitInvalidReuseRefE2ETestCase(
             description="interactive typed invalid reuse ref skips reuse with a warning",
             expected_stdout_fragments=(
-                "dbt reuse_from skipped",
-                "does not exist in this repository",
+                "dbt reuse-from-production is enabled but git ref",
+                "was not found",
                 "Plan ready",
             ),
         )
@@ -642,26 +643,24 @@ def test_given_generated_dbt_init_config_without_prod_table_when_building_then_r
 @pytest.mark.parametrize(
     "test_case",
     [
-        DbtInitInvalidReuseRefE2ETestCase(
-            description="auto-init invalid default reuse ref skips reuse with a warning",
-            expected_stdout_fragments=(
-                "dbt reuse_from skipped",
-                "does not exist in this repository",
-                "Plan ready",
-            ),
+        DbtInitDetectedReuseRefE2ETestCase(
+            description="auto-init detects the existing default branch for reuse config",
+            production_ref="prod",
+            expected_config_git_ref='git_ref = "main"',
+            unexpected_stdout_fragments=("was not found",),
         )
     ],
-    ids=["auto-init invalid default reuse ref skips reuse with a warning"],
+    ids=["auto-init detects the existing default branch for reuse config"],
 )
-def test_given_auto_init_default_ref_is_missing_when_planning_then_skips_reuse_with_warning(
+def test_given_auto_init_when_planning_then_detects_existing_default_branch(
     tmp_path: Path,
-    test_case: DbtInitInvalidReuseRefE2ETestCase,
+    test_case: DbtInitDetectedReuseRefE2ETestCase,
 ) -> None:
     skip_unless_dbt_is_runnable()
     workspace: Path = prepare_dbt_init_duckdb_workspace(
-        tmp_path=tmp_path, workspace_name="invalid_reuse_ref_workspace"
+        tmp_path=tmp_path, workspace_name="detected_reuse_ref_workspace"
     )
-    initialize_dbt_init_git_repo(workspace=workspace, production_ref="prod")
+    initialize_dbt_init_git_repo(workspace=workspace, production_ref=test_case.production_ref)
 
     result: subprocess.CompletedProcess[str] = run_sqb(
         command=("dbt", "plan", "--profiles-dir", "../profiles", "--select", "dbt_orders"),
@@ -669,6 +668,10 @@ def test_given_auto_init_default_ref_is_missing_when_planning_then_skips_reuse_w
     )
 
     assert result.returncode == 0, result.stdout + result.stderr
-    expected_fragment: str
-    for expected_fragment in test_case.expected_stdout_fragments:
-        assert expected_fragment in result.stdout
+    generated_toml: str = (workspace / "sqlbuild_project" / "sqlbuild_project.toml").read_text(
+        encoding="utf-8"
+    )
+    assert test_case.expected_config_git_ref in generated_toml
+    unexpected_fragment: str
+    for unexpected_fragment in test_case.unexpected_stdout_fragments:
+        assert unexpected_fragment not in result.stdout

{sqlbuild-0.37.5 → sqlbuild-0.37.6}/tests/e2e/src/sqlbuild/cli/commands/main/dbt/test_reuse_skip.py

@@ -24,8 +24,8 @@ pytestmark: pytest.MarkDecorator = pytest.mark.dbt
             description="reuse_from in a non-git project skips reuse with a warning and builds",
             expected_returncode=0,
             expected_stdout_fragments=(
-                "dbt reuse_from skipped",
-                "requires the SQLBuild project to be in a git repository",
+                "dbt reuse-from-production is enabled but inactive",
+                "not in a git repository",
                 "Plan ready",
             ),
             expected_stderr_fragments=(),
@@ -58,8 +58,8 @@ def test_given_reuse_from_in_non_git_project_when_building_then_skips_with_warni
             description="reuse_from git_ref equal to current branch skips with a warning",
             expected_returncode=0,
             expected_stdout_fragments=(
-                "dbt reuse_from skipped",
-                "must not be the current branch",
+                "dbt reuse-from-production is enabled but inactive",
+                "the configured production ref",
                 "Plan ready",
             ),
             expected_stderr_fragments=(),

{sqlbuild-0.37.5 → sqlbuild-0.37.6}/tests/e2e/src/sqlbuild/cli/commands/main/dbt/test_seed_change.py

@@ -459,7 +459,7 @@ def test_given_out_of_selection_seed_change_when_running_then_warns(
             description="reuse skipped in a non-git project still cascades a changed seed",
             select=("+fct_customer_revenue",),
             expected_stdout_fragments=(
-                "dbt reuse_from skipped",
+                "dbt reuse-from-production is enabled but inactive",
                 "Upstream changed",
                 "fct_customer_revenue",
             ),

sqlbuild-0.37.6/tests/integration/src/sqlbuild/cli/commands/main/helpers/dbt_init/_test_types.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass, field
+
+
+@dataclass(frozen=True)
+class DefaultBranchDetectionTestCase:
+    description: str
+    init_branch: str | None
+    extra_branches: tuple[str, ...] = field(default_factory=tuple)
+    set_remote_head_to: str | None = None
+    is_git_repo: bool = True
+    expected_ref: str = "main"

sqlbuild-0.37.6/tests/integration/src/sqlbuild/cli/commands/main/helpers/dbt_init/helpers.py

@@ -0,0 +1,44 @@
+import subprocess
+from pathlib import Path
+
+from tests.integration.src.sqlbuild.cli.commands.main.helpers.dbt_init._test_types import (
+    DefaultBranchDetectionTestCase,
+)
+
+
+def build_git_repo_for_case(*, root: Path, test_case: DefaultBranchDetectionTestCase) -> Path:
+    """Create a git repo on disk matching the test case branch topology."""
+
+    if not test_case.is_git_repo:
+        return root
+
+    _git(root, "init", f"--initial-branch={test_case.init_branch or 'main'}")
+    _git(root, "config", "user.email", "test@example.com")
+    _git(root, "config", "user.name", "Test User")
+    (root / "file.txt").write_text("seed\n", encoding="utf-8")
+    _git(root, "add", "file.txt")
+    _git(root, "commit", "-m", "initial")
+
+    branch: str
+    for branch in test_case.extra_branches:
+        _git(root, "branch", branch)
+
+    if test_case.set_remote_head_to is not None:
+        _git(root, "remote", "add", "origin", str(root))
+        _git(
+            root,
+            "symbolic-ref",
+            "refs/remotes/origin/HEAD",
+            f"refs/remotes/origin/{test_case.set_remote_head_to}",
+        )
+
+    return root
+
+
+def _git(root: Path, *args: str) -> None:
+    subprocess.run(
+        ("git", "-C", str(root), *args),
+        capture_output=True,
+        check=True,
+        text=True,
+    )

sqlbuild-0.37.6/tests/integration/src/sqlbuild/cli/commands/main/helpers/dbt_init/test_branch_detection.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from sqlbuild.cli.commands.main.helpers.dbt_init.branch_detection import (
+    detect_default_production_git_ref,
+)
+from tests.integration.src.sqlbuild.cli.commands.main.helpers.dbt_init._test_types import (
+    DefaultBranchDetectionTestCase,
+)
+from tests.integration.src.sqlbuild.cli.commands.main.helpers.dbt_init.helpers import (
+    build_git_repo_for_case,
+)
+
+TEST_CASES = [
+    DefaultBranchDetectionTestCase(
+        description="non-git directory falls back to main",
+        init_branch=None,
+        is_git_repo=False,
+        expected_ref="main",
+    ),
+    DefaultBranchDetectionTestCase(
+        description="master-only repo detects master",
+        init_branch="master",
+        expected_ref="master",
+    ),
+    DefaultBranchDetectionTestCase(
+        description="main-only repo detects main",
+        init_branch="main",
+        expected_ref="main",
+    ),
+    DefaultBranchDetectionTestCase(
+        description="remote HEAD takes precedence over local common branches",
+        init_branch="feature",
+        extra_branches=("master",),
+        set_remote_head_to="feature",
+        expected_ref="feature",
+    ),
+    DefaultBranchDetectionTestCase(
+        description="non-standard current branch with no common branch falls back to current",
+        init_branch="trunk",
+        expected_ref="trunk",
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    TEST_CASES,
+    ids=[case.description for case in TEST_CASES],
+)
+def test_given_git_repo_topology_when_detecting_default_ref_then_returns_expected_ref(
+    test_case: DefaultBranchDetectionTestCase,
+    tmp_path: Path,
+) -> None:
+    repo_dir: Path = build_git_repo_for_case(root=tmp_path, test_case=test_case)
+
+    detected: str = detect_default_production_git_ref(git_probe_dir=repo_dir)
+
+    assert detected == test_case.expected_ref

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

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