@openhands/extensions 0.20.0 → 0.22.0

package/tests/test_github_developer_delivery.py

@@ -0,0 +1,150 @@
+"""Contract tests for independent developer delivery."""
+
+from unittest.mock import Mock
+
+from github_automation_helpers import worker
+
+
+def _developer(tmp_path, monkeypatch):
+    module = worker("github-issue-to-pr", tmp_path, monkeypatch)
+    run = object.__new__(module.IssueToPR)
+    run.config = {
+        "trigger_label": "ready-for-dev",
+        "branch_prefix": "openhands/issue",
+        "review_label": "openhands-review",
+    }
+    run.repository = "owner/repo"
+    run.token_name = "FACTORY_GITHUB_DEVELOPER_TOKEN"
+    run.dispatcher = Mock()
+    run.dependencies_complete = lambda issue: True
+    run.statuses = lambda sha: {}
+    return module, run
+
+
+def test_developer_fans_out_ready_issues_by_priority(tmp_path, monkeypatch):
+    _module, run = _developer(tmp_path, monkeypatch)
+    issues = [
+        {
+            "number": 2,
+            "title": "Normal",
+            "updated_at": "u2",
+            "labels": [{"name": "ready-for-dev"}],
+        },
+        {
+            "number": 1,
+            "title": "High",
+            "updated_at": "u1",
+            "labels": [{"name": "ready-for-dev"}, {"name": "priority:high"}],
+        },
+    ]
+    run.open_issues = lambda: issues
+    run.gh_pages = lambda path: []
+    run.gh = Mock(
+        side_effect=[{"id": 55, "default_branch": "main"}, {"object": {"sha": "base"}}]
+    )
+    submit = Mock(
+        side_effect=lambda **kwargs: {
+            "disposition": "created",
+            "conversation_id": kwargs["subject"],
+        }
+    )
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    assert [call.kwargs["subject"] for call in submit.call_args_list] == [
+        "55:issue:1",
+        "55:issue:2",
+    ]
+    prompt = submit.call_args_list[0].kwargs["prompt"]
+    assert "workspace starts empty" in prompt
+    assert "FACTORY_GITHUB_DEVELOPER_TOKEN" in prompt
+    assert "gh repo clone owner/repo ." in prompt
+
+
+def test_developer_submits_failed_review_as_same_subject(tmp_path, monkeypatch):
+    _module, run = _developer(tmp_path, monkeypatch)
+    issue = {"number": 4, "title": "Feature", "updated_at": "u4", "labels": []}
+    pr = {
+        "number": 8,
+        "head": {"ref": "openhands/issue-4", "sha": "head"},
+        "base": {"ref": "main"},
+        "labels": [],
+    }
+    run.open_issues = lambda: [issue]
+    run.gh_pages = lambda path: [pr]
+    run.statuses = lambda sha: {"software-factory/review": "failure"}
+    run.gh = Mock(
+        side_effect=[{"id": 55, "default_branch": "main"}, {"object": {"sha": "base"}}]
+    )
+    submit = Mock(
+        return_value={"disposition": "created", "conversation_id": "conversation"}
+    )
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    assert submit.call_args.kwargs["subject"] == "55:issue:4"
+    assert submit.call_args.kwargs["delivery"] == "4:head"
+    prompt = submit.call_args.kwargs["prompt"]
+    assert "Revise existing PR #8 at exact head `head`" in prompt
+    assert "check out the existing remote branch `openhands/issue-4`" in prompt
+    assert "do not open another pull request" in prompt
+
+
+def test_developer_continues_after_one_submission_fails(tmp_path, monkeypatch):
+    _module, run = _developer(tmp_path, monkeypatch)
+    issues = [
+        {
+            "number": 1,
+            "title": "First",
+            "updated_at": "u1",
+            "labels": [{"name": "ready-for-dev"}],
+        },
+        {
+            "number": 2,
+            "title": "Second",
+            "updated_at": "u2",
+            "labels": [{"name": "ready-for-dev"}],
+        },
+    ]
+    run.open_issues = lambda: issues
+    run.gh_pages = lambda path: []
+    run.gh = Mock(
+        side_effect=[{"id": 55, "default_branch": "main"}, {"object": {"sha": "base"}}]
+    )
+    submit = Mock(
+        side_effect=[
+            RuntimeError("unavailable"),
+            {"disposition": "created", "conversation_id": "second"},
+        ]
+    )
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    assert [call.kwargs["subject"] for call in submit.call_args_list] == [
+        "55:issue:1",
+        "55:issue:2",
+    ]
+
+
+def test_developer_skips_open_pr_awaiting_review(tmp_path, monkeypatch):
+    _module, run = _developer(tmp_path, monkeypatch)
+    issue = {"number": 4, "title": "Feature", "labels": [{"name": "ready-for-dev"}]}
+    pr = {
+        "number": 8,
+        "head": {"ref": "openhands/issue-4", "sha": "head"},
+        "labels": [{"name": "openhands-review"}],
+    }
+    run.open_issues = lambda: [issue]
+    run.gh_pages = lambda path: [pr]
+    run.gh = Mock(
+        side_effect=[{"id": 55, "default_branch": "main"}, {"object": {"sha": "base"}}]
+    )
+    submit = Mock()
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    submit.assert_not_called()

