bmsdna-devtools 0.2.0__tar.gz → 0.2.2__tar.gz

{bmsdna_devtools-0.2.0 → bmsdna_devtools-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bmsdna-devtools
-Version: 0.2.0
+Version: 0.2.2
 Summary: Shared Azure DevOps / GitHub / git / Azure Monitor developer tooling for BMS projects
 Requires-Python: >=3.11
 Requires-Dist: requests>=2.32.0
@@ -77,6 +77,12 @@ title/body from commit info so it never blocks on an interactive prompt).
 Extra arguments pass through either way, e.g.
 `bdt pr create --target main -- --title "..."`.
 
+If `--target` has a build policy configured (an Azure DevOps Build policy,
+or a GitHub branch protection rule requiring status checks), a successful
+create prints a reminder to run `bdt pr status` afterward to check whether
+the CI build passes. This is a best-effort check — failures reading policy
+config (auth, permissions) fail open and simply skip the reminder.
+
 ## `bdt worktree`
 
 ```bash
@@ -134,10 +140,25 @@ Downloads the App Service log archive for a webapp/slot via
 common error/warning marker (`ERROR`, `CRITICAL`, `WARNING`, tracebacks,
 `4xx`/`5xx`, `FAILED`, `FATAL`) to `<out>/<slot>_errors.log`. Simpler and
 often preferable to the KQL commands above when you just want "what broke
-recently" rather than a queryable trace stream — no defaults are baked in
-here either.
+recently" rather than a queryable trace stream.
+
+The webapp/resource-group/slot come from a named environment configured in
+the calling repo's `pyproject.toml`. `slot` is optional — omit it for an
+app's default/production slot (no `--slot` is passed to `az`); set it for a
+named deployment slot:
+
+```toml
+[tool.bdt.envs.prod]
+webapp = "my-webapp"
+resource_group = "my-rg"
+
+[tool.bdt.envs.test]
+webapp = "my-webapp"
+resource_group = "my-rg"
+slot = "test"
+```
 
 ```bash
-bdt logs fetch --webapp my-webapp --resource-group my-rg --slot production
-bdt logs fetch --webapp my-webapp --resource-group my-rg --slot production --out logs/ --keep-archive
+bdt logs fetch --env prod
+bdt logs fetch --env prod --out logs/ --keep-archive
 ```

{bmsdna_devtools-0.2.0 → bmsdna_devtools-0.2.2}/README.md

@@ -67,6 +67,12 @@ title/body from commit info so it never blocks on an interactive prompt).
 Extra arguments pass through either way, e.g.
 `bdt pr create --target main -- --title "..."`.
 
+If `--target` has a build policy configured (an Azure DevOps Build policy,
+or a GitHub branch protection rule requiring status checks), a successful
+create prints a reminder to run `bdt pr status` afterward to check whether
+the CI build passes. This is a best-effort check — failures reading policy
+config (auth, permissions) fail open and simply skip the reminder.
+
 ## `bdt worktree`
 
 ```bash
@@ -124,10 +130,25 @@ Downloads the App Service log archive for a webapp/slot via
 common error/warning marker (`ERROR`, `CRITICAL`, `WARNING`, tracebacks,
 `4xx`/`5xx`, `FAILED`, `FATAL`) to `<out>/<slot>_errors.log`. Simpler and
 often preferable to the KQL commands above when you just want "what broke
-recently" rather than a queryable trace stream — no defaults are baked in
-here either.
+recently" rather than a queryable trace stream.
+
+The webapp/resource-group/slot come from a named environment configured in
+the calling repo's `pyproject.toml`. `slot` is optional — omit it for an
+app's default/production slot (no `--slot` is passed to `az`); set it for a
+named deployment slot:
+
+```toml
+[tool.bdt.envs.prod]
+webapp = "my-webapp"
+resource_group = "my-rg"
+
+[tool.bdt.envs.test]
+webapp = "my-webapp"
+resource_group = "my-rg"
+slot = "test"
+```
 
 ```bash
-bdt logs fetch --webapp my-webapp --resource-group my-rg --slot production
-bdt logs fetch --webapp my-webapp --resource-group my-rg --slot production --out logs/ --keep-archive
+bdt logs fetch --env prod
+bdt logs fetch --env prod --out logs/ --keep-archive
 ```

