bmsdna-devtools 0.5.0__tar.gz → 0.7.0__tar.gz

bmsdna_devtools-0.7.0/.github/workflows/auto-release.yml

@@ -0,0 +1,83 @@
+# Auto-tags, cuts a GitHub Release, and dispatches a PyPI publish whenever
+# pyproject.toml's version changes on main and the Python Test workflow has
+# passed for that commit. No manual "cut a release" step needed.
+#
+# Two GitHub Actions quirks shaped this design -- both hit and confirmed the
+# hard way, so read before "simplifying" this:
+#
+# 1. GitHub Actions doesn't fire other workflows' triggers (release:
+#    published included) for events performed with the automatic
+#    GITHUB_TOKEN, to prevent recursive runs. So creating the release here
+#    would NOT, on its own, trigger python-publish.yml's `release: published`
+#    listener. workflow_dispatch is the documented exception to that rule --
+#    an API-triggered workflow_dispatch DOES start a new run even when
+#    triggered by GITHUB_TOKEN -- so this dispatches python-publish.yml
+#    directly instead of relying on the release event to cascade.
+#
+# 2. The obvious alternative -- calling python-publish.yml's job directly via
+#    workflow_call instead of dispatching it as a separate run -- avoids (1)
+#    entirely, but breaks PyPI's OIDC trusted publishing: PyPI explicitly
+#    does not support trusted publishing from reusable/called workflows (the
+#    token's claims show a "reusable workflow" parent chain that PyPI's
+#    trusted-publisher matching rejects). So python-publish.yml must stay a
+#    plain, directly-triggered top-level workflow -- no workflow_call trigger
+#    on it, and nothing here should invoke it as `uses:`.
+
+name: Auto Release
+
+on:
+  workflow_run:
+    workflows: ["Python Test"]
+    types: [completed]
+
+permissions:
+  contents: read
+
+jobs:
+  release:
+    if: >
+      github.event.workflow_run.conclusion == 'success' &&
+      github.event.workflow_run.event == 'push' &&
+      github.event.workflow_run.head_branch == 'main'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      actions: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.workflow_run.head_sha }}
+
+      - name: Read version from pyproject.toml
+        id: version
+        run: |
+          version=$(grep -m1 '^version = ' pyproject.toml | sed -E 's/version = "([^"]+)"/\1/')
+          echo "version=$version" >> "$GITHUB_OUTPUT"
+
+      - name: Skip if this version is already on PyPI
+        id: check
+        run: |
+          version="${{ steps.version.outputs.version }}"
+          if curl -fsS https://pypi.org/pypi/bmsdna-devtools/json | jq -e --arg v "$version" '.releases[$v] != null' >/dev/null; then
+            echo "published=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "published=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Create tag and GitHub release, if missing
+        if: steps.check.outputs.published == 'false'
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          if ! gh release view "v${{ steps.version.outputs.version }}" >/dev/null 2>&1; then
+            gh release create "v${{ steps.version.outputs.version }}" \
+              --title "v${{ steps.version.outputs.version }}" \
+              --target "${{ github.event.workflow_run.head_sha }}" \
+              --generate-notes
+          fi
+
+      - name: Dispatch PyPI publish
+        if: steps.check.outputs.published == 'false'
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: gh workflow run python-publish.yml --ref main