package/tests/test_github_reviewer_delivery.py

@@ -0,0 +1,110 @@
+"""Contract tests for delegated GitHub PR review."""
+
+from pathlib import Path
+from unittest.mock import Mock
+
+from github_automation_helpers import worker
+
+
+def _reviewer(tmp_path, monkeypatch):
+    module = worker("github-pr-reviewer", tmp_path, monkeypatch)
+    run = object.__new__(module.PullRequestReviewer)
+    run.config = {"trigger_label": "openhands-review"}
+    run.repository = "owner/repo"
+    run.token = "token"
+    run.token_name = "FACTORY_GITHUB_REVIEWER_TOKEN"
+    run.dispatcher = Mock()
+    return module, run
+
+
+def test_reviewer_submits_each_labeled_exact_head(tmp_path, monkeypatch):
+    module, run = _reviewer(tmp_path, monkeypatch)
+    prs = [
+        {
+            "number": 2,
+            "head": {"sha": "head-2"},
+            "labels": [{"name": "openhands-review"}],
+        },
+        {"number": 1, "head": {"sha": "head-1"}, "labels": []},
+    ]
+    run.gh_pages = lambda path: prs
+    run.gh = Mock(side_effect=[{"id": 99}, prs[0]])
+    monkeypatch.setattr(
+        module.workflow,
+        "_latest_trigger_label_event",
+        lambda *args: {"id": 7, "created_at": "now"},
+    )
+    submit = Mock(
+        return_value={"disposition": "created", "conversation_id": "conversation"}
+    )
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    assert submit.call_args.kwargs["subject"] == "99:pr:2"
+    assert submit.call_args.kwargs["delivery"] == "7:head-2"
+    prompt = submit.call_args.kwargs["prompt"]
+    assert "publish the review directly to GitHub" in prompt
+    assert "software-factory/review" in prompt
+    assert "software-factory/tests" in prompt
+    assert "FACTORY_GITHUB_REVIEWER_TOKEN" in prompt
+    assert "gh auth setup-git" in prompt
+    assert "GIT_TERMINAL_PROMPT=0" in prompt
+    assert "Never paste JSON artifacts" in prompt
+
+
+def test_reviewer_ignores_unlabeled_prs(tmp_path, monkeypatch):
+    _module, run = _reviewer(tmp_path, monkeypatch)
+    run.gh_pages = lambda path: [{"number": 1, "labels": [], "head": {"sha": "head"}}]
+    run.gh = Mock(return_value={"id": 99})
+    submit = Mock()
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    submit.assert_not_called()
+
+
+def test_reviewer_continues_after_one_submission_fails(tmp_path, monkeypatch):
+    module, run = _reviewer(tmp_path, monkeypatch)
+    prs = [
+        {
+            "number": number,
+            "labels": [{"name": "openhands-review"}],
+            "head": {"sha": f"head-{number}"},
+        }
+        for number in (1, 2)
+    ]
+    run.gh_pages = lambda path: prs
+    run.gh = Mock(side_effect=[{"id": 99}, *prs])
+    monkeypatch.setattr(
+        module.workflow,
+        "_latest_trigger_label_event",
+        lambda *args: {"id": 7, "created_at": "now"},
+    )
+    submit = Mock(
+        side_effect=[
+            RuntimeError("temporary failure"),
+            {"disposition": "created", "conversation_id": "conversation"},
+        ]
+    )
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    assert submit.call_count == 2
+
+
+def test_reviewer_scanner_has_no_conversation_or_runtime_code():
+    source = (
+        Path(__file__).resolve().parents[1]
+        / "skills/github-pr-reviewer/scripts/worker.py"
+    ).read_text()
+    for forbidden in (
+        "RemoteConversation",
+        "RemoteWorkspace",
+        "AGENT_SERVER_URL",
+        "SESSION_API_KEY",
+        "AUTOMATION_CONVERSATION_ID",
+    ):
+        assert forbidden not in source