{bmsdna_devtools-0.2.0 → bmsdna_devtools-0.2.2}/bmsdna/devtools/app_service_logs.py

@@ -28,13 +28,13 @@ def run_az(args: list[str]) -> str:
     return proc.stdout
 
 
-def download_logs(webapp: str, resource_group: str, slot: str, archive: pathlib.Path) -> None:
-    print(f"Downloading logs for {webapp}/{slot}...", flush=True)
+def download_logs(webapp: str, resource_group: str, slot: str | None, archive: pathlib.Path) -> None:
+    print(f"Downloading logs for {webapp}/{slot or '(production)'}...", flush=True)
     run_az([
         "webapp", "log", "download",
         "--name", webapp,
         "--resource-group", resource_group,
-        "--slot", slot,
+        *(["--slot", slot] if slot else []),
         "--log-file", str(archive),
     ])
 
@@ -58,13 +58,14 @@ def extract_errors(archive: pathlib.Path, error_file: pathlib.Path) -> int:
 def fetch(
     webapp: str,
     resource_group: str,
-    slot: str,
+    slot: str | None,
     out_dir: pathlib.Path,
     keep_archive: bool = False,
 ) -> pathlib.Path:
     out_dir.mkdir(parents=True, exist_ok=True)
-    archive = out_dir / f"{slot}_logs.zip"
-    error_file = out_dir / f"{slot}_errors.log"
+    label = slot or "production"
+    archive = out_dir / f"{label}_logs.zip"
+    error_file = out_dir / f"{label}_errors.log"
 
     download_logs(webapp, resource_group, slot, archive)
     count = extract_errors(archive, error_file)

{bmsdna_devtools-0.2.0 → bmsdna_devtools-0.2.2}/bmsdna/devtools/cli.py

