Review 8be2189163b0

#!/bin/sh
set -e
cat > internal/gate/zz_repro_samectx_test.go <<'EOF'
package gate

import (
    "context"
    "fmt"
    "path/filepath"
    "testing"
    "time"
)

type reproSameCtxLister struct{ prs []PRRef }

func (l reproSameCtxLister) ListOpenPRs(ctx context.Context, repoURL, base string) ([]PRRef, error) {
    return l.prs, nil
}

func TestReproTwoPoliciesOneRepoSharedDefaultContext(t *testing.T) {
    pols, bad := ParsePolicyEnv([]string{
        PolicyEnvPrefix + "LINT=repo=o/r,cmd=true",
        PolicyEnvPrefix + "TEST=repo=o/r,cmd=go test ./...",
    })
    if len(bad) != 0 || len(pols) != 2 {
        t.Fatalf("parser refused the pair (bad=%v n=%d): defect absent", bad, len(pols))
    }
    store, err := OpenStore(filepath.Join(t.TempDir(), "g.db"))
    if err != nil {
        t.Fatal(err)
    }
    defer store.Close()
    ran := map[string]int{}
    p := &Poller{
        Policies: pols,
        List:     reproSameCtxLister{prs: []PRRef{{Number: 1, HeadSHA: "abc", Base: "main"}}},
        Store:    store,
        Run: func(ctx context.Context, repoURL string, pol Policy, pr PRRef) error {
            ran[pol.CheckCmd]++
            return store.Save(Run{Repo: pol.Repo, HeadSHA: pr.HeadSHA, PR: pr.Number, Context: pol.Context, Passed: true, StatusPosted: true, RanAt: time.Unix(0, 0)})
        },
    }
    for i := 0; i < 3; i++ {
        _ = p.Tick(context.Background())
    }
    fmt.Printf("ParsePolicyEnv accepted 2 policies for o/r, both under context %q, bad=%v\n", pols[0].normalized().Context, bad)
    fmt.Printf("runs after 3 ticks: cmd 'true' = %d, cmd 'go test ./...' = %d (the second check never runs)\n", ran["true"], ran["go test ./..."])
    if ran["true"] != 1 || ran["go test ./..."] != 0 {
        t.Fatalf("both policies ran: defect absent")
    }
}
EOF
exec go test ./internal/gate -run TestReproTwoPoliciesOneRepoSharedDefaultContext -count=1 -v

=== RUN   TestReproTwoPoliciesOneRepoSharedDefaultContext
ParsePolicyEnv accepted 2 policies for o/r, both under context "corral/gate", bad=[]
runs after 3 ticks: cmd 'true' = 1, cmd 'go test ./...' = 0 (the second check never runs)
--- PASS: TestReproTwoPoliciesOneRepoSharedDefaultContext (0.03s)
PASS
ok  	github.com/pdbethke/corralai/internal/gate	0.031s

#!/bin/sh
set -e
cat > internal/gate/zz_repro_repost_test.go <<'EOF'
package gate

import (
    "context"
    "errors"
    "fmt"
    "path/filepath"
    "testing"
    "time"
)

type reproRLister struct{ prs []PRRef }

func (l reproRLister) ListOpenPRs(ctx context.Context, repoURL, base string) ([]PRRef, error) {
    return l.prs, nil
}

type reproRCheckout struct{}

func (reproRCheckout) CheckoutPR(ctx context.Context, repoURL string, pr int, sha, dest string) error {
    return nil
}

type reproRJail struct{ calls int }

func (j *reproRJail) Run(ctx context.Context, command, ws string, net bool, to time.Duration) (int, string, error) {
    j.calls++
    return 0, "ok", nil
}

type reproRCert struct{ calls int }

func (c *reproRCert) Certify(ctx context.Context, repo, commit, command string, exit int, digest string) (int64, string, error) {
    c.calls++
    return int64(c.calls), "head", nil
}

type reproRStatus struct{ posts int }

func (s *reproRStatus) SetCommitStatus(ctx context.Context, repoURL, sha, c, state, target, desc string) error {
    s.posts++
    return errors.New("403 Resource not accessible by integration")
}