{bmsdna_devtools-0.5.0 → bmsdna_devtools-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bmsdna-devtools
-Version: 0.5.0
+Version: 0.7.0
 Summary: Shared Azure DevOps / GitHub / git / Azure Monitor developer tooling for BMS projects
 Requires-Python: >=3.11
 Requires-Dist: requests>=2.32.0
@@ -78,6 +78,27 @@ 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 "..."`.
 
+`--label` (repeatable) applies labels to the PR on either host: on GitHub
+these map to `gh pr create --label`, so the label must already exist on the
+repo (`gh label create`); on Azure DevOps they map to `az repos pr create
+--labels`, which are freeform and get created on the fly. A successful
+create prints the PR's web/GUI link (not just the REST API URL Azure DevOps'
+`az` output otherwise gives you).
+
+`[tool.bdt.pr.required_labels]` in pyproject.toml can require at least one
+label from each named group before the PR is created — checked locally
+(no `gh`/`az` call happens if a group isn't satisfied):
+
+```toml
+[tool.bdt.pr.required_labels]
+type = ["bug", "feature", "chore"]
+risk = ["breaking", "non-breaking"]
+```
+
+With the above, `bdt pr create --label feature --label breaking` passes,
+but `bdt pr create --label feature` fails with a message naming the unmet
+group (`risk`) and its allowed choices.
+
 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
@@ -222,3 +243,29 @@ slot = "test"
 bdt logs fetch --env prod
 bdt logs fetch --env prod --out logs/ --keep-archive
 ```
+
+## Releasing
+
+Bump `version` in `pyproject.toml` as part of your PR, same as any other
+change. Once that PR merges to `main` and the `Python Test` workflow passes
+for that commit, `.github/workflows/auto-release.yml` automatically tags it
+`vX.Y.Z`, cuts a GitHub Release (skipping if that version was already
+released, e.g. a merge that didn't touch the version), and dispatches
+`python-publish.yml` to publish it to PyPI — no manual release step, and no
+extra secret to configure. Two non-obvious GitHub Actions quirks shaped
+this (see the comments at the top of `auto-release.yml` for the full
+reasoning, since both were hit and confirmed the hard way):
+
+- A release created with the default `GITHUB_TOKEN` does **not** trigger
+  other workflows' `release: published` listeners (an anti-recursion
+  safeguard) — `workflow_dispatch` is the documented exception, so
+  `auto-release.yml` dispatches `python-publish.yml` directly (`gh workflow
+  run`) instead of relying on the release to cascade into it.
+- `python-publish.yml` deliberately stays a plain, directly-triggered
+  top-level workflow rather than something `auto-release.yml` calls via
+  `workflow_call`: PyPI's OIDC trusted publishing does not support
+  reusable/called workflows and silently rejects the token in that shape.
+
+`workflow_dispatch` (or an actual GitHub UI release) on `python-publish.yml`
+still works as a manual fallback if you ever need to re-publish a version
+without going through `auto-release.yml`.

{bmsdna_devtools-0.5.0 → bmsdna_devtools-0.7.0}/README.md

@@ -68,6 +68,27 @@ 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 "..."`.
 
+`--label` (repeatable) applies labels to the PR on either host: on GitHub
+these map to `gh pr create --label`, so the label must already exist on the
+repo (`gh label create`); on Azure DevOps they map to `az repos pr create
+--labels`, which are freeform and get created on the fly. A successful
+create prints the PR's web/GUI link (not just the REST API URL Azure DevOps'
+`az` output otherwise gives you).
+
+`[tool.bdt.pr.required_labels]` in pyproject.toml can require at least one
+label from each named group before the PR is created — checked locally
+(no `gh`/`az` call happens if a group isn't satisfied):
+
+```toml
+[tool.bdt.pr.required_labels]
+type = ["bug", "feature", "chore"]
+risk = ["breaking", "non-breaking"]
+```
+
+With the above, `bdt pr create --label feature --label breaking` passes,
+but `bdt pr create --label feature` fails with a message naming the unmet
+group (`risk`) and its allowed choices.
+
 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
@@ -212,3 +233,29 @@ slot = "test"
 bdt logs fetch --env prod
 bdt logs fetch --env prod --out logs/ --keep-archive
 ```
+
+## Releasing
+
+Bump `version` in `pyproject.toml` as part of your PR, same as any other
+change. Once that PR merges to `main` and the `Python Test` workflow passes
+for that commit, `.github/workflows/auto-release.yml` automatically tags it
+`vX.Y.Z`, cuts a GitHub Release (skipping if that version was already
+released, e.g. a merge that didn't touch the version), and dispatches
+`python-publish.yml` to publish it to PyPI — no manual release step, and no
+extra secret to configure. Two non-obvious GitHub Actions quirks shaped
+this (see the comments at the top of `auto-release.yml` for the full
+reasoning, since both were hit and confirmed the hard way):
+
+- A release created with the default `GITHUB_TOKEN` does **not** trigger
+  other workflows' `release: published` listeners (an anti-recursion
+  safeguard) — `workflow_dispatch` is the documented exception, so
+  `auto-release.yml` dispatches `python-publish.yml` directly (`gh workflow
+  run`) instead of relying on the release to cascade into it.
+- `python-publish.yml` deliberately stays a plain, directly-triggered
+  top-level workflow rather than something `auto-release.yml` calls via
+  `workflow_call`: PyPI's OIDC trusted publishing does not support
+  reusable/called workflows and silently rejects the token in that shape.
+
+`workflow_dispatch` (or an actual GitHub UI release) on `python-publish.yml`
+still works as a manual fallback if you ever need to re-publish a version
+without going through `auto-release.yml`.

{bmsdna_devtools-0.5.0 → bmsdna_devtools-0.7.0}/bmsdna/devtools/cli.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
 
+import json
 import subprocess
 import sys
 from collections.abc import Callable
+from importlib.metadata import version as _pkg_version
 from pathlib import Path
 
 import requests
@@ -12,7 +14,7 @@ from . import ado_issue, app_service_logs, commit as commit_mod
 from . import env_config
 from . import gh_issue, gh_pr
 from . import logs as logs_mod
-from . import pr_build, worktree as worktree_mod
+from . import pr_build, pr_labels, worktree as worktree_mod
 from .ado_auth import auth_header
 from .cli_tools import require_az, require_gh
 from .gitrepo import AdoRemote, GitHubRemote, current_branch, current_remote
@@ -24,7 +26,32 @@ if sys.platform == "win32":
     sys.stdout.reconfigure(encoding="utf-8")  # type: ignore[union-attr]
     sys.stderr.reconfigure(encoding="utf-8")  # type: ignore[union-attr]
 
-app = typer.Typer(name="bdt", help="Shared BMS developer tooling: PRs/builds (Azure DevOps or GitHub), worktrees, commits, logs")
+__version__ = _pkg_version("bmsdna-devtools")
+
+app = typer.Typer(
+    name="bdt",
+    help=f"Shared BMS developer tooling: PRs/builds (Azure DevOps or GitHub), worktrees, commits, logs (v{__version__})",
+)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        print(f"bdt {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        None,
+        "--version",
+        callback=_version_callback,
+        is_eager=True,
+        help="Show the bdt version and exit.",
+    ),
+) -> None:
+    pass
+
 
 pr_app = typer.Typer(name="pr", help="Pull request commands (Azure DevOps or GitHub, auto-detected from the git remote)")
 app.add_typer(pr_app, name="pr")