@@ -38,17 +38,25 @@ def pr_create(
     """Create a PR from the current branch into --target (Azure DevOps or GitHub, auto-detected)."""
     remote = current_remote()
     if isinstance(remote, GitHubRemote):
-        raise typer.Exit(gh_pr.create(require_gh(), target, args or []))
-
-    az = require_az()
-    cmd = [
-        az, "repos", "pr", "create",
-        "--target-branch", target,
-        "--source-branch", current_branch(),
-        "--auto-complete", "false",
-        *(args or []),
-    ]
-    raise typer.Exit(subprocess.run(cmd).returncode)
+        gh = require_gh()
+        returncode = gh_pr.create(gh, target, args or [])
+        build_policy = gh_pr.has_build_policy(gh, target)
+    else:
+        az = require_az()
+        cmd = [
+            az, "repos", "pr", "create",
+            "--target-branch", target,
+            "--source-branch", current_branch(),
+            "--auto-complete", "false",
+            *(args or []),
+        ]
+        returncode = subprocess.run(cmd).returncode
+        build_policy = pr_build.has_build_policy(remote, target)
+
+    if returncode == 0 and build_policy:
+        print("\nRun `bdt pr status` to check whether the CI build passes.")
+
+    raise typer.Exit(returncode)
 
 
 @pr_app.command("status")
@@ -131,7 +139,7 @@ def logs_fetch(
 ) -> None:
     """Download an App Service log archive and extract error/warning lines."""
     cfg = env_config.resolve_env(env)
-    app_service_logs.fetch(cfg["webapp"], cfg["resource_group"], cfg["slot"], out, keep_archive=keep_archive)
+    app_service_logs.fetch(cfg["webapp"], cfg["resource_group"], cfg.get("slot"), out, keep_archive=keep_archive)
 
 
 if __name__ == "__main__":

{bmsdna_devtools-0.2.0 → bmsdna_devtools-0.2.2}/bmsdna/devtools/commit.py

@@ -30,6 +30,26 @@ def _in_sandbox() -> bool:
     return os.getenv(IS_SANDBOX_ENV_VAR, "0").lower() in ("1", "true", "yes")
 
 
+def _staged_deletion(path: str, cwd: str | None = None) -> bool:
+    """True if `path` is already staged as a deletion (e.g. via `git rm`) in
+    the repo at `cwd`. This is a deliberate-intent signal, not just "HEAD used
+    to have this path" — a file that vanished because a write failed or raced
+    would be missing from disk but NOT staged as a deletion, so it still
+    fails the check below instead of silently being committed as removed."""
+    r = _run(["git", "diff", "--cached", "--name-only", "--diff-filter=D", "--", path], cwd=cwd)
+    return r.returncode == 0 and path in r.stdout.splitlines()
+
+
+def _present_or_staged_deletion(path: str, subrepos: list[str]) -> bool:
+    if os.path.exists(path):
+        return True
+    for subrepo in subrepos:
+        prefix = subrepo + "/"
+        if path.startswith(prefix):
+            return _staged_deletion(path[len(prefix):], cwd=subrepo)
+    return _staged_deletion(path)
+
+
 @dataclass
 class CommitResult:
     success: bool
@@ -64,17 +84,29 @@ def _git_commit(message: str, cwd: str | None = None, no_verify: bool = False) -
     return _run(cmd, cwd=cwd)
 
 
+def _add(files: list[str], cwd: str | None) -> None:
+    """`git add`, excluding paths already fully removed (disk + index) by a
+    prior `git rm` -- those have nothing left to add, and `git add` fails its
+    ENTIRE invocation (staging nothing, for any path in the same call) if even
+    one pathspec doesn't match anything. Passing only what's actually present
+    on disk avoids silently dropping the other files' staged content."""
+    root = cwd or "."
+    addable = [f for f in files if os.path.exists(os.path.join(root, f))]
+    if addable:
+        _run(["git", "add", *addable], cwd=cwd)
+
+
 def _commit_with_retry(
     message: str, files: list[str], cwd: str | None, no_verify: bool
 ) -> tuple[bool, subprocess.CompletedProcess | None]:
     """Commit, retrying once (re-`git add`) if a pre-commit hook reformatted files."""
-    _run(["git", "add", *files], cwd=cwd)
+    _add(files, cwd)
     r = _git_commit(message, cwd=cwd, no_verify=no_verify)
     if r.returncode == 0:
         return True, None
     if "nothing to commit" in r.stdout + r.stderr:
         return False, None
-    _run(["git", "add", *files], cwd=cwd)
+    _add(files, cwd)
     r2 = _git_commit(message, cwd=cwd, no_verify=no_verify)
     if r2.returncode == 0:
         return True, None
@@ -108,8 +140,8 @@ def commit_and_push(
         print(f"  {'✓' if ok else '✗'} {label}", file=sys.stdout if ok else sys.stderr)
         return ok
 
-    missing = [f for f in files if not os.path.exists(f)]
-    if not check(not missing, "files exist"):
+    missing = [f for f in files if not _present_or_staged_deletion(f, subrepos)]
+    if not check(not missing, "files exist (or are a staged deletion)"):
         return CommitResult(
             False, False, False, message, files,
             error=f"File not found: {missing[0]} — did you typo the path? Run `git status` to see changed files",
@@ -177,7 +209,7 @@ def commit_and_push(
     pr = _run(["git", "push"])
     if pr.returncode != 0:
         return CommitResult(
-            True, committed, False, message, files,
+            False, committed, False, message, files,
             commit_sha=_sha(),
             error=(pr.stdout + pr.stderr).strip(),
             hint="Push rejected. Run `git pull --rebase`, resolve conflicts, then retry.",

{bmsdna_devtools-0.2.0 → bmsdna_devtools-0.2.2}/bmsdna/devtools/env_config.py

@@ -11,13 +11,19 @@ import sys
 import tomllib
 from pathlib import Path
 
-REQUIRED_KEYS = ("webapp", "resource_group", "slot")
+REQUIRED_KEYS = ("webapp", "resource_group")
 
 CONFIG_EXAMPLE = """\
 [tool.bdt.envs.prod]
 webapp = "my-app"
 resource_group = "my-app-rg"
-slot = "production"
+# slot is optional — omit it for an app's default/production slot,
+# set it for a named deployment slot (e.g. "test", "stage").
+
+[tool.bdt.envs.test]
+webapp = "my-app"
+resource_group = "my-app-rg"
+slot = "test"
 """
 
 

{bmsdna_devtools-0.2.0 → bmsdna_devtools-0.2.2}/bmsdna/devtools/gh_pr.py

@@ -138,3 +138,31 @@ def create(gh: str, target: str, extra_args: list[str]) -> int:
     """
     cmd = [gh, "pr", "create", "--base", target, "--fill", *extra_args]
     return subprocess.run(cmd).returncode
+
+
+def protection_requires_status_checks(protection: dict) -> bool:
+    """True if a branch's `.../protection` response requires status checks to pass."""
+    return bool(protection.get("required_status_checks"))
+
+
+def has_build_policy(gh: str, branch: str) -> bool:
+    """Best-effort check for whether `branch` has branch protection requiring status checks.
+
+    Only used to decide whether to print a `bdt pr status` reminder after
+    `pr create` — `{owner}`/`{repo}` are resolved by `gh` from the current
+    repo, and any failure (no permission to read protection settings, branch
+    not protected at all, etc.) fails open (returns False) rather than
+    blocking PR creation.
+    """
+    r = subprocess.run(
+        [gh, "api", f"repos/{{owner}}/{{repo}}/branches/{branch}/protection"],
+        capture_output=True,
+        encoding="utf-8",
+    )
+    if r.returncode != 0:
+        return False
+    try:
+        data = json.loads(r.stdout)
+    except json.JSONDecodeError:
+        return False
+    return protection_requires_status_checks(data)

{bmsdna_devtools-0.2.0 → bmsdna_devtools-0.2.2}/bmsdna/devtools/pr_build.py

@@ -28,6 +28,60 @@ def _base_url(remote: AdoRemote) -> str:
     return f"https://dev.azure.com/{remote.org}/{quote(remote.project, safe='')}"
 
 
+# PolicyType.id for the built-in "Build" policy (branch policy requiring a
+# build to pass) — same GUID across every ADO organization.
+BUILD_POLICY_TYPE_ID = "0609b952-1397-4640-95ec-e00a01b2c241"
+
+
+def _scope_matches(scope: dict, repo_id: str, target_ref: str, default_branch: str | None) -> bool:
+    if scope.get("repositoryId") not in (None, repo_id):
+        return False
+    if scope.get("matchKind") == "DefaultBranch":
+        return default_branch == target_ref
+    return scope.get("refName") in (None, target_ref)
+
+
+def policy_configs_include_branch(configs: list, repo_id: str, branch: str, default_branch: str | None) -> bool:
+    """True if any enabled, non-deleted Build-type policy configuration's scope covers `branch`."""
+    target_ref = f"refs/heads/{branch}"
+    for config in configs:
+        if not config.get("isEnabled") or config.get("isDeleted"):
+            continue
+        if config.get("type", {}).get("id") != BUILD_POLICY_TYPE_ID:
+            continue
+        scopes = config.get("settings", {}).get("scope", [])
+        if any(_scope_matches(scope, repo_id, target_ref, default_branch) for scope in scopes):
+            return True
+    return False
+
+
+def has_build_policy(remote: AdoRemote, branch: str, pat: str | None = None) -> bool:
+    """Best-effort check for whether `branch` has an enabled Build policy configured.
+
+    Only used to decide whether to print a `bdt pr status` reminder after
+    `pr create` — failures here (auth, permissions, network) fail open
+    (return False) rather than blocking PR creation.
+    """
+    try:
+        session = requests.Session()
+        session.headers.update(auth_header(pat))
+
+        r = session.get(
+            f"{_base_url(remote)}/_apis/git/repositories/{quote(remote.repo, safe='')}",
+            params={"api-version": "7.1"},
+        )
+        r.raise_for_status()
+        repo = r.json()
+
+        r = session.get(f"{_base_url(remote)}/_apis/policy/configurations", params={"api-version": "7.1"})
+        r.raise_for_status()
+        configs = r.json().get("value", [])
+    except (requests.RequestException, SystemExit):
+        return False
+
+    return policy_configs_include_branch(configs, repo.get("id"), branch, repo.get("defaultBranch"))
+
+
 def merge_conflict_message(pr: dict) -> str | None:
     """None if the PR's mergeStatus is fine; else a human-readable description of the problem."""
     merge_status = pr.get("mergeStatus")

{bmsdna_devtools-0.2.0 → bmsdna_devtools-0.2.2}/pyproject.toml

@@ -10,7 +10,7 @@ packages = ["bmsdna"]
 
 [project]
 name = "bmsdna-devtools"
-version = "0.2.0"
+version = "0.2.2"
 description = "Shared Azure DevOps / GitHub / git / Azure Monitor developer tooling for BMS projects"
 readme = "README.md"
 requires-python = ">=3.11"

{bmsdna_devtools-0.2.0 → bmsdna_devtools-0.2.2}/skills/bmsdna-devtools/SKILL.md

@@ -66,6 +66,9 @@ info, so it never blocks waiting on an interactive prompt). Extra args pass
 straight through either way, e.g.
 `bdt pr create --target main -- --title "..." --description "..."`.
 
+After creating a PR, use `bdt pr status` (see above) to check whether the
+CI build passes.
+
 ## Creating a worktree
 
 ```bash

bmsdna_devtools-0.2.2/tests/test_app_service_logs.py

@@ -0,0 +1,39 @@
+import zipfile
+
+from bmsdna.devtools import app_service_logs
+
+
+def test_download_logs_omits_slot_flag_when_none(monkeypatch, tmp_path):
+    captured = {}
+
+    def fake_run_az(args):
+        captured["args"] = args
+        return ""
+
+    monkeypatch.setattr(app_service_logs, "run_az", fake_run_az)
+    app_service_logs.download_logs("my-app", "my-rg", None, tmp_path / "archive.zip")
+    assert "--slot" not in captured["args"]
+
+
+def test_download_logs_includes_slot_flag_when_given(monkeypatch, tmp_path):
+    captured = {}
+
+    def fake_run_az(args):
+        captured["args"] = args
+        return ""
+
+    monkeypatch.setattr(app_service_logs, "run_az", fake_run_az)
+    app_service_logs.download_logs("my-app", "my-rg", "test", tmp_path / "archive.zip")
+    assert "--slot" in captured["args"]
+    assert captured["args"][captured["args"].index("--slot") + 1] == "test"
+
+
+def test_fetch_uses_production_label_when_slot_is_none(monkeypatch, tmp_path):
+    def fake_download(webapp, resource_group, slot, archive):
+        with zipfile.ZipFile(archive, "w"):
+            pass
+
+    monkeypatch.setattr(app_service_logs, "download_logs", fake_download)
+    error_file = app_service_logs.fetch("my-app", "my-rg", None, tmp_path, keep_archive=True)
+    assert error_file == tmp_path / "production_errors.log"
+    assert (tmp_path / "production_logs.zip").exists()

bmsdna_devtools-0.2.2/tests/test_commit.py

@@ -0,0 +1,124 @@
+import subprocess
+
+from bmsdna.devtools.commit import commit_and_push
+
+
+def init_repo(path):
+    subprocess.run(["git", "init", "-q", "-b", "feature"], cwd=path, check=True)
+    subprocess.run(["git", "config", "user.email", "test@example.com"], cwd=path, check=True)
+    subprocess.run(["git", "config", "user.name", "Test"], cwd=path, check=True)
+
+
+def test_commit_and_push_fails_when_push_has_no_remote(tmp_path, monkeypatch):
+    init_repo(tmp_path)
+    (tmp_path / "a.txt").write_text("hello")
+    monkeypatch.chdir(tmp_path)
+
+    result = commit_and_push(
+        "feat(x): add a.txt",
+        ["a.txt"],
+        require_message_quality=False,
+        require_feature_branch=False,
+    )
+
+    assert result.committed is True
+    assert result.pushed is False
+    assert result.success is False
+    assert result.error
+
+
+def test_commit_and_push_allows_staged_deletion(tmp_path, monkeypatch):
+    init_repo(tmp_path)
+    (tmp_path / "a.txt").write_text("hello")
+    monkeypatch.chdir(tmp_path)
+    subprocess.run(["git", "add", "a.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-q", "-m", "init"], cwd=tmp_path, check=True)
+
+    subprocess.run(["git", "rm", "-q", "a.txt"], cwd=tmp_path, check=True)
+
+    result = commit_and_push(
+        "feat(x): remove a.txt",
+        ["a.txt"],
+        require_message_quality=False,
+        require_feature_branch=False,
+    )
+
+    assert result.committed is True
+    assert result.error != "File not found: a.txt — did you typo the path? Run `git status` to see changed files"
+
+
+def test_commit_and_push_rejects_unstaged_missing_file(tmp_path, monkeypatch):
+    """A file that vanished from disk without git being told (e.g. a failed
+    write) must still be rejected -- only an already-*staged* deletion (via
+    `git rm`) is treated as an intentional removal."""
+    init_repo(tmp_path)
+    (tmp_path / "a.txt").write_text("hello")
+    monkeypatch.chdir(tmp_path)
+    subprocess.run(["git", "add", "a.txt"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-q", "-m", "init"], cwd=tmp_path, check=True)
+
+    (tmp_path / "a.txt").unlink()
+
+    result = commit_and_push(
+        "feat(x): update a.txt",
+        ["a.txt"],
+        require_message_quality=False,
+        require_feature_branch=False,
+    )
+
+    assert result.committed is False
+    assert result.error == "File not found: a.txt — did you typo the path? Run `git status` to see changed files"
+
+
+def test_commit_and_push_stages_modified_file_alongside_staged_deletion(tmp_path, monkeypatch):
+    """Regression test: `git add <modified-file> <already-git-rm'd-file>` fails
+    its ENTIRE invocation (git errors "pathspec did not match any files" for
+    the already-removed path, staging nothing at all in that call) -- which
+    previously silently dropped the modified file's new content from the
+    commit, since _commit_with_retry didn't check git add's exit code."""
+    init_repo(tmp_path)
+    (tmp_path / "a.md").write_text("old")
+    (tmp_path / "gone.py").write_text("old")
+    subprocess.run(["git", "add", "a.md", "gone.py"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "commit", "-q", "-m", "init"], cwd=tmp_path, check=True)
+    monkeypatch.chdir(tmp_path)
+
+    subprocess.run(["git", "rm", "-q", "gone.py"], cwd=tmp_path, check=True)
+    (tmp_path / "a.md").write_text("new content")
+
+    result = commit_and_push(
+        "feat(x): update a.md and remove gone.py",
+        ["a.md", "gone.py"],
+        require_message_quality=False,
+        require_feature_branch=False,
+    )
+
+    assert result.committed is True
+    committed_content = subprocess.run(
+        ["git", "show", "HEAD:a.md"], cwd=tmp_path, capture_output=True, text=True, check=True
+    ).stdout
+    assert committed_content == "new content"
+
+
+def test_commit_and_push_allows_staged_deletion_in_subrepo(tmp_path, monkeypatch):
+    subrepo = tmp_path / "database"
+    subrepo.mkdir()
+    init_repo(subrepo)
+    (subrepo / "schema.sql").write_text("create table t();")
+    subprocess.run(["git", "add", "schema.sql"], cwd=subrepo, check=True)
+    subprocess.run(["git", "commit", "-q", "-m", "init"], cwd=subrepo, check=True)
+
+    init_repo(tmp_path)
+    monkeypatch.chdir(tmp_path)
+    subprocess.run(["git", "commit", "-q", "-m", "init", "--allow-empty"], cwd=tmp_path, check=True)
+    subprocess.run(["git", "rm", "-q", "schema.sql"], cwd=subrepo, check=True)
+
+    result = commit_and_push(
+        "feat(x): remove schema.sql",
+        ["database/schema.sql"],
+        require_message_quality=False,
+        require_feature_branch=False,
+        subrepos=["database"],
+    )
+
+    assert result.error != "File not found: database/schema.sql — did you typo the path? Run `git status` to see changed files"

{bmsdna_devtools-0.2.0 → bmsdna_devtools-0.2.2}/tests/test_env_config.py

@@ -93,3 +93,15 @@ slot = "production"
         "resource_group": "my-app-rg",
         "slot": "production",
     }
+
+
+def test_resolve_env_allows_missing_slot(tmp_path):
+    write_pyproject(
+        tmp_path,
+        """
+[tool.bdt.envs.prod]
+webapp = "my-app"
+resource_group = "my-app-rg"
+""",
+    )
+    assert resolve_env("prod", tmp_path) == {"webapp": "my-app", "resource_group": "my-app-rg"}

{bmsdna_devtools-0.2.0 → bmsdna_devtools-0.2.2}/tests/test_gh_pr.py

@@ -1,6 +1,6 @@
 import pytest
 
-from bmsdna.devtools.gh_pr import check_bucket, check_label, merge_conflict_message
+from bmsdna.devtools.gh_pr import check_bucket, check_label, merge_conflict_message, protection_requires_status_checks
 
 # Real statusCheckRollup entries captured from `gh pr view 13902 -R cli/cli --json statusCheckRollup`.
 COMPLETED_SUCCESS_CHECK_RUN = {
@@ -60,3 +60,13 @@ def test_merge_conflict_message_conflicting() -> None:
     assert msg is not None
     assert "PR #42" in msg
     assert "main" in msg
+
+
+def test_protection_requires_status_checks_true_when_configured() -> None:
+    protection = {"required_status_checks": {"strict": True, "contexts": ["build"]}}
+    assert protection_requires_status_checks(protection) is True
+
+
+@pytest.mark.parametrize("protection", [{}, {"required_status_checks": None}])
+def test_protection_requires_status_checks_false_when_absent(protection: dict) -> None:
+    assert protection_requires_status_checks(protection) is False

bmsdna_devtools-0.2.2/tests/test_pr_build.py

@@ -0,0 +1,97 @@
+import pytest
+
+from bmsdna.devtools.pr_build import merge_conflict_message, policy_configs_include_branch
+
+REPO_ID = "0cd3a822-389e-416e-a4fa-b73f988c2930"
+
+# Shape captured from a real `.../_apis/policy/configurations` response.
+BUILD_POLICY_ON_MAIN = {
+    "isEnabled": True,
+    "isDeleted": False,
+    "type": {"id": "0609b952-1397-4640-95ec-e00a01b2c241", "displayName": "Build"},
+    "settings": {
+        "scope": [{"refName": "refs/heads/main", "matchKind": "Exact", "repositoryId": REPO_ID}],
+    },
+}
+REVIEWER_POLICY_ON_EMERGENCY_RELEASE = {
+    "isEnabled": True,
+    "isDeleted": False,
+    "type": {"id": "fd2167ab-b0be-447a-8ec8-39368250530e", "displayName": "Minimum number of reviewers"},
+    "settings": {
+        "scope": [{"refName": "refs/heads/emergency-release", "matchKind": "Exact", "repositoryId": REPO_ID}],
+    },
+}
+
+
+@pytest.mark.parametrize("merge_status", ["notSet", "queued", "succeeded"])
+def test_merge_conflict_message_none_when_mergeable(merge_status: str) -> None:
+    assert merge_conflict_message({"pullRequestId": 1, "title": "x", "mergeStatus": merge_status}) is None
+
+
+def test_merge_conflict_message_missing_field_is_fine() -> None:
+    assert merge_conflict_message({"pullRequestId": 1, "title": "x"}) is None
+
+
+def test_merge_conflict_message_conflicts() -> None:
+    pr = {"pullRequestId": 42, "title": "feat: widgets", "mergeStatus": "conflicts"}
+    msg = merge_conflict_message(pr)
+    assert msg is not None
+    assert "PR #42" in msg
+    assert "conflicts" in msg
+
+
+def test_merge_conflict_message_uses_failure_message_when_present() -> None:
+    pr = {
+        "pullRequestId": 7,
+        "title": "fix: x",
+        "mergeStatus": "failure",
+        "mergeFailureMessage": "object too large to merge",
+    }
+    msg = merge_conflict_message(pr)
+    assert msg is not None
+    assert "object too large to merge" in msg
+
+
+@pytest.mark.parametrize("merge_status", ["conflicts", "failure", "rejectedByPolicy"])
+def test_merge_conflict_message_covers_all_bad_statuses(merge_status: str) -> None:
+    pr = {"pullRequestId": 1, "title": "x", "mergeStatus": merge_status}
+    assert merge_conflict_message(pr) is not None
+
+
+def test_policy_configs_include_branch_matches_build_policy_on_scoped_branch() -> None:
+    configs = [BUILD_POLICY_ON_MAIN, REVIEWER_POLICY_ON_EMERGENCY_RELEASE]
+    assert policy_configs_include_branch(configs, REPO_ID, "main", "refs/heads/main") is True
+
+
+def test_policy_configs_include_branch_false_for_unscoped_branch() -> None:
+    configs = [BUILD_POLICY_ON_MAIN, REVIEWER_POLICY_ON_EMERGENCY_RELEASE]
+    assert policy_configs_include_branch(configs, REPO_ID, "test", "refs/heads/main") is False
+
+
+def test_policy_configs_include_branch_ignores_non_build_policy_types() -> None:
+    assert policy_configs_include_branch([REVIEWER_POLICY_ON_EMERGENCY_RELEASE], REPO_ID, "emergency-release", "refs/heads/main") is False
+
+
+def test_policy_configs_include_branch_ignores_disabled_policy() -> None:
+    disabled = {**BUILD_POLICY_ON_MAIN, "isEnabled": False}
+    assert policy_configs_include_branch([disabled], REPO_ID, "main", "refs/heads/main") is False
+
+
+def test_policy_configs_include_branch_ignores_deleted_policy() -> None:
+    deleted = {**BUILD_POLICY_ON_MAIN, "isDeleted": True}
+    assert policy_configs_include_branch([deleted], REPO_ID, "main", "refs/heads/main") is False
+
+
+def test_policy_configs_include_branch_ignores_other_repo() -> None:
+    assert policy_configs_include_branch([BUILD_POLICY_ON_MAIN], "some-other-repo-id", "main", "refs/heads/main") is False
+
+
+def test_policy_configs_include_branch_matches_default_branch_scope() -> None:
+    default_branch_policy = {
+        "isEnabled": True,
+        "isDeleted": False,
+        "type": {"id": "0609b952-1397-4640-95ec-e00a01b2c241"},
+        "settings": {"scope": [{"matchKind": "DefaultBranch", "repositoryId": REPO_ID}]},
+    }
+    assert policy_configs_include_branch([default_branch_policy], REPO_ID, "main", "refs/heads/main") is True
+    assert policy_configs_include_branch([default_branch_policy], REPO_ID, "test", "refs/heads/main") is False

{bmsdna_devtools-0.2.0 → bmsdna_devtools-0.2.2}/uv.lock

@@ -13,7 +13,7 @@ wheels = [
 
 [[package]]
 name = "bmsdna-devtools"
-version = "0.2.0"
+version = "0.2.2"
 source = { editable = "." }
 dependencies = [
     { name = "requests" },

bmsdna_devtools-0.2.0/tests/test_pr_build.py

@@ -1,38 +0,0 @@
-import pytest
-
-from bmsdna.devtools.pr_build import merge_conflict_message
-
-
-@pytest.mark.parametrize("merge_status", ["notSet", "queued", "succeeded"])
-def test_merge_conflict_message_none_when_mergeable(merge_status: str) -> None:
-    assert merge_conflict_message({"pullRequestId": 1, "title": "x", "mergeStatus": merge_status}) is None
-
-
-def test_merge_conflict_message_missing_field_is_fine() -> None:
-    assert merge_conflict_message({"pullRequestId": 1, "title": "x"}) is None
-
-
-def test_merge_conflict_message_conflicts() -> None:
-    pr = {"pullRequestId": 42, "title": "feat: widgets", "mergeStatus": "conflicts"}
-    msg = merge_conflict_message(pr)
-    assert msg is not None
-    assert "PR #42" in msg
-    assert "conflicts" in msg
-
-
-def test_merge_conflict_message_uses_failure_message_when_present() -> None:
-    pr = {
-        "pullRequestId": 7,
-        "title": "fix: x",
-        "mergeStatus": "failure",
-        "mergeFailureMessage": "object too large to merge",
-    }
-    msg = merge_conflict_message(pr)
-    assert msg is not None
-    assert "object too large to merge" in msg
-
-
-@pytest.mark.parametrize("merge_status", ["conflicts", "failure", "rejectedByPolicy"])
-def test_merge_conflict_message_covers_all_bad_statuses(merge_status: str) -> None:
-    pr = {"pullRequestId": 1, "title": "x", "mergeStatus": merge_status}
-    assert merge_conflict_message(pr) is not None