func TestReproPermanentPostFailureRerunsJailAndRecertifiesEveryTick(t *testing.T) {
    store, err := OpenStore(filepath.Join(t.TempDir(), "g.db"))
    if err != nil {
        t.Fatal(err)
    }
    defer store.Close()
    jail := &reproRJail{}
    cert := &reproRCert{}
    status := &reproRStatus{}
    r := &Runner{Checkout: reproRCheckout{}, Jail: jail, Certify: cert, Status: status, Store: store,
        RecordURL: func(a, b string) string { return "http://x" }, Now: func() time.Time { return time.Unix(0, 0) }}
    p := &Poller{
        Policies: []Policy{{Repo: "o/r", CheckCmd: "true"}},
        List:     reproRLister{prs: []PRRef{{Number: 1, HeadSHA: "abc", Base: "main"}}},
        Store:    store,
        Run:      r.Run,
    }
    ticks := 3
    for i := 0; i < ticks; i++ {
        _ = p.Tick(context.Background())
    }
    fmt.Printf("after %d ticks with a status post that always fails: jail runs=%d, signed records appended=%d, status posts=%d\n", ticks, jail.calls, cert.calls, status.posts)
    fmt.Println("a 're-delivery' of an already computed and signed verdict should re-post once per tick and run the jail / certify exactly once")
    if jail.calls < ticks || cert.calls < ticks {
        t.Fatalf("jail/certify were not re-run per tick: defect absent")
    }
}
EOF
exec go test ./internal/gate -run TestReproPermanentPostFailureRerunsJailAndRecertifiesEveryTick -count=1 -v

=== RUN   TestReproPermanentPostFailureRerunsJailAndRecertifiesEveryTick
2026/09/15 09:11:35 gate: poller: run o/r#1@abc: 403 Resource not accessible by integration
2026/09/15 09:11:35 gate: poller: o/r@abc ctx corral/gate was gated but its status never posted — re-delivering
2026/09/15 09:11:35 gate: poller: run o/r#1@abc: 403 Resource not accessible by integration
2026/09/15 09:11:35 gate: poller: o/r@abc ctx corral/gate was gated but its status never posted — re-delivering
2026/09/15 09:11:35 gate: poller: run o/r#1@abc: 403 Resource not accessible by integration
after 3 ticks with a status post that always fails: jail runs=3, signed records appended=3, status posts=6
a 're-delivery' of an already computed and signed verdict should re-post once per tick and run the jail / certify exactly once
--- PASS: TestReproPermanentPostFailureRerunsJailAndRecertifiesEveryTick (0.03s)
PASS
ok  	github.com/pdbethke/corralai/internal/gate	0.039s

#!/bin/sh
set -e
cat > internal/gate/zz_repro_spacedcmd_test.go <<'EOF'
package gate

import (
    "fmt"
    "strings"
    "testing"
)

func TestReproSpaceBeforeCmdIsRefused(t *testing.T) {
    // Whitespace after the comma is accepted for every other field...
    if _, reason := ParsePolicy("repo=o/r, base=main,cmd=true"); reason != "" {
        t.Fatalf("spaced base= refused (%s): premise wrong", reason)
    }
    // ...and by the stray-field guard (", base=" after cmd= is detected)...
    if _, reason := ParsePolicy("repo=o/r,cmd=true, base=main"); !strings.Contains(reason, "after cmd=") {
        t.Fatalf("spaced stray field not detected (%q): premise wrong", reason)
    }
    // ...but not for cmd= itself.
    pol, reason := ParsePolicy("repo=o/r, cmd=true")
    fmt.Printf("ParsePolicy(%q) -> reason=%q policy=%+v\n", "repo=o/r, cmd=true", reason, pol)
    if !strings.Contains(reason, "no cmd=") {
        t.Fatalf("accepted or refused for another reason: defect absent")
    }
}
EOF
exec go test ./internal/gate -run TestReproSpaceBeforeCmdIsRefused -count=1 -v

=== RUN   TestReproSpaceBeforeCmdIsRefused
ParsePolicy("repo=o/r, cmd=true") -> reason="no cmd= (a policy with no command would report a result for a check that never ran)" policy={Repo: Base:[] Context: CheckCmd: AllowNet:false TimeoutS:0}
--- PASS: TestReproSpaceBeforeCmdIsRefused (0.00s)
PASS
ok  	github.com/pdbethke/corralai/internal/gate	0.005s