@@ -64,6 +91,14 @@ def _attach_screenshots(attach: Callable[[], None]) -> None:
 def pr_create(
     target: str = typer.Option("main", "--target", help="Target branch (e.g. main, test)"),
     draft: bool = typer.Option(False, "--draft", help="Create the PR as a draft (not ready for review)"),
+    label: list[str] = typer.Option(
+        [],
+        "--label",
+        help="Label to apply to the PR (repeatable). On GitHub the label must already exist on the repo "
+        "(`gh label create`); Azure DevOps PR labels are freeform and created on the fly. "
+        r"[tool.bdt.pr.required_labels] in pyproject.toml can require at least one label from each "
+        "named group before the PR is created.",
+    ),
     screenshot: list[str] = typer.Option(
         [], "--screenshot", help="Path to an image to attach to the PR description (repeatable)"
     ),
@@ -80,11 +115,16 @@ def pr_create(
         if not Path(path).is_file():
             raise typer.BadParameter(f"Screenshot not found: {path}", param_hint="--screenshot")
 
+    missing_groups = pr_labels.missing_label_groups(pr_labels.required_label_groups(), label)
+    if missing_groups:
+        raise typer.BadParameter(pr_labels.format_missing_groups_error(missing_groups), param_hint="--label")
+
     remote = current_remote()
     source_branch = current_branch()
+    pr_url: str | None = None
     if isinstance(remote, GitHubRemote):
         gh = require_gh()
-        returncode = gh_pr.create(gh, target, args or [], draft=draft)
+        returncode, pr_url = gh_pr.create(gh, target, args or [], draft=draft, labels=label)
         build_policy = gh_pr.has_build_policy(gh, target)
         if returncode == 0 and screenshot:
             _attach_screenshots(lambda: gh_pr.add_screenshots(gh, remote.owner, remote.repo, source_branch, screenshot))
@@ -99,10 +139,33 @@ def pr_create(
             "--target-branch", target,
             "--source-branch", source_branch,
             "--auto-complete", "false",
+            "--output", "json",
             *(["--draft", "true"] if draft else []),
+            *(["--labels", *label] if label else []),
             *(args or []),
         ]
-        returncode = subprocess.run(cmd).returncode
+        r = subprocess.run(cmd, capture_output=True, encoding="utf-8")
+        returncode = r.returncode
+        if isinstance(r.stderr, str) and r.stderr.strip():
+            print(r.stderr.strip(), file=sys.stderr)
+
+        pr_json = None
+        if returncode == 0 and isinstance(r.stdout, str):
+            try:
+                pr_json = json.loads(r.stdout)
+            except json.JSONDecodeError:
+                pr_json = None
+
+        if pr_json is not None:
+            # Concise summary instead of the raw `az` JSON blob — the web
+            # link printed below is the part a human actually needs.
+            print(f"PR #{pr_json.get('pullRequestId', '?')}: {pr_json.get('title', '?')}")
+            try:
+                pr_url = pr_build.pr_web_url(remote, pr_json["pullRequestId"])
+            except (KeyError, TypeError):
+                pr_url = None
+        elif isinstance(r.stdout, str) and r.stdout.strip():
+            print(r.stdout.rstrip())
         session = requests.Session()
         session.headers.update(auth_header(pat))
         build_policy = pr_build.has_build_policy(session, remote, target)
@@ -114,6 +177,9 @@ def pr_create(
             _attach_screenshots(_add)
         publish_hint = "`az repos pr update --id <PR-ID> --draft false`"
 
+    if returncode == 0 and pr_url:
+        print(f"\n{pr_url}")
+
     if returncode == 0 and draft:
         print(f"\nCreated as a draft PR. Run `bdt pr publish` (or {publish_hint}) to mark it ready for review.")
 

{bmsdna_devtools-0.5.0 → bmsdna_devtools-0.7.0}/bmsdna/devtools/gh_pr.py

@@ -140,15 +140,32 @@ def run(gh: str, wait: bool) -> None:
         return
 
 
-def create(gh: str, target: str, extra_args: list[str], draft: bool = False) -> int:
+def create(gh: str, target: str, extra_args: list[str], draft: bool = False, labels: list[str] | None = None) -> tuple[int, str | None]:
     """Create a GitHub PR from the current branch into `target`.
 
     --fill autofills title/body from commit info so this never blocks on an
     interactive prompt; pass --title/--body in extra_args to override (gh
     lets explicit values take precedence over --fill).
+
+    `-l/--label` labels must already exist on the repo (`gh label create`) —
+    unlike Azure DevOps PR labels, GitHub rejects a label name it doesn't
+    already know about.
+
+    Returns (returncode, web_url) — on success `gh pr create` prints the
+    PR's web URL as its only stdout line, which is what a human needs to
+    open it; on failure the url is `None` and the CLI's stderr is
+    surfaced to ours.
     """
-    cmd = [gh, "pr", "create", "--base", target, "--fill", *(["--draft"] if draft else []), *extra_args]
-    return subprocess.run(cmd).returncode
+    cmd = [gh, "pr", "create", "--base", target, "--fill", *(["--draft"] if draft else [])]
+    for label in labels or []:
+        cmd += ["--label", label]
+    cmd += extra_args
+    r = subprocess.run(cmd, capture_output=True, encoding="utf-8")
+    if r.stderr:
+        print(r.stderr.strip(), file=sys.stderr)
+    if r.returncode != 0:
+        return r.returncode, None
+    return r.returncode, r.stdout.strip() or None
 
 
 def publish(gh: str) -> None:

{bmsdna_devtools-0.5.0 → bmsdna_devtools-0.7.0}/bmsdna/devtools/pr_build.py

@@ -30,6 +30,13 @@ def _base_url(remote: AdoRemote) -> str:
     return f"https://dev.azure.com/{remote.org}/{quote(remote.project, safe='')}"
 
 
+def pr_web_url(remote: AdoRemote, pr_id: int) -> str:
+    """The browsable web page for a PR, as opposed to its REST API URL (which is all the
+    `az repos pr create` JSON response otherwise gives you).
+    """
+    return f"{_base_url(remote)}/_git/{quote(remote.repo, safe='')}/pullrequest/{pr_id}"
+
+
 # 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"

bmsdna_devtools-0.7.0/bmsdna/devtools/pr_labels.py

@@ -0,0 +1,43 @@
+"""Required PR label groups, configured under `[tool.bdt.pr.required_labels]`
+in pyproject.toml:
+
+    [tool.bdt.pr.required_labels]
+    type = ["bug", "feature", "chore"]
+    risk = ["breaking", "non-breaking"]
+
+Each key names a group; its value is the labels that satisfy it. `bdt pr
+create` must be given at least one label from every configured group
+(checked locally, before talking to GitHub/Azure DevOps, so a PR missing a
+required label is never created in the first place). Applies identically on
+both hosts.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .bdt_config import load_bdt_table
+
+
+def required_label_groups(start: Path | None = None) -> dict[str, list[str]]:
+    """`[tool.bdt.pr.required_labels]` -> {group name: [allowed label, ...]}."""
+    raw = load_bdt_table("pr", start).get("required_labels", {})
+    if not isinstance(raw, dict):
+        return {}
+    return {name: choices for name, choices in raw.items() if isinstance(choices, list)}
+
+
+def missing_label_groups(groups: dict[str, list[str]], labels: list[str]) -> dict[str, list[str]]:
+    """The subset of `groups` for which none of `labels` is a member.
+
+    Matched case-insensitively — this is a local config check independent of
+    whatever casing rules GitHub/Azure DevOps apply to the label text that
+    actually gets sent through unchanged.
+    """
+    given = {label.lower() for label in labels}
+    return {name: choices for name, choices in groups.items() if given.isdisjoint(choice.lower() for choice in choices)}
+
+
+def format_missing_groups_error(missing: dict[str, list[str]]) -> str:
+    parts = [f"'{name}' (choose one of: {', '.join(choices)})" for name, choices in missing.items()]
+    return "Missing required PR label(s) for group " + "; group ".join(parts)

{bmsdna_devtools-0.5.0 → bmsdna_devtools-0.7.0}/pyproject.toml

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

bmsdna_devtools-0.7.0/tests/test_cli_pr_create.py

@@ -0,0 +1,132 @@
+"""`bdt pr create` must pass the parsed org/project/repo through to
+`az repos pr create` explicitly, rather than relying on `az`'s own remote
+auto-detection -- that auto-detect doesn't understand the SSH `v3` remote
+form at all, and separately, an `az devops configure -d project=...` default
+that happens to point at a *different* ADO project than the current repo's
+own silently makes `az` look for the PR's repository in the wrong project.
+"""
+
+import json
+from unittest.mock import MagicMock
+
+from typer.testing import CliRunner
+
+from bmsdna.devtools.cli import app
+from bmsdna.devtools.gitrepo import AdoRemote, GitHubRemote
+
+runner = CliRunner()
+
+
+def test_pr_create_passes_organization_project_repository_to_az(monkeypatch) -> None:
+    remote = AdoRemote("bmeurope", "BMS - CCMT2", "BMS - CCMT2")
+    monkeypatch.setattr("bmsdna.devtools.cli.current_remote", lambda: remote)
+    monkeypatch.setattr("bmsdna.devtools.cli.current_branch", lambda: "feature-x")
+    monkeypatch.setattr("bmsdna.devtools.cli.require_az", lambda: "az")
+    monkeypatch.setattr("bmsdna.devtools.cli.auth_header", lambda pat: {})
+
+    captured_cmd: list[str] = []
+
+    def fake_run(cmd, **kwargs):
+        captured_cmd[:] = cmd
+        return MagicMock(returncode=0)
+
+    monkeypatch.setattr("bmsdna.devtools.cli.subprocess.run", fake_run)
+    monkeypatch.setattr("bmsdna.devtools.pr_build.has_build_policy", lambda session, remote, target: False)
+
+    result = runner.invoke(app, ["pr", "create", "--target", "test"])
+
+    assert result.exit_code == 0, result.output
+    assert "--organization" in captured_cmd
+    assert captured_cmd[captured_cmd.index("--organization") + 1] == "https://dev.azure.com/bmeurope"
+    assert "--project" in captured_cmd
+    assert captured_cmd[captured_cmd.index("--project") + 1] == "BMS - CCMT2"
+    assert "--repository" in captured_cmd
+    assert captured_cmd[captured_cmd.index("--repository") + 1] == "BMS - CCMT2"
+
+
+def test_pr_create_passes_labels_and_prints_web_link_for_ado(monkeypatch) -> None:
+    remote = AdoRemote("bmeurope", "BMS - CCMT2", "BMS - CCMT2")
+    monkeypatch.setattr("bmsdna.devtools.cli.current_remote", lambda: remote)
+    monkeypatch.setattr("bmsdna.devtools.cli.current_branch", lambda: "feature-x")
+    monkeypatch.setattr("bmsdna.devtools.cli.require_az", lambda: "az")
+    monkeypatch.setattr("bmsdna.devtools.cli.auth_header", lambda pat: {})
+    monkeypatch.setattr("bmsdna.devtools.pr_build.has_build_policy", lambda session, remote, target: False)
+
+    captured_cmd: list[str] = []
+
+    def fake_run(cmd, **kwargs):
+        captured_cmd[:] = cmd
+        return MagicMock(returncode=0, stdout=json.dumps({"pullRequestId": 456, "title": "feat: widgets"}), stderr="")
+
+    monkeypatch.setattr("bmsdna.devtools.cli.subprocess.run", fake_run)
+
+    result = runner.invoke(app, ["pr", "create", "--target", "test", "--label", "bug", "--label", "urgent"])
+
+    assert result.exit_code == 0, result.output
+    assert "--labels" in captured_cmd
+    labels_idx = captured_cmd.index("--labels")
+    assert captured_cmd[labels_idx + 1 : labels_idx + 3] == ["bug", "urgent"]
+    assert "https://dev.azure.com/bmeurope/BMS%20-%20CCMT2/_git/BMS%20-%20CCMT2/pullrequest/456" in result.output
+    assert "PR #456: feat: widgets" in result.output
+    assert '"pullRequestId"' not in result.output  # the raw `az` JSON blob must not be dumped on success
+
+
+def test_pr_create_passes_labels_and_prints_web_link_for_github(monkeypatch) -> None:
+    remote = GitHubRemote("owner", "repo")
+    monkeypatch.setattr("bmsdna.devtools.cli.current_remote", lambda: remote)
+    monkeypatch.setattr("bmsdna.devtools.cli.current_branch", lambda: "feature-x")
+    monkeypatch.setattr("bmsdna.devtools.cli.require_gh", lambda: "gh")
+    monkeypatch.setattr("bmsdna.devtools.gh_pr.has_build_policy", lambda gh, target: False)
+
+    captured_cmd: list[str] = []
+
+    def fake_run(cmd, **kwargs):
+        captured_cmd[:] = cmd
+        return MagicMock(returncode=0, stdout="https://github.com/owner/repo/pull/7\n", stderr="")
+
+    monkeypatch.setattr("bmsdna.devtools.gh_pr.subprocess.run", fake_run)
+
+    result = runner.invoke(app, ["pr", "create", "--target", "main", "--label", "bug"])
+
+    assert result.exit_code == 0, result.output
+    assert captured_cmd.count("--label") == 1
+    assert captured_cmd[captured_cmd.index("--label") + 1] == "bug"
+    assert "https://github.com/owner/repo/pull/7" in result.output
+
+
+def test_pr_create_fails_before_touching_gh_az_when_required_label_group_missing(monkeypatch) -> None:
+    monkeypatch.setattr(
+        "bmsdna.devtools.cli.pr_labels.required_label_groups",
+        lambda: {"risk": ["breaking", "non-breaking"]},
+    )
+
+    def fail_if_called(*args, **kwargs):
+        raise AssertionError("should not be reached — the missing-label check must run first")
+
+    monkeypatch.setattr("bmsdna.devtools.cli.current_remote", fail_if_called)
+
+    result = runner.invoke(app, ["pr", "create", "--target", "main", "--label", "bug"])
+
+    assert result.exit_code != 0
+    assert "risk" in result.output
+    assert "breaking" in result.output
+
+
+def test_pr_create_proceeds_when_required_label_group_satisfied(monkeypatch) -> None:
+    remote = GitHubRemote("owner", "repo")
+    monkeypatch.setattr(
+        "bmsdna.devtools.cli.pr_labels.required_label_groups",
+        lambda: {"risk": ["breaking", "non-breaking"]},
+    )
+    monkeypatch.setattr("bmsdna.devtools.cli.current_remote", lambda: remote)
+    monkeypatch.setattr("bmsdna.devtools.cli.current_branch", lambda: "feature-x")
+    monkeypatch.setattr("bmsdna.devtools.cli.require_gh", lambda: "gh")
+    monkeypatch.setattr("bmsdna.devtools.gh_pr.has_build_policy", lambda gh, target: False)
+    monkeypatch.setattr(
+        "bmsdna.devtools.gh_pr.subprocess.run",
+        lambda cmd, **kwargs: MagicMock(returncode=0, stdout="https://github.com/owner/repo/pull/7\n", stderr=""),
+    )
+
+    result = runner.invoke(app, ["pr", "create", "--target", "main", "--label", "non-breaking"])
+
+    assert result.exit_code == 0, result.output

{bmsdna_devtools-0.5.0 → bmsdna_devtools-0.7.0}/tests/test_gh_pr.py

@@ -1,6 +1,8 @@
+from unittest.mock import MagicMock
+
 import pytest
 
-from bmsdna.devtools.gh_pr import check_bucket, check_label, merge_conflict_message, protection_requires_status_checks
+from bmsdna.devtools.gh_pr import check_bucket, check_label, create, 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 = {
@@ -70,3 +72,33 @@ def test_protection_requires_status_checks_true_when_configured() -> None:
 @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
+
+
+def test_create_passes_repeatable_label_flags(monkeypatch) -> None:
+    captured_cmd: list[str] = []
+
+    def fake_run(cmd, **kwargs):
+        captured_cmd[:] = cmd
+        return MagicMock(returncode=0, stdout="https://github.com/owner/repo/pull/7\n", stderr="")
+
+    monkeypatch.setattr("bmsdna.devtools.gh_pr.subprocess.run", fake_run)
+
+    returncode, url = create("gh", "main", [], labels=["bug", "urgent"])
+
+    assert returncode == 0
+    assert url == "https://github.com/owner/repo/pull/7"
+    assert captured_cmd.count("--label") == 2
+    assert captured_cmd[captured_cmd.index("--label") + 1] == "bug"
+
+
+def test_create_returns_none_url_on_failure(monkeypatch, capsys) -> None:
+    def fake_run(cmd, **kwargs):
+        return MagicMock(returncode=1, stdout="", stderr="label 'nope' not found")
+
+    monkeypatch.setattr("bmsdna.devtools.gh_pr.subprocess.run", fake_run)
+
+    returncode, url = create("gh", "main", [], labels=["nope"])
+
+    assert returncode == 1
+    assert url is None
+    assert "not found" in capsys.readouterr().err

{bmsdna_devtools-0.5.0 → bmsdna_devtools-0.7.0}/tests/test_pr_build.py

@@ -1,6 +1,7 @@
 import pytest
 
-from bmsdna.devtools.pr_build import merge_conflict_message, policy_configs_include_branch
+from bmsdna.devtools.gitrepo import AdoRemote
+from bmsdna.devtools.pr_build import merge_conflict_message, policy_configs_include_branch, pr_web_url
 
 REPO_ID = "0cd3a822-389e-416e-a4fa-b73f988c2930"
 
@@ -95,3 +96,8 @@ def test_policy_configs_include_branch_matches_default_branch_scope() -> None:
     }
     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
+
+
+def test_pr_web_url_is_the_browsable_page_not_the_rest_api_url() -> None:
+    remote = AdoRemote("bmeurope", "BMS - CCMT2", "BMS - CCMT2")
+    assert pr_web_url(remote, 123) == "https://dev.azure.com/bmeurope/BMS%20-%20CCMT2/_git/BMS%20-%20CCMT2/pullrequest/123"

bmsdna_devtools-0.7.0/tests/test_pr_labels.py

@@ -0,0 +1,56 @@
+from bmsdna.devtools.pr_labels import format_missing_groups_error, missing_label_groups, required_label_groups
+
+
+def write_pyproject(tmp_path, body: str):
+    (tmp_path / "pyproject.toml").write_text(body)
+    return tmp_path
+
+
+def test_required_label_groups_empty_when_no_pyproject(tmp_path) -> None:
+    assert required_label_groups(tmp_path) == {}
+
+
+def test_required_label_groups_empty_when_table_absent(tmp_path) -> None:
+    write_pyproject(tmp_path, "[tool.bdt.ado]\nboard = 'x'\n")
+    assert required_label_groups(tmp_path) == {}
+
+
+def test_required_label_groups_reads_named_groups(tmp_path) -> None:
+    write_pyproject(
+        tmp_path,
+        "[tool.bdt.pr.required_labels]\n"
+        'type = ["bug", "feature", "chore"]\n'
+        'risk = ["breaking", "non-breaking"]\n',
+    )
+    assert required_label_groups(tmp_path) == {
+        "type": ["bug", "feature", "chore"],
+        "risk": ["breaking", "non-breaking"],
+    }
+
+
+def test_missing_label_groups_none_missing_when_all_satisfied() -> None:
+    groups = {"type": ["bug", "feature"], "risk": ["breaking", "non-breaking"]}
+    assert missing_label_groups(groups, ["feature", "breaking"]) == {}
+
+
+def test_missing_label_groups_reports_unsatisfied_group() -> None:
+    groups = {"type": ["bug", "feature"], "risk": ["breaking", "non-breaking"]}
+    assert missing_label_groups(groups, ["feature"]) == {"risk": ["breaking", "non-breaking"]}
+
+
+def test_missing_label_groups_matches_case_insensitively() -> None:
+    groups = {"risk": ["breaking", "non-breaking"]}
+    assert missing_label_groups(groups, ["Breaking"]) == {}
+    assert missing_label_groups(groups, ["BREAKING"]) == {}
+
+
+def test_missing_label_groups_reports_all_when_no_labels_given() -> None:
+    groups = {"type": ["bug", "feature"], "risk": ["breaking", "non-breaking"]}
+    assert missing_label_groups(groups, []) == groups
+
+
+def test_format_missing_groups_error_lists_group_name_and_choices() -> None:
+    msg = format_missing_groups_error({"risk": ["breaking", "non-breaking"]})
+    assert "risk" in msg
+    assert "breaking" in msg
+    assert "non-breaking" in msg

{bmsdna_devtools-0.5.0 → bmsdna_devtools-0.7.0}/uv.lock

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

bmsdna_devtools-0.5.0/tests/test_cli_pr_create.py

@@ -1,43 +0,0 @@
-"""`bdt pr create` must pass the parsed org/project/repo through to
-`az repos pr create` explicitly, rather than relying on `az`'s own remote
-auto-detection -- that auto-detect doesn't understand the SSH `v3` remote
-form at all, and separately, an `az devops configure -d project=...` default
-that happens to point at a *different* ADO project than the current repo's
-own silently makes `az` look for the PR's repository in the wrong project.
-"""
-
-from unittest.mock import MagicMock
-
-from typer.testing import CliRunner
-
-from bmsdna.devtools.cli import app
-from bmsdna.devtools.gitrepo import AdoRemote
-
-runner = CliRunner()
-
-
-def test_pr_create_passes_organization_project_repository_to_az(monkeypatch) -> None:
-    remote = AdoRemote("bmeurope", "BMS - CCMT2", "BMS - CCMT2")
-    monkeypatch.setattr("bmsdna.devtools.cli.current_remote", lambda: remote)
-    monkeypatch.setattr("bmsdna.devtools.cli.current_branch", lambda: "feature-x")
-    monkeypatch.setattr("bmsdna.devtools.cli.require_az", lambda: "az")
-    monkeypatch.setattr("bmsdna.devtools.cli.auth_header", lambda pat: {})
-
-    captured_cmd: list[str] = []
-
-    def fake_run(cmd, **kwargs):
-        captured_cmd[:] = cmd
-        return MagicMock(returncode=0)
-
-    monkeypatch.setattr("bmsdna.devtools.cli.subprocess.run", fake_run)
-    monkeypatch.setattr("bmsdna.devtools.pr_build.has_build_policy", lambda session, remote, target: False)
-
-    result = runner.invoke(app, ["pr", "create", "--target", "test"])
-
-    assert result.exit_code == 0, result.output
-    assert "--organization" in captured_cmd
-    assert captured_cmd[captured_cmd.index("--organization") + 1] == "https://dev.azure.com/bmeurope"
-    assert "--project" in captured_cmd
-    assert captured_cmd[captured_cmd.index("--project") + 1] == "BMS - CCMT2"
-    assert "--repository" in captured_cmd
-    assert captured_cmd[captured_cmd.index("--repository") + 1] == "BMS - CCMT2"