forked from longtao.wu/droboticflow
286 lines
10 KiB
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())
|
|
}
|