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 domain
import (
"testing"
"time"
)
func TestClassifyMRDeliveryState(t *testing.T) {
t.Parallel()
cases := []struct {
name, state, target, def, integrate, want string
}{
{name: "mainline master", state: "merged", target: "master", def: "master", want: "merged"},
{name: "mainline origin prefix", state: "merged", target: "origin/master", def: "master", want: "merged"},
{name: "release default", state: "merged", target: "release/2.0", def: "release/2.0", want: "merged"},
{name: "integrate baseline", state: "merged", target: "agentflow/integration", def: "master", integrate: "agentflow/integration", want: "integrated"},
{name: "other side branch", state: "merged", target: "feature/x", def: "master", want: "integrated"},
{name: "merged no target", state: "merged", target: "", def: "master", want: "unknown"},
{name: "opened to main", state: "opened", target: "master", def: "master", want: "opened"},
{name: "closed to integrate", state: "closed", target: "agentflow/integration", def: "master", want: "closed"},
{name: "empty state", state: "", target: "master", def: "master", want: "unknown"},
{name: "unknown default accepts main", state: "merged", target: "main", def: "", want: "merged"},
{name: "unknown default accepts master", state: "merged", target: "master", def: "", want: "merged"},
{name: "unknown default rejects integrate", state: "merged", target: "agentflow/integration", def: "", want: "integrated"},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
got := ClassifyMRDeliveryState(tc.state, tc.target, tc.def, tc.integrate)
if got != tc.want {
t.Fatalf("ClassifyMRDeliveryState(%q,%q,%q) = %q, want %q", tc.state, tc.target, tc.def, got, tc.want)
}
})
}
}
func TestFinalizeAnalyticsDeliveryRequiresMainline(t *testing.T) {
t.Parallel()
merged := AnalyticsDelivery{SOPSucceeded: true, MRURL: "http://x", MRState: "merged"}
FinalizeAnalyticsDelivery(&merged)
if !merged.Delivered {
t.Fatal("mainline merged + SOP success must be delivered")
}
integrated := AnalyticsDelivery{SOPSucceeded: true, MRURL: "http://x", MRState: "integrated"}
FinalizeAnalyticsDelivery(&integrated)
if integrated.Delivered {
t.Fatal("baseline merge must not count as delivered")
}
}
func TestEffectiveAnalyticsMRStatePromotesIntegrated(t *testing.T) {
t.Parallel()
if got := EffectiveAnalyticsMRState("integrated", "merged"); got != "merged" {
t.Fatalf("promoted integrated = %q", got)
}
if got := EffectiveAnalyticsMRState("integrated", "integrated"); got != "integrated" {
t.Fatalf("unpromoted integrated = %q", got)
}
if got := EffectiveAnalyticsMRState("opened", "merged"); got != "opened" {
t.Fatalf("opened must not inherit old mainline label = %q", got)
}
}
func TestKeepMainlineDeliveryLabel(t *testing.T) {
t.Parallel()
if !KeepMainlineDeliveryLabel("merged", "integrated") {
t.Fatal("must keep mainline after work MR still targets baseline")
}
if !KeepMainlineDeliveryLabel("merged", "unknown") {
t.Fatal("must keep mainline while target_branch is still syncing")
}
if KeepMainlineDeliveryLabel("merged", "closed") {
t.Fatal("closed work MR should be allowed to replace mainline")
}
if KeepMainlineDeliveryLabel("integrated", "merged") {
t.Fatal("must not block an upgrade to mainline")
}
}
func TestBranchListed(t *testing.T) {
t.Parallel()
refs := []string{"agentflow/integration", "feature/fix-issue-77", "origin/master"}
if !BranchListed(refs, "master") {
t.Fatal("origin/master should count as master")
}
if BranchListed(refs, "release") {
t.Fatal("unrelated branch should not match")
}
}
func TestWorkLandedWithPromote(t *testing.T) {
t.Parallel()
promote := time.Date(2026, 9, 4, 8, 0, 0, 0, time.UTC)
if !WorkLandedWithPromote(promote.Add(-time.Hour), promote) {
t.Fatal("work merged before promote must land")
}
if WorkLandedWithPromote(promote.Add(time.Hour), promote) {
t.Fatal("work merged after promote must stay on baseline")
}
if !WorkLandedWithPromote(time.Time{}, promote) {
t.Fatal("missing work time must not block promote")
}
}
func TestSummarizeDeliveriesSplitsMainlineAndBaseline(t *testing.T) {
t.Parallel()
sum := SummarizeDeliveries([]AnalyticsDelivery{
{SOPSucceeded: true, MRURL: "a", MRState: "merged", Delivered: true},
{SOPSucceeded: true, MRURL: "b", MRState: "integrated", Delivered: false},
})
if sum.MRMerged != 1 || sum.MRIntegrated != 1 || sum.Delivered != 1 {
t.Fatalf("summary=%+v", sum)
}
}
func TestSummarizeDeliveriesCountsMRsSeparatelyFromIssues(t *testing.T) {
a := DeliveryMR{Project: "team/frontend", IID: 1, URL: GongfengMRURL("team/frontend", 1), State: "merged"}
b := DeliveryMR{Project: "team/backend", IID: 1, URL: GongfengMRURL("team/backend", 1), State: "merged"}
alias := a
alias.URL = "http://git.example.com/team/frontend/merge_requests/1"
item := AnalyticsDelivery{IssueID: "one", SOPSucceeded: true, MRURL: a.URL, MRState: "merged", MRs: []DeliveryMR{a, alias, b}, Tokens: 100, CostUSD: .5}
sum := SummarizeDeliveries([]AnalyticsDelivery{item})
if sum.TotalMRs != 2 || sum.MRMerged != 2 || sum.WithMR != 1 || sum.IssuesWithMergedMR != 1 || sum.Issues != 1 || sum.TotalTokens != 100 || sum.TotalCostUSD != .5 {
t.Fatalf("two repositories must count as two MRs but one requirement: %+v", sum)
}
// Repeated references from another delivery row still count the actual MR once.
sum = SummarizeDeliveries([]AnalyticsDelivery{item, {IssueID: "two", MRs: []DeliveryMR{alias}}})
if sum.TotalMRs != 2 || sum.MRMerged != 2 {
t.Fatalf("duplicate MR counted twice: %+v", sum)
}
}