Monorepo for Tangled
Something went wrong. Try again.
Go
at commit-links
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334package webhook
import ( "context" "net/http" "net/http/httptest" "path/filepath" "testing" "time"
"github.com/bluesky-social/indigo/atproto/syntax" "tangled.org/core/appview/db" "tangled.org/core/appview/models")
func TestPullStateEvent(t *testing.T) { tests := []struct { name string state models.PullState wantEvent models.WebhookEvent wantAction string wantOk bool }{ {"merged", models.PullMerged, models.WebhookEventPullRequestMerged, "merged", true}, {"closed", models.PullClosed, models.WebhookEventPullRequestClosed, "closed", true}, {"reopened", models.PullOpen, models.WebhookEventPullRequestReopened, "reopened", true}, {"abandoned", models.PullAbandoned, "", "", false}, }
for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { event, action, ok := pullStateEvent(tt.state) if event != tt.wantEvent || action != tt.wantAction || ok != tt.wantOk { t.Errorf("pullStateEvent(%v) = (%q, %q, %v), want (%q, %q, %v)", tt.state, event, action, ok, tt.wantEvent, tt.wantAction, tt.wantOk) } }) }}
func TestBuildPullRequestPayload(t *testing.T) { const baseUrl = "https://tangled.org"
targetDid := syntax.DID("did:plc:target") forkDid := syntax.DID("did:plc:fork")
repo := &models.Repo{ Did: "did:plc:target", Name: "some-repo", Knot: "knot.example.com", Rkey: "some-repo", Created: time.Date(2025, 9, 15, 8, 57, 23, 0, time.UTC), }
basePull := func() models.Pull { return models.Pull{ PullId: 4, RepoDid: targetDid, OwnerDid: "did:plc:author", Title: "add dark mode", Body: "implements dark mode", TargetBranch: "main", State: models.PullOpen, Created: time.Date(2025, 9, 16, 10, 0, 0, 0, time.UTC), Submissions: []*models.PullSubmission{ {RoundNumber: 0, SourceRev: "aaaa000"}, {RoundNumber: 1, SourceRev: "bbbb111"}, }, } }
t.Run("patch based", func(t *testing.T) { pull := basePull() pull.PullSource = nil
payload := buildPullRequestPayload("created", repo, &pull, "did:plc:author", baseUrl)
if payload.Action != "created" { t.Errorf("action = %q, want %q", payload.Action, "created") } pr := payload.PullRequest if pr.Number != 4 { t.Errorf("number = %d, want 4", pr.Number) } if pr.State != "open" { t.Errorf("state = %q, want %q", pr.State, "open") } if pr.Source != nil { t.Errorf("source = %+v, want nil for patch-based pull", pr.Source) } if pr.RoundNumber != 1 { t.Errorf("round_number = %d, want 1", pr.RoundNumber) } wantHtmlUrl := "https://tangled.org/did:plc:target/some-repo/pulls/4" if pr.HtmlUrl != wantHtmlUrl { t.Errorf("html_url = %q, want %q", pr.HtmlUrl, wantHtmlUrl) } wantPatchUrl := wantHtmlUrl + "/round/1.patch" if pr.PatchUrl != wantPatchUrl { t.Errorf("patch_url = %q, want %q", pr.PatchUrl, wantPatchUrl) } if pr.Owner.Did != "did:plc:author" { t.Errorf("owner.did = %q, want %q", pr.Owner.Did, "did:plc:author") } if payload.Sender.Did != "did:plc:author" { t.Errorf("sender.did = %q, want %q", payload.Sender.Did, "did:plc:author") } if payload.Repository.FullName != "did:plc:target/some-repo" { t.Errorf("repository.full_name = %q, want %q", payload.Repository.FullName, "did:plc:target/some-repo") } })
t.Run("branch based", func(t *testing.T) { pull := basePull() pull.PullSource = &models.PullSource{ Branch: "dark-mode", RepoDid: &targetDid, }
payload := buildPullRequestPayload("merged", repo, &pull, "did:plc:merger", baseUrl)
pr := payload.PullRequest if pr.Source == nil { t.Fatal("source = nil, want non-nil for branch-based pull") } if pr.Source.Branch != "dark-mode" { t.Errorf("source.branch = %q, want %q", pr.Source.Branch, "dark-mode") } if pr.Source.Repo != "" { t.Errorf("source.repo = %q, want empty for branch-based pull", pr.Source.Repo) } if pr.Source.Sha != "bbbb111" { t.Errorf("source.sha = %q, want %q", pr.Source.Sha, "bbbb111") } if payload.Sender.Did != "did:plc:merger" { t.Errorf("sender.did = %q, want %q", payload.Sender.Did, "did:plc:merger") } })
t.Run("fork based", func(t *testing.T) { pull := basePull() pull.PullSource = &models.PullSource{ Branch: "dark-mode", RepoDid: &forkDid, }
payload := buildPullRequestPayload("created", repo, &pull, "did:plc:author", baseUrl)
pr := payload.PullRequest if pr.Source == nil { t.Fatal("source = nil, want non-nil for fork-based pull") } if pr.Source.Repo != "did:plc:fork" { t.Errorf("source.repo = %q, want %q", pr.Source.Repo, "did:plc:fork") } })
t.Run("no submissions", func(t *testing.T) { pull := basePull() pull.Submissions = nil
payload := buildPullRequestPayload("created", repo, &pull, "did:plc:author", baseUrl)
pr := payload.PullRequest if pr.RoundNumber != 0 { t.Errorf("round_number = %d, want 0", pr.RoundNumber) } if pr.PatchUrl != "" { t.Errorf("patch_url = %q, want empty when there are no submissions", pr.PatchUrl) } })}
type notifierTestEnv struct { notifier *Notifier webhook *models.Webhook db *db.DB received chan string}
// newNotifierTestEnv sets up a real sqlite db with a repo and a webhook// subscribed to the given events, delivering to a local test serverfunc newNotifierTestEnv(t *testing.T, events []string) *notifierTestEnv { t.Helper()
d, err := db.Make(context.Background(), filepath.Join(t.TempDir(), "test.db")) if err != nil { t.Fatalf("Make: %v", err) } t.Cleanup(func() { d.Close() })
tx, err := d.Begin() if err != nil { t.Fatalf("Begin: %v", err) } if err := db.AddRepo(tx, &models.Repo{ Did: "did:plc:owner", Name: "some-repo", Knot: "knot.example.com", Rkey: "some-repo", RepoDid: "did:plc:repo1", }); err != nil { t.Fatalf("AddRepo: %v", err) } if err := tx.Commit(); err != nil { t.Fatalf("Commit: %v", err) }
received := make(chan string, 1) srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { received <- r.Header.Get("X-Tangled-Event") w.WriteHeader(http.StatusOK) })) t.Cleanup(srv.Close)
webhook := &models.Webhook{ RepoDid: syntax.DID("did:plc:repo1"), Url: srv.URL, Active: true, Events: events, } if err := db.AddWebhook(d, webhook); err != nil { t.Fatalf("AddWebhook: %v", err) }
return ¬ifierTestEnv{ notifier: NewNotifier(d, "https://tangled.org", true), webhook: webhook, db: d, received: received, }}
func (env *notifierTestEnv) awaitDelivery(t *testing.T, wantEvent string) { t.Helper()
select { case event := <-env.received: if event != wantEvent { t.Errorf("X-Tangled-Event = %q, want %q", event, wantEvent) } case <-time.After(10 * time.Second): t.Fatalf("webhook %s not delivered", wantEvent) }
// wait for the delivery record so the sender goroutine finishes // before the db is closed deadline := time.Now().Add(10 * time.Second) for { deliveries, err := db.GetWebhookDeliveries(env.db, env.webhook.Id, 10) if err == nil && len(deliveries) > 0 { if !deliveries[0].Success { t.Errorf("delivery recorded as failed, want success") } return } if time.Now().After(deadline) { t.Fatal("delivery record not written") } time.Sleep(10 * time.Millisecond) }}
func testPull(state models.PullState) *models.Pull { return &models.Pull{ PullId: 1, RepoDid: syntax.DID("did:plc:repo1"), OwnerDid: "did:plc:author", Title: "hello", TargetBranch: "main", State: state, Created: time.Now(), }}
// Pull request events fire from http handlers, whose request context is// canceled as soon as the handler returns. Deliveries run in background// goroutines and must not be cut short by that cancellation.func TestPullRequestEventDeliversAfterContextCancel(t *testing.T) { env := newNotifierTestEnv(t, []string{string(models.WebhookEventPullRequestCreated)})
ctx, cancel := context.WithCancel(context.Background()) cancel()
env.notifier.NewPull(ctx, testPull(models.PullOpen)) env.awaitDelivery(t, "pull_request:created")}
func TestNotifierDeliversPullRequestEvents(t *testing.T) { allEvents := []string{ string(models.WebhookEventPullRequestCreated), string(models.WebhookEventPullRequestResubmitted), string(models.WebhookEventPullRequestMerged), string(models.WebhookEventPullRequestClosed), string(models.WebhookEventPullRequestReopened), } actor := syntax.DID("did:plc:actor")
tests := []struct { name string notify func(*Notifier, context.Context) wantEvent string }{ { "resubmitted", func(n *Notifier, ctx context.Context) { n.ResubmitPull(ctx, testPull(models.PullOpen)) }, "pull_request:resubmitted", }, { "merged", func(n *Notifier, ctx context.Context) { n.NewPullState(ctx, actor, testPull(models.PullMerged)) }, "pull_request:merged", }, { "closed", func(n *Notifier, ctx context.Context) { n.NewPullState(ctx, actor, testPull(models.PullClosed)) }, "pull_request:closed", }, { "reopened", func(n *Notifier, ctx context.Context) { n.NewPullState(ctx, actor, testPull(models.PullOpen)) }, "pull_request:reopened", }, }
for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { env := newNotifierTestEnv(t, allEvents) tt.notify(env.notifier, context.Background()) env.awaitDelivery(t, tt.wantEvent) }) }}