Self-hosted workflows for coding-agent delivery. Orchestrate CodeBuddy, Codex and Claude Code with scripts and human approval gates. Includes Local workflows for coding assistants.
JavaScript agent-orchestrationagentic-workflowai-agentsai-codingclaude-codecode-reviewcodebuddycodexcoding-agentscursordeveloper-toolshuman-on-the-loopllmmcpmulti-agentsdlcself-hostedsopworkflow-automationworkflow-engine
package repo
import (
"testing"
"time"
"agentflow/internal/domain"
)
func TestRunMRTextPrefersMRBodyOverPatch(t *testing.T) {
text := runMRText(domain.Run{Artifacts: []domain.Artifact{
{Name: "repository-patch", NodeID: "mr", Content: "-https://git.example.com/org/repo/merge_requests/282\n+https://git.example.com/org/repo/merge_requests/286"},
{Name: "mr-body", NodeID: "mr", Content: "https://git.example.com/org/repo/-/merge_requests/286"},
{Name: "closeout", NodeID: "close", Content: "https://git.example.com/org/repo/merge_requests/286"},
}})
refs := domain.ParseGongfengMRs(text)
if len(refs) != 1 || refs[0].IID != 286 {
t.Fatalf("expected only !286 from mr-body, got %+v text=%q", refs, text)
}
}
func TestBetterAnalyticsMRPrefersIssueDelivery(t *testing.T) {
older := mrRef{project: "org/repo", iid: 282, createdAt: time.Now().UTC(), sourceRank: 10}
own := mrRef{project: "org/repo", iid: 286, createdAt: time.Now().UTC().Add(-time.Hour), sourceRank: 10}
if !betterAnalyticsMR("org/repo", 286, older, "integrated", own, "integrated") {
t.Fatal("issue delivery MR should win when both are on the baseline")
}
if betterAnalyticsMR("org/repo", 286, own, "integrated", older, "integrated") {
t.Fatal("should not replace the preferred delivery MR")
}
}
func TestApplyMRDeliveryStatesMemoryStore(t *testing.T) {
s, err := OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { s.Close() })
items := []domain.AnalyticsDelivery{{
IssueID: "gf-1", MRProject: "org/repo", MRIID: 9,
MRURL: "https://git.example.com/org/repo/merge_requests/9",
MRState: "unknown", SOPSucceeded: true,
}}
issue, _ := s.Issue("gf-1")
s.applyMRDeliveryStates(items, map[string][]mrRef{
"gf-1": {{project: "org/repo", iid: 9, url: "https://git.example.com/org/repo/merge_requests/9"}},
}, map[string]domain.Issue{"gf-1": issue})
if items[0].MRState != "unknown" || items[0].Delivered {
t.Fatalf("memory store keeps unknown without db: %#v", items[0])
}
}
func TestMarkAndReopenDeliveredIssue(t *testing.T) {
s, err := OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(s.Close)
issue := domain.Issue{ID: "tapd-1", ProjectID: "platform", Source: "tapd", Status: "in_review", AutomationState: "eligible"}
if err := s.PutIssue(issue); err != nil {
t.Fatal(err)
}
mergedAt := time.Now().UTC().Add(-time.Minute)
if err := s.MarkIssueDelivered(issue.ID, "https://git.example.com/org/repo/merge_requests/1", mergedAt); err != nil {
t.Fatal(err)
}
locked, _ := s.Issue(issue.ID)
if !locked.DeliveryLocked() || locked.Status != "done" || locked.AutomationState != "ignored" {
t.Fatalf("merged issue not locked: %+v", locked)
}
reopened, err := s.ReopenDeliveredIssue(issue.ID)
if err != nil {
t.Fatal(err)
}
if reopened.DeliveryState != "reopened" || reopened.Status != "todo" || reopened.AutomationState != "eligible" {
t.Fatalf("issue not reopened: %+v", reopened)
}
if err := s.MarkIssueDelivered(issue.ID, locked.DeliveryMRURL, mergedAt); err != nil {
t.Fatal(err)
}
stillOpen, _ := s.Issue(issue.ID)
if stillOpen.DeliveryState != "reopened" {
t.Fatalf("old merged MR relocked reopened issue: %+v", stillOpen)
}
if err := s.MarkIssueDelivered(issue.ID, locked.DeliveryMRURL, time.Now().UTC().Add(time.Minute)); err != nil {
t.Fatal(err)
}
stillOpen, _ = s.Issue(issue.ID)
if stillOpen.DeliveryState != "reopened" {
t.Fatalf("newer MR check must not relock a reopened issue: %+v", stillOpen)
}
if err := s.MarkIssueDeliveredFromSOP(issue.ID, "https://git.example.com/org/repo/merge_requests/2", time.Now().UTC().Add(2*time.Minute)); err != nil {
t.Fatal(err)
}
lockedAgain, _ := s.Issue(issue.ID)
if !lockedAgain.DeliveryLocked() {
t.Fatalf("new SOP success should lock a reopened issue: %+v", lockedAgain)
}
}
func TestExternalClosedIssueKeepsStatusDuringDelivery(t *testing.T) {
s, err := OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(s.Close)
issue := domain.Issue{
ID: "gf-closed", ProjectID: "platform", Source: "gongfeng",
Status: "closed", CloseSource: "external",
ExternalRef: &domain.ExternalRef{Source: "gongfeng", ExternalState: "closed"},
}
if err := s.PutIssue(issue); err != nil {
t.Fatal(err)
}
if err := s.MarkIssueDelivered(issue.ID, "https://git.example.com/org/repo/merge_requests/1", time.Now().UTC()); err != nil {
t.Fatal(err)
}
got, _ := s.Issue(issue.ID)
if got.Status != "closed" || got.CloseSource != "external" || !got.DeliveryLocked() {
t.Fatalf("MR delivery must not turn external closure into done: %+v", got)
}
if _, err := s.ReopenDeliveredIssue(issue.ID); err == nil {
t.Fatal("externally closed issue must be reopened in its tracker first")
}
}
func TestReconcileCompletedDeliveries(t *testing.T) {
s, err := OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(s.Close)
issue := domain.Issue{ID: "tapd-done", ProjectID: "platform", Source: "tapd", LatestTaskID: "task-1"}
if err := s.PutIssue(issue); err != nil {
t.Fatal(err)
}
if err := s.PutTask(domain.Task{ID: "task-1", IssueID: issue.ID, RunID: "run-1", Status: "completed"}); err != nil {
t.Fatal(err)
}
if err := s.PutRun(domain.Run{ID: "run-1", Status: "succeeded", UpdatedAt: time.Now().UTC(), ExecutionContext: domain.TelemetryContext{IssueID: issue.ID}}); err != nil {
t.Fatal(err)
}
if err := s.ReconcileCompletedDeliveries(); err != nil {
t.Fatal(err)
}
locked, _ := s.Issue(issue.ID)
if !locked.DeliveryLocked() {
t.Fatalf("expected succeeded SOP to lock issue: %+v", locked)
}
}
func TestClassifyMRDeliveryUsesRepoBranches(t *testing.T) {
s, err := OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(s.Close)
if err := s.PutRepository(domain.Repository{
ID: "repo-skillhub", ProjectID: "platform", Name: "skillhub",
GongfengProjectID: "example/team-project",
DefaultBranch: "master",
IntegrateBranch: "agentflow/integration",
}); err != nil {
t.Fatal(err)
}
baseline := s.classifyMRDelivery(domain.MRDeliveryState{
MRProject: "example/team-project", State: "merged", TargetBranch: "agentflow/integration",
})
if baseline != "integrated" {
t.Fatalf("baseline merge classified as %q", baseline)
}
mainline := s.classifyMRDelivery(domain.MRDeliveryState{
MRProject: "example/team-project", State: "merged", TargetBranch: "master",
})
if mainline != "merged" {
t.Fatalf("mainline merge classified as %q", mainline)
}
pending := s.classifyMRDelivery(domain.MRDeliveryState{
MRProject: "example/team-project", State: "merged", TargetBranch: "",
})
if pending != "unknown" {
t.Fatalf("merged without target classified as %q", pending)
}
}
func TestPromoteIssueToMainlineKeepsWorkMR(t *testing.T) {
s, err := OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(s.Close)
issue := domain.Issue{
ID: "gf-skillhub-32", ProjectID: "platform", Source: "gongfeng",
Status: "done", DeliveryState: "merged", DeliveryMRState: "integrated",
DeliveryMRURL: "https://git.example.com/example/team-project/merge_requests/293",
DeliveryUpdatedAt: time.Now().UTC().Add(-time.Hour),
}
if err := s.PutIssue(issue); err != nil {
t.Fatal(err)
}
at := time.Now().UTC()
if err := s.PromoteIssueToMainline(issue.ID, issue.DeliveryMRURL, at); err != nil {
t.Fatal(err)
}
got, _ := s.Issue(issue.ID)
if got.DeliveryMRState != "merged" {
t.Fatalf("expected mainline label, got %+v", got)
}
if got.DeliveryMRURL != issue.DeliveryMRURL {
t.Fatalf("work MR URL changed: %s", got.DeliveryMRURL)
}
if err := s.ReconcileDeliveryMRStates(); err != nil {
t.Fatal(err)
}
still, _ := s.Issue(issue.ID)
if still.DeliveryMRState != "merged" {
t.Fatalf("reconcile downgraded mainline label: %+v", still)
}
}
func TestPromoteSkipsWorkAfterPromote(t *testing.T) {
s, err := OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(s.Close)
promoteAt := time.Now().UTC().Add(-time.Hour)
old := domain.Issue{
ID: "gf-old", ProjectID: "platform",
DeliveryState: "merged", DeliveryMRState: "integrated",
DeliveryMRURL: "https://git.example.com/org/repo/merge_requests/10",
DeliveryUpdatedAt: promoteAt.Add(-time.Hour),
}
newer := domain.Issue{
ID: "gf-new", ProjectID: "platform",
DeliveryState: "merged", DeliveryMRState: "integrated",
DeliveryMRURL: "https://git.example.com/org/repo/merge_requests/20",
DeliveryUpdatedAt: promoteAt.Add(time.Hour),
}
if err := s.PutIssue(old); err != nil {
t.Fatal(err)
}
if err := s.PutIssue(newer); err != nil {
t.Fatal(err)
}
if err := s.promoteIntegratedIssues("org/repo", promoteAt); err != nil {
t.Fatal(err)
}
gotOld, _ := s.Issue(old.ID)
gotNew, _ := s.Issue(newer.ID)
if gotOld.DeliveryMRState != "merged" {
t.Fatalf("older baseline MR should promote: %+v", gotOld)
}
if gotNew.DeliveryMRState != "integrated" {
t.Fatalf("newer baseline MR must stay integrated: %+v", gotNew)
}
}
func TestApplyDefaultBranchLandingUsesCommitNotTime(t *testing.T) {
s, err := OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(s.Close)
missing := "https://git.example.com/example/team-project/merge_requests/463"
missingIssue := domain.Issue{
ID: "gf-skillhub-77", ProjectID: "platform", Status: "done",
DeliveryState: "merged", DeliveryMRState: "merged", DeliveryMRURL: missing,
}
present := "https://git.example.com/example/team-project/merge_requests/457"
presentIssue := domain.Issue{
ID: "gf-skillhub-76", ProjectID: "platform", Status: "done",
DeliveryState: "merged", DeliveryMRState: "integrated", DeliveryMRURL: present,
}
for _, issue := range []domain.Issue{missingIssue, presentIssue} {
if err := s.PutIssue(issue); err != nil {
t.Fatal(err)
}
}
if err := s.ApplyDefaultBranchLanding(missingIssue.ID, missing, false); err != nil {
t.Fatal(err)
}
if err := s.ApplyDefaultBranchLanding(presentIssue.ID, present, true); err != nil {
t.Fatal(err)
}
gotMissing, _ := s.Issue(missingIssue.ID)
if gotMissing.DeliveryMRState != "integrated" || gotMissing.DeliveryMRURL != missing {
t.Fatalf("commit absent from master should be baseline: %+v", gotMissing)
}
gotPresent, _ := s.Issue(presentIssue.ID)
if gotPresent.DeliveryMRState != "merged" || gotPresent.DeliveryMRURL != present {
t.Fatalf("commit on master should be mainline: %+v", gotPresent)
}
}
func TestApplyMRDeliveryStatesHonorsPromotedIssue(t *testing.T) {
s, err := OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(s.Close)
if err := s.PutIssue(domain.Issue{
ID: "gf-1", DeliveryState: "merged", DeliveryMRState: "merged",
DeliveryMRURL: "https://git.example.com/org/repo/merge_requests/9",
}); err != nil {
t.Fatal(err)
}
items := []domain.AnalyticsDelivery{{
IssueID: "gf-1", MRProject: "org/repo", MRIID: 9,
MRURL: "https://git.example.com/org/repo/merge_requests/9",
MRState: "integrated", SOPSucceeded: true,
}}
issue, _ := s.Issue("gf-1")
s.applyMRDeliveryStates(items, map[string][]mrRef{
"gf-1": {{project: "org/repo", iid: 9, url: items[0].MRURL}},
}, map[string]domain.Issue{"gf-1": issue})
if items[0].MRState != "merged" || !items[0].Delivered {
t.Fatalf("promoted issue should count as delivered: %#v", items[0])
}
}
func TestFinalizeAnalyticsDeliveryMerged(t *testing.T) {
item := domain.AnalyticsDelivery{SOPSucceeded: true, MRURL: "http://x", MRState: "merged"}
domain.FinalizeAnalyticsDelivery(&item)
if !item.Delivered {
t.Fatal("expected delivered")
}
}
func TestStaleOpenedMRDoesNotOverwriteCanonicalDelivery(t *testing.T) {
s, err := OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(s.Close)
canonical := "https://git.example.com/example/team-project/merge_requests/248"
stale := "https://git.example.com/example/team-project/merge_requests/183"
issue := domain.Issue{
ID: "gf-19", ProjectID: "skillhub", Source: "gongfeng",
Status: "done", DeliveryState: "merged", DeliveryMRState: "merged",
DeliveryMRURL: canonical,
DeliveryUpdatedAt: time.Now().UTC().Add(-time.Hour),
}
if err := s.PutIssue(issue); err != nil {
t.Fatal(err)
}
if err := s.EnsureMRDeliveryState("example/team-project", 248, canonical, issue.ID); err != nil {
t.Fatal(err)
}
if err := s.UpdateMRDeliveryState("example/team-project", 248, "merged", "master", time.Time{}, time.Now().UTC().Add(-time.Hour)); err != nil {
t.Fatal(err)
}
if err := s.EnsureMRDeliveryState("example/team-project", 183, stale, issue.ID); err != nil {
t.Fatal(err)
}
if err := s.UpdateMRDeliveryState("example/team-project", 183, "opened", "master", time.Time{}, time.Now().UTC()); err != nil {
t.Fatal(err)
}
got, _ := s.Issue(issue.ID)
if got.DeliveryMRURL != canonical {
t.Fatalf("canonical MR URL changed: %s", got.DeliveryMRURL)
}
if got.DeliveryMRState != "merged" {
t.Fatalf("stale opened MR overwrote delivery label: %+v", got)
}
}
func TestCanonicalMRPollStillUpdatesDeliveryLabel(t *testing.T) {
s, err := OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(s.Close)
canonical := "https://git.example.com/org/repo/-/merge_requests/9"
issue := domain.Issue{
ID: "gf-1", Status: "done", DeliveryState: "merged", DeliveryMRState: "opened",
DeliveryMRURL: "https://git.example.com/org/repo/merge_requests/9",
DeliveryUpdatedAt: time.Now().UTC().Add(-time.Hour),
}
if err := s.PutIssue(issue); err != nil {
t.Fatal(err)
}
if err := s.EnsureMRDeliveryState("org/repo", 9, canonical, issue.ID); err != nil {
t.Fatal(err)
}
if err := s.UpdateMRDeliveryState("org/repo", 9, "merged", "master", time.Time{}, time.Now().UTC()); err != nil {
t.Fatal(err)
}
got, _ := s.Issue(issue.ID)
if got.DeliveryMRState != "merged" {
t.Fatalf("canonical merged poll should set MR 已合入, got %+v", got)
}
}
func TestMultiRepositoryDeliveryMRs(t *testing.T) {
s, err := OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(s.Close)
issue := domain.Issue{ID: "tapd-multi", ProjectID: "platform", Source: "tapd", Status: "in_review"}
if err := s.PutIssue(issue); err != nil {
t.Fatal(err)
}
urlA := "https://git.example.com/org/a/-/merge_requests/1"
urlB := "https://git.example.com/org/b/-/merge_requests/2"
at := time.Now().UTC().Add(-time.Hour)
if err := s.MarkIssueDeliveredFromSOPMRs(issue.ID, []domain.DeliveryMR{
{RepositoryID: "a", Repository: "a", Project: "org/a", IID: 1, URL: urlA, GongfengState: "merged", TargetBranch: "master"},
{RepositoryID: "b", Repository: "b", Project: "org/b", IID: 2, URL: urlB, GongfengState: "opened", TargetBranch: "master"},
}, at); err != nil {
t.Fatal(err)
}
got, _ := s.Issue(issue.ID)
if !got.DeliveryLocked() || len(got.DeliveryMRs) != 2 || got.DeliveryMRURL != urlA || got.DeliveryMRState != "opened" {
t.Fatalf("multi-repo delivery not recorded: %+v", got)
}
if got.DeliveryMRs[0].State != "merged" || got.DeliveryMRs[1].State != "opened" || got.DeliveryLockedLabel() != "交付闭环" {
t.Fatalf("per-MR states / label wrong: %+v label=%s", got.DeliveryMRs, got.DeliveryLockedLabel())
}
// Both MRs are registered for polling; the second merge lands the item.
if err := s.UpdateMRDeliveryState("org/b", 2, "merged", "master", time.Time{}, time.Now().UTC()); err != nil {
t.Fatal(err)
}
got, _ = s.Issue(issue.ID)
if got.DeliveryMRState != "merged" || got.DeliveryLockedLabel() != "MR 已合入" || got.DeliveryMRURL != urlA {
t.Fatalf("all MRs merged must read MR 已合入: %+v", got)
}
// A leftover MR from an earlier run must not join or relabel the item.
if err := s.EnsureMRDeliveryState("org/a", 9, "https://git.example.com/org/a/-/merge_requests/9", issue.ID); err != nil {
t.Fatal(err)
}
if err := s.UpdateMRDeliveryState("org/a", 9, "closed", "master", time.Time{}, time.Now().UTC()); err != nil {
t.Fatal(err)
}
got, _ = s.Issue(issue.ID)
if len(got.DeliveryMRs) != 2 || got.DeliveryMRState != "merged" {
t.Fatalf("leftover MR changed delivery MRs: %+v", got)
}
}
func TestReconcileDeliveryMRStatesRecoversHTTPArtifactLink(t *testing.T) {
s, err := OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(s.Close)
issue := domain.Issue{
ID: "tapd-http-mr", ProjectID: "privatedns", Status: "done",
DeliveryState: "merged", LatestTaskID: "task-http",
DeliveryUpdatedAt: time.Now().UTC().Add(-time.Hour),
}
if err := s.PutIssue(issue); err != nil {
t.Fatal(err)
}
if err := s.PutTask(domain.Task{ID: "task-http", IssueID: issue.ID, RunID: "run-http", Status: "completed"}); err != nil {
t.Fatal(err)
}
run := domain.Run{
ID: "run-http", Status: "succeeded", UpdatedAt: time.Now().UTC(),
ExecutionContext: domain.TelemetryContext{IssueID: issue.ID},
Repositories: []domain.RepositoryContext{{
RepositoryID: "demodns", Name: "dns-service", GongfengProjectID: "example/dns/dns-service",
WorkBranch: "feature/story-1",
}},
Artifacts: []domain.Artifact{{
NodeID: "mr", Name: "mr-body",
Content: "http://git.example.com/example/dns/dns-service/merge_requests/558",
}},
}
if err := s.PutRun(run); err != nil {
t.Fatal(err)
}
if err := s.ReconcileUnlinkedDeliveryMRs(); err != nil {
t.Fatal(err)
}
got, _ := s.Issue(issue.ID)
want := "https://git.example.com/example/dns/dns-service/-/merge_requests/558"
if len(got.DeliveryMRs) != 1 || got.DeliveryMRURL != want || got.DeliveryMRs[0].IID != 558 {
t.Fatalf("locked issue did not recover http MR: %+v", got)
}
if !got.DeliveryLocked() || got.Status != "done" {
t.Fatalf("recovery must keep the item delivered: %+v", got)
}
}
func TestReconcileDeliveryMRStatesMigratesLegacySingleMR(t *testing.T) {
s, err := OpenTest()
if err != nil {
t.Fatal(err)
}
t.Cleanup(s.Close)
url := "https://git.example.com/org/a/-/merge_requests/3"
issue := domain.Issue{ID: "tapd-legacy", ProjectID: "platform", Status: "done", DeliveryState: "merged", DeliveryMRURL: url, DeliveryMRState: "opened", DeliveryUpdatedAt: time.Now().UTC()}
if err := s.PutIssue(issue); err != nil {
t.Fatal(err)
}
if err := s.EnsureMRDeliveryState("org/a", 3, url, issue.ID); err != nil {
t.Fatal(err)
}
if err := s.recordMRState("org/a", 3, "merged", "master", time.Time{}, time.Now().UTC()); err != nil {
t.Fatal(err)
}
if err := s.ReconcileDeliveryMRStates(); err != nil {
t.Fatal(err)
}
got, _ := s.Issue(issue.ID)
if len(got.DeliveryMRs) != 1 || got.DeliveryMRs[0].URL != url || got.DeliveryMRState != "merged" {
t.Fatalf("legacy MR not migrated into deliveryMrs: %+v", got)
}
}