droboticflow/internal/store/acceptance_authorization_test.go

286 lines
10 KiB
Go

package store
import (
"context"
"errors"
"fmt"
"net/url"
"os"
"sync"
"testing"
"time"
"droboticflow/internal/domain"
"go.mongodb.org/mongo-driver/mongo"
"go.mongodb.org/mongo-driver/mongo/options"
)
func testSharedAcceptanceStore(t *testing.T, s Store) {
t.Helper()
ctx := t.Context()
org := "acceptance-test-org"
for _, id := range []string{"producer", "reviewer"} {
if err := s.UpsertSupplier(ctx, domain.SupplierRecord{ID: id, OrganizationID: org, Status: "active"}); err != nil {
t.Fatal(err)
}
}
input := domain.CreateUserInput{OrganizationID: org, SupplierID: "reviewer", Role: domain.UserRoleAcceptanceReviewer, Phone: "13900101001", Status: domain.UserStatusActive}
if _, err := s.CreateUser(ctx, input); !errors.Is(err, ErrAcceptanceAuthorizationRequired) {
t.Fatalf("default must deny: %v", err)
}
g, err := s.SetSupplierAcceptanceAuthorization(ctx, org, "reviewer", true, 0, "admin")
if err != nil {
t.Fatal(err)
}
if _, err := s.SetSupplierAcceptanceAuthorization(ctx, org, "reviewer", false, 0, "admin"); !errors.Is(err, ErrAcceptanceAuthorizationConflict) {
t.Fatalf("stale update %v", err)
}
a, err := s.CreateUser(ctx, input)
if err != nil {
t.Fatal(err)
}
input.Phone = "13900101002"
b, err := s.CreateUser(ctx, input)
if err != nil {
t.Fatal(err)
}
if a.AcceptanceAccessMode != "managed" {
t.Fatal("new user grandfathered")
}
batch := domain.HumanBatchRecord{ID: "acceptance-batch", OrganizationID: org, ProjectID: "other-project", PluginID: "annotation-qa", Stages: []domain.HumanStageDefinition{{ID: "acceptance", Kind: domain.HumanStageAcceptance, RequiredRole: "acceptance_reviewer"}}}
if err := s.UpsertHumanBatch(ctx, batch); err != nil {
t.Fatal(err)
}
item := domain.HumanItemRecord{ID: "acceptance-item", OrganizationID: org, ProjectID: batch.ProjectID, PluginID: batch.PluginID, BatchID: batch.ID, SupplierID: "producer", CurrentStageID: "acceptance", Status: domain.HumanItemReady, Version: 1, ReviewRound: 1}
if err := s.UpsertHumanItem(ctx, item); err != nil {
t.Fatal(err)
}
var wg sync.WaitGroup
wins := make(chan string, 2)
errs := make(chan error, 2)
for _, u := range []*domain.UserRecord{a, b} {
wg.Add(1)
go func(user *domain.UserRecord) {
defer wg.Done()
next := item
next.AssignedUserID = user.ID
next.Status = domain.HumanItemClaimed
next.ClaimedAt = nowISO()
next.Version++
ok, e := s.ClaimHumanItemVersioned(ctx, next, 1, domain.UserRoleAcceptanceReviewer)
if e != nil {
errs <- e
}
if ok {
wins <- user.ID
}
}(u)
}
wg.Wait()
close(wins)
close(errs)
for e := range errs {
t.Fatal(e)
}
if len(wins) != 1 {
t.Fatalf("claim winners %d", len(wins))
}
winner := <-wins
stored, err := s.GetHumanItem(ctx, item.ID)
if err != nil {
t.Fatal(err)
}
user, _ := s.GetUser(ctx, winner)
if stored.SupplierID != "producer" || !stored.AcceptanceClaim.Matches(*stored, *user) {
t.Fatalf("receipt/ownership: %+v", stored)
}
_, err = s.SetSupplierAcceptanceAuthorization(ctx, org, "reviewer", false, g.Version, "admin")
if err != nil {
t.Fatal(err)
}
projects, count, err := s.SharedAcceptanceInventory(ctx, org, "reviewer", winner)
if err != nil || count != 1 || len(projects) != 1 {
t.Fatalf("drain inventory %v %d %v", projects, count, err)
}
item.ID = "new-round"
item.ReviewRound++
if err := s.UpsertHumanItem(ctx, item); err != nil {
t.Fatal(err)
}
next := item
next.AssignedUserID = winner
next.Status = domain.HumanItemClaimed
next.ClaimedAt = nowISO()
next.Version++
if ok, err := s.ClaimHumanItemVersioned(ctx, next, 1, domain.UserRoleAcceptanceReviewer); ok || !errors.Is(err, ErrHumanClaimConflict) {
t.Fatalf("revoked claim %v %v", ok, err)
}
copy := *stored
copy.ReviewRound++
if copy.AcceptanceClaim.Matches(copy, *user) {
t.Fatal("receipt leaked to another round")
}
// Legacy role changes invalidate the old compatibility even if changed back.
legacy := domain.UserRecord{ID: "legacy-reviewer", OrganizationID: org, SupplierID: "reviewer", Phone: "13900101003", Role: domain.UserRoleAcceptanceReviewer, Status: domain.UserStatusActive}
if err := s.UpsertUser(ctx, legacy); err != nil {
t.Fatal(err)
}
changed := legacy
changed.Role = domain.UserRoleAnnotator
if err := s.UpdateUser(ctx, changed, legacy); err != nil {
t.Fatal(err)
}
current, _ := s.GetUser(ctx, legacy.ID)
if current.AcceptanceAccessMode != "managed" {
t.Fatal("role change retained compatibility")
}
back := *current
back.Role = domain.UserRoleAcceptanceReviewer
if err := s.UpdateUser(ctx, back, *current); !errors.Is(err, ErrAcceptanceAuthorizationRequired) {
t.Fatalf("role bypass %v", err)
}
}
func TestSharedAcceptanceStore(t *testing.T) { testSharedAcceptanceStore(t, NewMemoryStore()) }
func TestSharedAcceptanceMongo(t *testing.T) {
uri := os.Getenv("ACCEPTANCE_LOCAL_MONGO_URI")
if uri == "" {
t.Skip("ACCEPTANCE_LOCAL_MONGO_URI required")
}
u, parseErr := url.Parse(uri)
if parseErr != nil || u.Scheme != "mongodb" || (u.Host != "127.0.0.1:27018" && u.Host != "127.0.0.1:27028") {
t.Fatal("only local replica/standalone Mongo allowed")
}
ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
defer cancel()
client, err := mongo.Connect(ctx, options.Client().ApplyURI(uri))
if err != nil {
t.Fatal(err)
}
defer client.Disconnect(context.Background())
db := client.Database(fmt.Sprintf("acceptance_auth_test_%d", time.Now().UnixNano()))
defer db.Drop(context.Background())
s := NewMongoStore(db)
testSharedAcceptanceStore(t, s)
testAcceptanceRevocationRaceAndQueue(t, s)
legacy := domain.UserRecord{ID: "migration-old", OrganizationID: "migration-org", Role: domain.UserRoleAcceptanceReviewer, AcceptanceAccessMode: "", Phone: "13900101111"}
if err := s.UpsertUser(ctx, legacy); err != nil {
t.Fatal(err)
}
if err := s.SnapshotLegacyAcceptanceAccounts(ctx, legacy.OrganizationID); err != nil {
t.Fatal(err)
}
old, _ := s.GetUser(ctx, legacy.ID)
if old.AcceptanceAccessMode != "legacy" {
t.Fatal("legacy snapshot missing")
}
changed := *old
changed.Role = domain.UserRoleAnnotator
if err := s.UpdateUser(ctx, changed, *old); err != nil {
t.Fatal(err)
}
if err := s.SnapshotLegacyAcceptanceAccounts(ctx, legacy.OrganizationID); err != nil {
t.Fatal(err)
}
current, _ := s.GetUser(ctx, legacy.ID)
if current.AcceptanceAccessMode != "managed" {
t.Fatal("replay revived legacy access")
}
}
func testAcceptanceRevocationRaceAndQueue(t *testing.T, s Store) {
t.Helper()
ctx := t.Context()
org := "acceptance-race-org"
if err := s.UpsertSupplier(ctx, domain.SupplierRecord{ID: "race-supplier", OrganizationID: org, Status: "active"}); err != nil {
t.Fatal(err)
}
g, err := s.SetSupplierAcceptanceAuthorization(ctx, org, "race-supplier", true, 0, "admin")
if err != nil {
t.Fatal(err)
}
u, err := s.CreateUser(ctx, domain.CreateUserInput{OrganizationID: org, SupplierID: "race-supplier", Role: domain.UserRoleAcceptanceReviewer, Phone: "13900102222"})
if err != nil {
t.Fatal(err)
}
batch := domain.HumanBatchRecord{ID: "race-batch", OrganizationID: org, PluginID: "annotation-qa", Stages: []domain.HumanStageDefinition{{ID: "acceptance", Kind: domain.HumanStageAcceptance, RequiredRole: "acceptance_reviewer"}}}
if err = s.UpsertHumanBatch(ctx, batch); err != nil {
t.Fatal(err)
}
for i := 0; i < 8; i++ {
item := domain.HumanItemRecord{ID: fmt.Sprintf("race-%d", i), OrganizationID: org, ProjectID: "project-race", PluginID: "annotation-qa", BatchID: batch.ID, CurrentStageID: "acceptance", Status: domain.HumanItemReady, Version: 1, ReviewRound: 1}
if err = s.UpsertHumanItem(ctx, item); err != nil {
t.Fatal(err)
}
next := item
next.AssignedUserID = u.ID
next.Status = domain.HumanItemClaimed
next.ClaimedAt = nowISO()
next.Version++
var won bool
var claimErr, revokeErr error
var revoked *domain.SupplierAcceptanceAuthorization
var wg sync.WaitGroup
wg.Add(2)
go func() {
defer wg.Done()
won, claimErr = s.ClaimHumanItemVersioned(ctx, next, 1, domain.UserRoleAcceptanceReviewer)
}()
go func() {
defer wg.Done()
revoked, revokeErr = s.SetSupplierAcceptanceAuthorization(ctx, org, u.SupplierID, false, g.Version, "admin")
}()
wg.Wait()
if revokeErr != nil {
t.Fatal(revokeErr)
}
if claimErr != nil && !errors.Is(claimErr, ErrHumanClaimConflict) {
t.Fatal(claimErr)
}
saved, _ := s.GetHumanItem(ctx, item.ID)
if won && (saved.AcceptanceClaim == nil || saved.AcceptanceClaim.GrantVersion >= revoked.Version || !saved.AcceptanceClaim.Matches(*saved, *u)) {
t.Fatal("claim after revoke or missing receipt")
}
if !won && saved.AssignedUserID != "" {
t.Fatal("failed claim wrote ownership")
}
item.ID += "-after"
if err = s.UpsertHumanItem(ctx, item); err != nil {
t.Fatal(err)
}
next.ID = item.ID
if ok, e := s.ClaimHumanItemVersioned(ctx, next, 1, domain.UserRoleAcceptanceReviewer); ok || !errors.Is(e, ErrHumanClaimConflict) {
t.Fatalf("post revoke claim %v %v", ok, e)
}
g, err = s.SetSupplierAcceptanceAuthorization(ctx, org, u.SupplierID, true, revoked.Version, "admin")
if err != nil {
t.Fatal(err)
}
}
// Mixed legacy timestamps are ordered before pagination; candidates never carry video evidence.
for i := 0; i < 105; i++ {
at := time.Date(2020, 1, 1, 0, 0, i, 0, time.UTC).Format(time.RFC3339Nano)
if i == 0 {
at = "2020-01-01T08:00:00+08:00"
}
v := domain.HumanItemRecord{ID: fmt.Sprintf("queue-%03d", i), OrganizationID: org, ProjectID: "queue-project", PluginID: "annotation-qa", Status: domain.HumanItemReady, CreatedAt: at, Subject: domain.HumanSubjectRef{Payload: map[string]any{"largeEvidence": "omitted"}}}
if e := s.UpsertHumanItem(ctx, v); e != nil {
t.Fatal(e)
}
}
for _, offset := range []int{0, 100} {
rows, e := s.ListReviewCandidates(ctx, org, "queue-project", u.ID, false, offset, 100)
if e != nil {
t.Fatal(e)
}
for i, row := range rows {
if row.ID != fmt.Sprintf("queue-%03d", offset+i) || row.Subject.Payload != nil {
t.Fatalf("bad bounded order/payload %+v", row)
}
}
}
}
func TestAcceptanceRevocationRaceAndQueue(t *testing.T) {
testAcceptanceRevocationRaceAndQueue(t, NewMemoryStore())
}