Monorepo for Tangled
Something went wrong. Try again.
Go
at commit-links
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855package spindle
import ( "context" "encoding/json" "log/slog" "strings" "tangled.org/core/jetstream" "testing" "time"
"github.com/bluesky-social/indigo/atproto/identity" "github.com/bluesky-social/indigo/atproto/syntax" "tangled.org/core/api/tangled" "tangled.org/core/eventconsumer" "tangled.org/core/idresolver" "tangled.org/core/rbac" "tangled.org/core/spindle/config" "tangled.org/core/spindle/db" "tangled.org/core/workflow"
"tangled.org/core/tapc")
func TestProcessRepo_MembershipCheck(t *testing.T) { d, e := newTestSpindleDB(t)
cfg := &config.Config{} cfg.Server.Hostname = "spindle.test"
ccfg := eventconsumer.NewConsumerConfig() ccfg.Logger = slog.Default() ks := eventconsumer.NewConsumer(*ccfg)
jc, jcerr := jetstream.NewJetstreamClient("", "", nil, nil, slog.Default(), nil, false, false) if jcerr != nil { t.Fatalf("NewJetstreamClient: %v", jcerr) } s := &Spindle{ db: d, e: e, l: slog.Default(), cfg: cfg, ks: ks, jc: jc, rootCtx: context.Background(), }
tap := &Tap{ spindle: s, logger: slog.Default(), }
ownerDid := syntax.DID("did:plc:memberowner") nonMemberDid := syntax.DID("did:plc:nonmemberowner") repoDid := "did:plc:testrepo123"
err := e.AddSpindle(rbac.ThisServer) if err != nil { t.Fatalf("AddSpindle: %v", err) } err = e.AddSpindleMember(rbac.ThisServer, ownerDid.String()) if err != nil { t.Fatalf("AddSpindleMember: %v", err) }
recNonMember := tangled.Repo{ Knot: "knot.test", RepoDid: &repoDid, Spindle: &cfg.Server.Hostname, CreatedAt: time.Now().Format(time.RFC3339), } recNonMemberJson, _ := json.Marshal(recNonMember)
err = tap.processRepo(context.Background(), &tapc.RecordEventData{ Live: true, Did: nonMemberDid, Rkey: "test-repo-rkey", Collection: syntax.NSID(tangled.RepoNSID), Action: tapc.RecordCreateAction, Record: recNonMemberJson, }) if err != nil { t.Fatalf("processRepo returned error for non-member: %v", err) }
_, err = d.GetRepoByOwnerRkey(nonMemberDid, "test-repo-rkey") if err == nil { t.Fatal("repo for non-member was registered in DB, expected rejection") }
recMember := tangled.Repo{ Knot: "knot.test", RepoDid: &repoDid, Spindle: &cfg.Server.Hostname, CreatedAt: time.Now().Format(time.RFC3339), } recMemberJson, _ := json.Marshal(recMember)
err = tap.processRepo(context.Background(), &tapc.RecordEventData{ Live: true, Did: ownerDid, Rkey: "test-repo-rkey", Collection: syntax.NSID(tangled.RepoNSID), Action: tapc.RecordCreateAction, Record: recMemberJson, }) if err == nil { t.Fatal("expected git clone error for valid member, but got nil") }
if !strings.Contains(err.Error(), "setting up sparse-clone git repo") { t.Fatalf("expected sparse-clone error, got: %v", err) }}
func TestProcessPull_PushAllowedCheck(t *testing.T) { d, e := newTestSpindleDB(t)
cfg := &config.Config{} cfg.Server.Hostname = "spindle.test"
jc, jcerr := jetstream.NewJetstreamClient("", "", nil, nil, slog.Default(), nil, false, false) if jcerr != nil { t.Fatalf("NewJetstreamClient: %v", jcerr) } s := &Spindle{ db: d, e: e, l: slog.Default(), cfg: cfg, res: idresolver.DefaultResolver("https://plc.test"), jc: jc, rootCtx: context.Background(), }
repoOwnerDid := syntax.DID("did:plc:repoowner") nonPusherDid := syntax.DID("did:plc:nonpusher") pusherDid := syntax.DID("did:plc:pusher") repoDid := syntax.DID("did:plc:testrepo123")
err := d.AddRepo(db.Repo{ Knot: "knot.test", Owner: repoOwnerDid, Rkey: "test-repo-rkey", RepoDid: repoDid, CreatedAt: time.Now().Format(time.RFC3339), }) if err != nil { t.Fatalf("AddRepo: %v", err) }
err = e.AddRepo(repoOwnerDid.String(), rbac.ThisServer, repoDid.String()) if err != nil { t.Fatalf("AddRepo permissions: %v", err) } err = e.AddCollaborator(pusherDid.String(), rbac.ThisServer, repoDid.String()) if err != nil { t.Fatalf("AddCollaborator: %v", err) }
pullRecord := tangled.RepoPull{ Target: &tangled.RepoPull_Target{ Branch: "main", Repo: repoDid.String(), }, Source: &tangled.RepoPull_Source{ Branch: "feature", Repo: nil, // branch-based PR (source repo is nil) }, } pullRecordJson, _ := json.Marshal(pullRecord)
err = s.processPull(context.Background(), &tapc.RecordEventData{ Live: true, Did: nonPusherDid, Rkey: "pull-rkey-1", Collection: syntax.NSID(tangled.RepoPullNSID), Action: tapc.RecordCreateAction, Record: pullRecordJson, }) if err != nil { t.Fatalf("processPull returned error for non-pusher: %v", err) }
// fetch fails because plc/pds are not real err = s.processPull(context.Background(), &tapc.RecordEventData{ Live: true, Did: pusherDid, Rkey: "pull-rkey-2", Collection: syntax.NSID(tangled.RepoPullNSID), Action: tapc.RecordCreateAction, Record: pullRecordJson, }) if err == nil { t.Fatal("expected error from fetchLatestSubmission for valid pusher, but got nil") }
if !strings.Contains(err.Error(), "checking push access") && !strings.Contains(err.Error(), "resolve PR owner") && !strings.Contains(err.Error(), "invalid memory address") { t.Fatalf("expected failed identity resolution or connection error, got: %v", err) }}
func TestProcessRepo_HijackRepoDidCheck(t *testing.T) { d, e := newTestSpindleDB(t)
cfg := &config.Config{} cfg.Server.Hostname = "spindle.test"
ccfg := eventconsumer.NewConsumerConfig() ccfg.Logger = slog.Default() ks := eventconsumer.NewConsumer(*ccfg)
jc, jcerr := jetstream.NewJetstreamClient("", "", nil, nil, slog.Default(), nil, false, false) if jcerr != nil { t.Fatalf("NewJetstreamClient: %v", jcerr) } s := &Spindle{ db: d, e: e, l: slog.Default(), cfg: cfg, ks: ks, jc: jc, rootCtx: context.Background(), }
tap := &Tap{ spindle: s, logger: slog.Default(), }
aliceDid := syntax.DID("did:plc:alice") bobDid := syntax.DID("did:plc:bob") repoDid := "did:plc:sharedrepo"
err := e.AddSpindle(rbac.ThisServer) if err != nil { t.Fatalf("AddSpindle: %v", err) } err = e.AddSpindleMember(rbac.ThisServer, aliceDid.String()) if err != nil { t.Fatalf("AddSpindleMember alice: %v", err) } err = e.AddSpindleMember(rbac.ThisServer, bobDid.String()) if err != nil { t.Fatalf("AddSpindleMember bob: %v", err) }
err = d.AddRepo(db.Repo{ Knot: "knot.test", Owner: aliceDid, Rkey: "alice-repo", RepoDid: syntax.DID(repoDid), CreatedAt: time.Now().Format(time.RFC3339), }) if err != nil { t.Fatalf("d.AddRepo: %v", err) }
// bob tries to register alice's repo did, must reject the hijack recBob := tangled.Repo{ Knot: "knot.test", RepoDid: &repoDid, Spindle: &cfg.Server.Hostname, CreatedAt: time.Now().Format(time.RFC3339), } recBobJson, _ := json.Marshal(recBob)
err = tap.processRepo(context.Background(), &tapc.RecordEventData{ Live: true, Did: bobDid, Rkey: "bob-repo", Collection: syntax.NSID(tangled.RepoNSID), Action: tapc.RecordCreateAction, Record: recBobJson, }) if err != nil { t.Fatalf("processRepo returned error on duplicate repoDid hijack attempt: %v", err) }
_, err = d.GetRepoByOwnerRkey(bobDid, "bob-repo") if err == nil { t.Fatal("bob successfully hijacked alice's repoDid in DB, expected rejection") }}
func TestProcessCollaborator_RBAC(t *testing.T) { d, e := newTestSpindleDB(t)
cfg := &config.Config{} cfg.Server.Hostname = "spindle.test"
ownerDid := syntax.DID("did:plc:repoowner") otherDid := syntax.DID("did:plc:otheractor") subjectDid := syntax.DID("did:plc:collabsubject") repoDid := syntax.DID("did:plc:testrepo123")
h, err := syntax.ParseHandle("collabsubject.test") if err != nil { t.Fatalf("syntax.ParseHandle: %v", err) } mockIdent := &identity.Identity{ DID: subjectDid, Handle: h, } resolver := idresolver.NewMockResolver(idresolver.MockDirectory{Ident: mockIdent})
jc, jcerr := jetstream.NewJetstreamClient("", "", nil, nil, slog.Default(), nil, false, false) if jcerr != nil { t.Fatalf("NewJetstreamClient: %v", jcerr) } s := &Spindle{ db: d, e: e, l: slog.Default(), cfg: cfg, res: resolver, jc: jc, rootCtx: context.Background(), }
tap := &Tap{ spindle: s, logger: slog.Default(), }
err = d.AddRepo(db.Repo{ Knot: "knot.test", Owner: ownerDid, Rkey: "test-repo-rkey", RepoDid: repoDid, CreatedAt: time.Now().Format(time.RFC3339), }) if err != nil { t.Fatalf("AddRepo: %v", err) }
collabRecord := tangled.RepoCollaborator{ Subject: subjectDid.String(), Repo: repoDid.String(), } collabRecordJson, _ := json.Marshal(collabRecord)
err = tap.processCollaborator(context.Background(), &tapc.RecordEventData{ Live: true, Did: otherDid, Rkey: "collab-rkey-1", Collection: syntax.NSID(tangled.RepoCollaboratorNSID), Action: tapc.RecordCreateAction, Record: collabRecordJson, }) if err != nil { t.Fatalf("processCollaborator returned error: %v", err) }
_, err = d.GetRepoCollaborator(otherDid, "collab-rkey-1") if err == nil { t.Fatal("collaborator from non-owner was registered in DB") }
err = tap.processCollaborator(context.Background(), &tapc.RecordEventData{ Live: true, Did: ownerDid, Rkey: "collab-rkey-2", Collection: syntax.NSID(tangled.RepoCollaboratorNSID), Action: tapc.RecordCreateAction, Record: collabRecordJson, }) if err != nil { t.Fatalf("processCollaborator returned error: %v", err) } _, err = d.GetRepoCollaborator(ownerDid, "collab-rkey-2") if err == nil { t.Fatal("collaborator registered despite missing Casbin invite permission") }
err = e.AddRepo(ownerDid.String(), rbac.ThisServer, repoDid.String()) if err != nil { t.Fatalf("AddRepo permissions: %v", err) }
err = tap.processCollaborator(context.Background(), &tapc.RecordEventData{ Live: true, Did: ownerDid, Rkey: "collab-rkey-3", Collection: syntax.NSID(tangled.RepoCollaboratorNSID), Action: tapc.RecordCreateAction, Record: collabRecordJson, }) if err != nil { t.Fatalf("processCollaborator failed for authorized owner: %v", err) }
c, err := d.GetRepoCollaborator(ownerDid, "collab-rkey-3") if err != nil { t.Fatalf("GetRepoCollaborator error: %v", err) } if c.Subject != subjectDid || c.RepoDid != repoDid { t.Fatalf("unexpected collaborator: %+v", c) }
ok, err := e.IsRepoCollaborator(subjectDid.String(), rbac.ThisServer, repoDid.String()) if err != nil || !ok { t.Fatalf("Casbin policy for collaborator missing or err: %v", err) }
err = tap.processCollaborator(context.Background(), &tapc.RecordEventData{ Live: true, Did: ownerDid, Rkey: "collab-rkey-3", Collection: syntax.NSID(tangled.RepoCollaboratorNSID), Action: tapc.RecordDeleteAction, }) if err != nil { t.Fatalf("delete collaborator process returned error: %v", err) }
_, err = d.GetRepoCollaborator(ownerDid, "collab-rkey-3") if err == nil { t.Fatal("collaborator DB row remained after deletion") }
ok, err = e.IsRepoCollaborator(subjectDid.String(), rbac.ThisServer, repoDid.String()) if err != nil || ok { t.Fatal("Casbin policy for collaborator remained after deletion") }}
func TestTeardownRepo_RBAC(t *testing.T) { d, e := newTestSpindleDB(t)
cfg := &config.Config{} cfg.Server.Hostname = "spindle.test"
jc, jcerr := jetstream.NewJetstreamClient("", "", nil, nil, slog.Default(), nil, false, false) if jcerr != nil { t.Fatalf("NewJetstreamClient: %v", jcerr) } s := &Spindle{ db: d, e: e, l: slog.Default(), cfg: cfg, jc: jc, rootCtx: context.Background(), }
tap := &Tap{ spindle: s, logger: slog.Default(), }
ownerDid := syntax.DID("did:plc:repoowner") repoDid := syntax.DID("did:plc:testrepo123") collabDid := syntax.DID("did:plc:collab")
err := d.AddRepo(db.Repo{ Knot: "knot.test", Owner: ownerDid, Rkey: "test-repo-rkey", RepoDid: repoDid, CreatedAt: time.Now().Format(time.RFC3339), }) if err != nil { t.Fatalf("AddRepo DB: %v", err) }
err = e.AddRepo(ownerDid.String(), rbac.ThisServer, repoDid.String()) if err != nil { t.Fatalf("AddRepo policy: %v", err) }
err = d.AddRepoCollaborator(db.RepoCollaborator{ OwnerDid: ownerDid, Rkey: "collab-rkey", Subject: collabDid, RepoDid: repoDid, }) if err != nil { t.Fatalf("AddCollaborator DB: %v", err) }
err = e.AddCollaborator(collabDid.String(), rbac.ThisServer, repoDid.String()) if err != nil { t.Fatalf("AddCollaborator policy: %v", err) }
err = tap.processRepo(context.Background(), &tapc.RecordEventData{ Live: true, Did: ownerDid, Rkey: "test-repo-rkey", Collection: syntax.NSID(tangled.RepoNSID), Action: tapc.RecordDeleteAction, }) if err != nil { t.Fatalf("processRepo delete returned error: %v", err) }
_, err = d.GetRepoByOwnerRkey(ownerDid, "test-repo-rkey") if err == nil { t.Fatal("repo remained in DB after delete") }
collabs, err := d.ListCollaboratorsByRepoDid(repoDid) if err != nil { t.Fatalf("ListCollaboratorsByRepoDid: %v", err) } if len(collabs) > 0 { t.Fatal("collaborators remained in DB after delete") }
ok, err := e.IsRepoOwner(ownerDid.String(), rbac.ThisServer, repoDid.String()) if err != nil || ok { t.Fatal("repo owner policy remained in Casbin after delete") }
ok, err = e.IsRepoCollaborator(collabDid.String(), rbac.ThisServer, repoDid.String()) if err != nil || ok { t.Fatal("collaborator policy remained in Casbin after delete") }}
func TestProcessRepo_ForgeDeleteRejection(t *testing.T) { d, e := newTestSpindleDB(t)
cfg := &config.Config{} cfg.Server.Hostname = "spindle.test"
jc, jcerr := jetstream.NewJetstreamClient("", "", nil, nil, slog.Default(), nil, false, false) if jcerr != nil { t.Fatalf("NewJetstreamClient: %v", jcerr) }
s := &Spindle{ db: d, e: e, l: slog.Default(), cfg: cfg, jc: jc, rootCtx: context.Background(), }
tap := &Tap{ spindle: s, logger: slog.Default(), }
aliceDid := syntax.DID("did:plc:alice") bobDid := syntax.DID("did:plc:bob") repoDid := syntax.DID("did:plc:sharedrepo")
err := d.AddRepo(db.Repo{ Knot: "knot.test", Owner: aliceDid, Rkey: "test-repo-rkey", RepoDid: repoDid, CreatedAt: time.Now().Format(time.RFC3339), }) if err != nil { t.Fatalf("AddRepo DB: %v", err) }
err = e.AddRepo(aliceDid.String(), rbac.ThisServer, repoDid.String()) if err != nil { t.Fatalf("AddRepo policy: %v", err) }
// bob tries to delete alice's repo, must reject forged delete err = tap.processRepo(context.Background(), &tapc.RecordEventData{ Live: true, Did: bobDid, Rkey: "test-repo-rkey", Collection: syntax.NSID(tangled.RepoNSID), Action: tapc.RecordDeleteAction, }) if err != nil { t.Fatalf("processRepo returned error on delete: %v", err) }
_, err = d.GetRepoByOwnerRkey(aliceDid, "test-repo-rkey") if err != nil { t.Fatalf("Alice's repo was deleted or error: %v", err) }
ok, err := e.IsRepoOwner(aliceDid.String(), rbac.ThisServer, repoDid.String()) if err != nil || !ok { t.Fatal("Alice's owner policy was removed from Casbin by forged delete") }}
func TestProcessCollaborator_ForgeDeleteRejection(t *testing.T) { d, e := newTestSpindleDB(t)
cfg := &config.Config{} cfg.Server.Hostname = "spindle.test"
jc, jcerr := jetstream.NewJetstreamClient("", "", nil, nil, slog.Default(), nil, false, false) if jcerr != nil { t.Fatalf("NewJetstreamClient: %v", jcerr) }
s := &Spindle{ db: d, e: e, l: slog.Default(), cfg: cfg, res: idresolver.DefaultResolver("https://plc.test"), jc: jc, rootCtx: context.Background(), }
tap := &Tap{ spindle: s, logger: slog.Default(), }
ownerDid := syntax.DID("did:plc:repoowner") bobDid := syntax.DID("did:plc:bob") collabDid := syntax.DID("did:plc:collab") repoDid := syntax.DID("did:plc:testrepo123")
err := d.AddRepo(db.Repo{ Knot: "knot.test", Owner: ownerDid, Rkey: "test-repo-rkey", RepoDid: repoDid, CreatedAt: time.Now().Format(time.RFC3339), }) if err != nil { t.Fatalf("AddRepo: %v", err) }
err = e.AddRepo(ownerDid.String(), rbac.ThisServer, repoDid.String()) if err != nil { t.Fatalf("AddRepo permissions: %v", err) }
err = d.AddRepoCollaborator(db.RepoCollaborator{ OwnerDid: ownerDid, Rkey: "collab-rkey", Subject: collabDid, RepoDid: repoDid, }) if err != nil { t.Fatalf("AddRepoCollaborator: %v", err) }
err = e.AddCollaborator(collabDid.String(), rbac.ThisServer, repoDid.String()) if err != nil { t.Fatalf("AddCollaborator policy: %v", err) }
// bob tries to delete alice's collaborator, must reject forged delete err = tap.processCollaborator(context.Background(), &tapc.RecordEventData{ Live: true, Did: bobDid, Rkey: "collab-rkey", Collection: syntax.NSID(tangled.RepoCollaboratorNSID), Action: tapc.RecordDeleteAction, }) if err != nil { t.Fatalf("processCollaborator delete returned error: %v", err) }
_, err = d.GetRepoCollaborator(ownerDid, "collab-rkey") if err != nil { t.Fatalf("collaborator was deleted from DB: %v", err) }
ok, err := e.IsRepoCollaborator(collabDid.String(), rbac.ThisServer, repoDid.String()) if err != nil || !ok { t.Fatal("collaborator policy was removed from Casbin by forged delete") }}
func TestPullStatusAction(t *testing.T) { tests := []struct { name string status string wantAction string wantOK bool }{ {"open maps to reopened", tangled.RepoPullStatusOpen, workflow.PullRequestActionReopened, true}, {"closed maps to closed", tangled.RepoPullStatusClosed, workflow.PullRequestActionClosed, true}, {"merged maps to merged", tangled.RepoPullStatusMerged, workflow.PullRequestActionMerged, true}, {"unknown status is rejected", "sh.tangled.repo.pull.status.bogus", "", false}, {"empty status is rejected", "", "", false}, }
for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { action, ok := pullStatusAction(tt.status) if ok != tt.wantOK { t.Fatalf("pullStatusAction(%q) ok = %v, want %v", tt.status, ok, tt.wantOK) } if action != tt.wantAction { t.Fatalf("pullStatusAction(%q) action = %q, want %q", tt.status, action, tt.wantAction) } }) }}
func TestProcessPullStatus(t *testing.T) { d, e := newTestSpindleDB(t)
cfg := &config.Config{} cfg.Server.Hostname = "spindle.test"
jc, jcerr := jetstream.NewJetstreamClient("", "", nil, nil, slog.Default(), nil, false, false) if jcerr != nil { t.Fatalf("NewJetstreamClient: %v", jcerr) } s := &Spindle{ db: d, e: e, l: slog.Default(), cfg: cfg, res: idresolver.DefaultResolver("https://plc.test"), jc: jc, rootCtx: context.Background(), }
statusRecord := func(status, pullUri string) []byte { rec := tangled.RepoPullStatus{ Status: status, Pull: pullUri, CreatedAt: time.Now().Format(time.RFC3339), } b, _ := json.Marshal(rec) return b }
validPullUri := "at://did:plc:pullowner/sh.tangled.repo.pull/pull-rkey-1"
// non-create actions are ignored if err := s.processPullStatus(context.Background(), &tapc.RecordEventData{ Live: true, Did: syntax.DID("did:plc:actor"), Rkey: "status-rkey", Collection: syntax.NSID(tangled.RepoPullStatusNSID), Action: tapc.RecordUpdateAction, Record: statusRecord(tangled.RepoPullStatusClosed, validPullUri), }); err != nil { t.Fatalf("update action should be a no-op, got: %v", err) }
// unknown status variant is skipped without error if err := s.processPullStatus(context.Background(), &tapc.RecordEventData{ Live: true, Did: syntax.DID("did:plc:actor"), Rkey: "status-rkey", Collection: syntax.NSID(tangled.RepoPullStatusNSID), Action: tapc.RecordCreateAction, Record: statusRecord("sh.tangled.repo.pull.status.bogus", validPullUri), }); err != nil { t.Fatalf("unknown status should be skipped, got: %v", err) }
// a malformed pull at-uri is skipped without error if err := s.processPullStatus(context.Background(), &tapc.RecordEventData{ Live: true, Did: syntax.DID("did:plc:actor"), Rkey: "status-rkey", Collection: syntax.NSID(tangled.RepoPullStatusNSID), Action: tapc.RecordCreateAction, Record: statusRecord(tangled.RepoPullStatusClosed, "not-an-at-uri"), }); err != nil { t.Fatalf("invalid pull at-uri should be skipped, got: %v", err) }
// a status pointing at a non-pull subject is skipped without error if err := s.processPullStatus(context.Background(), &tapc.RecordEventData{ Live: true, Did: syntax.DID("did:plc:actor"), Rkey: "status-rkey", Collection: syntax.NSID(tangled.RepoPullStatusNSID), Action: tapc.RecordCreateAction, Record: statusRecord(tangled.RepoPullStatusClosed, "at://did:plc:x/sh.tangled.repo.issue/y"), }); err != nil { t.Fatalf("non-pull subject should be skipped, got: %v", err) }
// a valid close event resolves the pull record; fetch fails because plc/pds // are not real, confirming we reached the fetch stage with a mapped action. err := s.processPullStatus(context.Background(), &tapc.RecordEventData{ Live: true, Did: syntax.DID("did:plc:actor"), Rkey: "status-rkey", Collection: syntax.NSID(tangled.RepoPullStatusNSID), Action: tapc.RecordCreateAction, Record: statusRecord(tangled.RepoPullStatusClosed, validPullUri), }) if err == nil { t.Fatal("expected error fetching pull record against fake pds, got nil") } if !strings.Contains(err.Error(), "fetch pull record") { t.Fatalf("expected fetch pull record error, got: %v", err) }}
func TestIsPullTriggerAuthorized(t *testing.T) { d, e := newTestSpindleDB(t) s := &Spindle{ db: d, e: e, l: slog.Default(), }
repoDid := syntax.DID("did:plc:targetrepo") ownerDid := syntax.DID("did:plc:owner") // has push (repo owner) collaboratorDid := "did:plc:collaborator" // has push noPushAuthorDid := "did:plc:nopushauthor" // pull author without push strangerDid := "did:plc:stranger" // no push, not the author
if err := e.AddRepo(ownerDid.String(), rbac.ThisServer, repoDid.String()); err != nil { t.Fatalf("AddRepo permissions: %v", err) } if err := e.AddCollaborator(collaboratorDid, rbac.ThisServer, repoDid.String()); err != nil { t.Fatalf("AddCollaborator: %v", err) }
cases := []struct { name string eventDid string pullDid string allowed bool }{ // direct pr path: event author == pull author {"direct pr by pushing author", ownerDid.String(), ownerDid.String(), true}, {"direct pr by non-pushing author", noPushAuthorDid, noPushAuthorDid, false},
// status path: actor differs from pull author, pull author has push {"actor with push acts on authorized pr", collaboratorDid, ownerDid.String(), true}, {"pull author acts on own authorized pr", ownerDid.String(), ownerDid.String(), true}, {"stranger without push acts on authorized pr", strangerDid, ownerDid.String(), false},
// pull author must always have push, even if the actor does {"pushing actor on unauthorized pull author", ownerDid.String(), noPushAuthorDid, false}, {"non-pushing actor on unauthorized pull author", strangerDid, noPushAuthorDid, false}, }
for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { allowed, err := s.isPullTriggerAuthorized(tc.eventDid, tc.pullDid, repoDid.String()) if err != nil { t.Fatalf("isPullTriggerAuthorized: %v", err) } if allowed != tc.allowed { t.Fatalf("event=%q pull=%q allowed=%v, want %v", tc.eventDid, tc.pullDid, allowed, tc.allowed) } }) }}