package/tests/test_github_skill_installation.py

@@ -0,0 +1,63 @@
+"""Verify shared support is included in independently installed skills."""
+
+import json
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+from openhands.sdk.skills import install_skill
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def test_installed_triage_skill_contains_its_bundle(tmp_path):
+    name = "github-issue-triage"
+    install_skill(source=str(ROOT / "skills" / name), installed_dir=tmp_path)
+    scripts = tmp_path / name / "scripts"
+    manifest = json.loads(
+        (ROOT / f"automations/catalog/{name}/manifest.json").read_text()
+    )
+
+    for filename, source in manifest["setup"]["bundle"]["files"].items():
+        installed = scripts / filename
+        assert installed.is_file() and not installed.is_symlink()
+        assert installed.read_bytes() == (ROOT / source).read_bytes()
+
+    result = subprocess.run(
+        [sys.executable, "-c", "import worker"],
+        cwd=scripts,
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    assert result.returncode == 0, result.stderr
+
+
+@pytest.mark.parametrize(
+    "name",
+    [
+        "github-repo-monitor",
+        "github-agents-md-maintainer",
+        "github-issue-to-pr",
+        "github-pr-reviewer",
+    ],
+)
+def test_installed_github_skill_contains_shared_client(tmp_path, name):
+    install_skill(source=str(ROOT / "skills" / name), installed_dir=tmp_path)
+    scripts = tmp_path / name / "scripts"
+    helper = scripts / "github_client.py"
+
+    assert helper.is_file() and not helper.is_symlink()
+    assert (
+        helper.read_bytes()
+        == (ROOT / "skills/github/scripts/github_client.py").read_bytes()
+    )
+    result = subprocess.run(
+        [sys.executable, "-c", "import main"],
+        cwd=scripts,
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    assert result.returncode == 0, result.stderr

package/tests/test_github_triage_delivery.py

@@ -0,0 +1,90 @@
+"""Contract tests for independent triage delivery."""
+
+from unittest.mock import Mock
+
+from github_automation_helpers import worker
+
+
+def _triage(tmp_path, monkeypatch, issues):
+    module = worker("github-issue-triage", tmp_path, monkeypatch)
+    cls = module.IssueTriage
+    run = object.__new__(cls)
+    run.repository = "owner/repo"
+    run.token_name = "GITHUB_PERSONAL_ACCESS_TOKEN"
+    run.dispatcher = Mock()
+    run.open_issues = lambda: issues
+    run.dependencies_complete = lambda issue: True
+    run.gh = lambda method, path, body=None: {"id": 9876}
+    run.gh_pages = lambda path: []
+    return module, run
+
+
+def test_triage_submits_each_changed_issue_as_agent_work(tmp_path, monkeypatch):
+    issues = [
+        {"number": 2, "title": "Second", "body": "B", "labels": []},
+        {"number": 1, "title": "First", "body": "A", "labels": []},
+    ]
+    _module, run = _triage(tmp_path, monkeypatch, issues)
+    submit = Mock(
+        side_effect=lambda **kwargs: {
+            "disposition": "created",
+            "conversation_id": kwargs["subject"],
+        }
+    )
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    assert [call.kwargs["subject"] for call in submit.call_args_list] == [
+        "9876:issue:1",
+        "9876:issue:2",
+    ]
+    assert "Do not implement code" in submit.call_args_list[0].kwargs["prompt"]
+    assert "GITHUB_PERSONAL_ACCESS_TOKEN" in submit.call_args_list[0].kwargs["prompt"]
+
+
+def test_triage_continues_after_one_submission_fails(tmp_path, monkeypatch):
+    issues = [
+        {"number": 1, "title": "First", "body": "A", "labels": []},
+        {"number": 2, "title": "Second", "body": "B", "labels": []},
+    ]
+    _module, run = _triage(tmp_path, monkeypatch, issues)
+    submit = Mock(
+        side_effect=[
+            RuntimeError("unavailable"),
+            {"disposition": "created", "conversation_id": "second"},
+        ]
+    )
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    assert [call.kwargs["subject"] for call in submit.call_args_list] == [
+        "9876:issue:1",
+        "9876:issue:2",
+    ]
+
+
+def test_triage_skips_ready_blocked_and_unchanged_issues(tmp_path, monkeypatch):
+    issues = [
+        {
+            "number": 1,
+            "title": "Ready",
+            "body": "",
+            "labels": [{"name": "ready-for-dev"}],
+        },
+        {"number": 2, "title": "Blocked", "body": "", "labels": []},
+        {"number": 3, "title": "Unchanged", "body": "", "labels": []},
+    ]
+    module, run = _triage(tmp_path, monkeypatch, issues)
+    run.dependencies_complete = lambda issue: issue["number"] != 2
+    marker = module.hashlib.sha256(
+        module.json.dumps(["Unchanged", "", []], sort_keys=True).encode()
+    ).hexdigest()
+    run.gh_pages = lambda path: [{"id": 10, "body": f"<!-- triage-source:{marker} -->"}]
+    submit = Mock()
+    run.dispatcher.deliver = submit
+
+    run.run()
+
+    submit.assert_not_called()

package/tests/test_github_watchdog_delivery.py

@@ -0,0 +1,233 @@
+"""Contract tests for independent watchdog delivery."""
+
+import json
+import subprocess
+import sys
+from urllib.error import HTTPError
+
+import pytest
+from github_automation_helpers import ROOT, worker
+from openhands.sdk.skills import install_skill
+
+
+def test_installed_watchdog_skill_imports_worker(tmp_path):
+    name = "github-delivery-watchdog"
+    install_skill(source=str(ROOT / "skills" / name), installed_dir=tmp_path)
+    result = subprocess.run(
+        [sys.executable, "-c", "import worker"],
+        cwd=tmp_path / name / "scripts",
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    assert result.returncode == 0, result.stderr
+
+
+@pytest.mark.parametrize(
+    "changes",
+    [
+        {"head": {"sha": "b" * 40, "ref": "openhands/issue-1"}},
+        {"draft": True},
+        {"mergeable": None},
+        {"state": "closed"},
+        {"base": {"sha": "c" * 40, "ref": "release"}},
+    ],
+)
+def test_watchdog_rejects_ineligible_pr_before_merge(tmp_path, monkeypatch, changes):
+    cls = worker("github-delivery-watchdog", tmp_path, monkeypatch).DeliveryWatchdog
+    run = object.__new__(cls)
+    run.config = {"base_branch": "main"}
+    pr = {
+        "state": "open",
+        "draft": False,
+        "mergeable": True,
+        "head": {"sha": "a" * 40, "ref": "openhands/issue-1"},
+        "base": {"ref": "main", "sha": "c" * 40},
+        **changes,
+    }
+    calls = []
+    run.gh = lambda *args: calls.append(args) or pr
+    assert run.merge(1, "a" * 40) is None
+    assert calls == [("GET", "/pulls/1")]
+
+
+@pytest.mark.parametrize("base_branch", ["main", "release"])
+@pytest.mark.parametrize(
+    "review,ci,comparison,merged",
+    [
+        ("success", True, "ahead", True),
+        ("failure", True, "ahead", False),
+        ("success", False, "ahead", False),
+        ("success", True, "behind", False),
+    ],
+)
+def test_watchdog_requires_exact_acceptance_ci_and_current_base(
+    tmp_path, monkeypatch, review, ci, comparison, merged, base_branch
+):
+    cls = worker("github-delivery-watchdog", tmp_path, monkeypatch).DeliveryWatchdog
+    run = object.__new__(cls)
+    run.config = {}
+    sha = "a" * 40
+    calls = []
+
+    def gh(method, path, body=None):
+        calls.append((method, path, body))
+        if path == "":
+            return {"default_branch": base_branch}
+        if path == "/pulls/1":
+            return {
+                "state": "open",
+                "draft": False,
+                "mergeable": True,
+                "head": {"sha": sha, "ref": "openhands/issue-1"},
+                "base": {"ref": base_branch, "sha": "c" * 40},
+            }
+        if "/compare/" in path:
+            return {"status": comparison}
+        return {"merged": True}
+
+    run.gh = gh
+    run.statuses = lambda sha: {
+        "software-factory/tests": "success",
+        "software-factory/review": review,
+    }
+    run.ci_passed = lambda sha: ci
+    assert bool(run.merge(1, sha)) is merged
+    if merged:
+        assert calls[-1] == (
+            "PUT",
+            "/pulls/1/merge",
+            {"sha": sha, "merge_method": "squash"},
+        )
+    else:
+        assert not any(c[0] == "PUT" for c in calls)
+
+
+def test_watchdog_updates_accepted_branch_for_fresh_review(tmp_path, monkeypatch):
+    cls = worker("github-delivery-watchdog", tmp_path, monkeypatch).DeliveryWatchdog
+    run = object.__new__(cls)
+    run.config = {}
+    sha = "a" * 40
+    calls = []
+
+    def gh(method, path, body=None):
+        calls.append((method, path, body))
+        if path == "":
+            return {"default_branch": "main"}
+        if path == "/pulls/1":
+            return {
+                "state": "open",
+                "draft": False,
+                "mergeable": True,
+                "head": {"sha": sha, "ref": "openhands/issue-1"},
+                "base": {"ref": "main", "sha": "c" * 40},
+            }
+        if "/compare/" in path:
+            return {"status": "diverged", "behind_by": 1}
+        return {"message": "Updating pull request branch."}
+
+    run.gh = gh
+    run.statuses = lambda sha: {
+        "software-factory/tests": "success",
+        "software-factory/review": "success",
+    }
+    run.ci_passed = lambda sha: True
+
+    assert run.merge(1, sha) == {"message": "Updating pull request branch."}
+    assert calls[-2:] == [
+        ("POST", "/issues/1/labels", {"labels": ["openhands-review"]}),
+        ("PUT", "/pulls/1/update-branch", {"expected_head_sha": sha}),
+    ]
+
+
+@pytest.mark.parametrize(
+    "error",
+    [
+        HTTPError("https://api.github.com", 409, "Conflict", {}, None),
+        TimeoutError("GitHub unavailable"),
+        json.JSONDecodeError("Invalid response", "", 0),
+        KeyError("head"),
+    ],
+)
+def test_watchdog_continues_after_a_pr_api_failure(tmp_path, monkeypatch, error):
+    module = worker("github-delivery-watchdog", tmp_path, monkeypatch)
+    run = object.__new__(module.DeliveryWatchdog)
+    run.gh_pages = lambda path: [
+        {"number": 1, "head": {"sha": "a"}},
+        {"number": 2, "head": {"sha": "b"}},
+    ]
+    visited = []
+
+    def merge(number, sha):
+        visited.append(number)
+        if number == 1:
+            raise error
+        return {"merged": True}
+
+    run.merge = merge
+    run.run()
+    assert visited == [1, 2]
+
+
+@pytest.mark.parametrize("required,expected", [([], True), ([123], False)])
+def test_actions_are_optional_but_configured_workflows_are_required(
+    tmp_path, monkeypatch, required, expected
+):
+    module = worker("github-delivery-watchdog", tmp_path, monkeypatch)
+    run = object.__new__(module.DeliveryWatchdog)
+    run.config = {"required_workflow_ids": required}
+    run.gh = lambda *args: {"workflow_runs": [], "total_count": 0}
+    assert run.ci_passed("a" * 40) is expected
+
+
+@pytest.mark.parametrize(
+    "changes,expected",
+    [
+        ({}, True),
+        ({"conclusion": "failure"}, False),
+        ({"status": "in_progress"}, False),
+        ({"workflow_id": 2}, False),
+        ({"event": "push"}, False),
+        ({"head_branch": "other-branch"}, False),
+        ({"head_sha": "other-commit"}, False),
+    ],
+)
+def test_new_actions_execution_supersedes_only_its_own_trigger(
+    tmp_path, monkeypatch, changes, expected
+):
+    module = worker("github-delivery-watchdog", tmp_path, monkeypatch)
+    run = object.__new__(module.DeliveryWatchdog)
+    run.config = {"required_workflow_ids": [1]}
+    old = {
+        "id": 10,
+        "run_number": 1,
+        "workflow_id": 1,
+        "head_sha": "sha",
+        "event": "pull_request",
+        "head_branch": "feature",
+        "status": "completed",
+        "conclusion": "failure",
+    }
+    new = {**old, "id": 11, "run_number": 2, "conclusion": "success", **changes}
+    # Deliberately unsorted: correctness must not depend on API response order.
+    run.gh = lambda *args: {"workflow_runs": [old, new], "total_count": 2}
+    assert run.ci_passed("sha") is expected
+
+
+def test_native_actions_rerun_keeps_its_run_identity(tmp_path, monkeypatch):
+    module = worker("github-delivery-watchdog", tmp_path, monkeypatch)
+    run = object.__new__(module.DeliveryWatchdog)
+    run.config = {"required_workflow_ids": [1]}
+    result = {
+        "id": 10,
+        "run_number": 1,
+        "run_attempt": 2,
+        "workflow_id": 1,
+        "head_sha": "sha",
+        "event": "pull_request",
+        "head_branch": "feature",
+        "status": "completed",
+        "conclusion": "success",
+    }
+    run.gh = lambda *args: {"workflow_runs": [result], "total_count": 1}
+    assert run.ci_passed("sha")