Files
mtusi2026lab5/internal/attachment/service_test.go
T

182 lines
6.0 KiB
Go

package attachment_test
import (
"bytes"
"context"
"errors"
"io"
"os"
"sync"
"testing"
"time"
"github.com/google/uuid"
"messenger/internal/attachment"
"messenger/internal/attachment/store"
chatstore "messenger/internal/chat/store"
"messenger/internal/platform/apperr"
"messenger/internal/platform/ident"
"messenger/internal/testenv"
)
func TestCollectorRechecksStageAfterConcurrentEnqueue(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
defer cancel()
db, err := testenv.StartPostgres(ctx)
if err != nil {
t.Fatal(err)
}
defer db.Close()
f := reconcileSetup(t, db)
f.exec(`INSERT INTO chat_members VALUES ($1,$2)`, f.chat, f.user)
data, err := os.ReadFile("../../tests/fixtures/sample.png")
if err != nil {
t.Fatal(err)
}
entered := make(chan string, 1)
resume := make(chan struct{})
var once sync.Once
f.b.stating = func(key string) {
once.Do(func() {
f.b.add(key, data, time.Now().Add(-2*time.Hour))
entered <- key
select {
case <-resume:
case <-ctx.Done():
}
})
}
s := attachment.NewService(store.NewAttachments(db.Pool), chatstore.NewChats(db.Pool), f.b, attachment.Config{})
uploaded := make(chan error, 1)
go func() {
_, err := s.Upload(ctx, f.user, attachment.UploadInput{ChatID: f.chat, Filename: "photo.png", MIMEType: "image/png", SizeBytes: int64(len(data))}, bytes.NewReader(data))
uploaded <- err
}()
var key string
select {
case key = <-entered:
case <-ctx.Done():
t.Fatal("upload never verified staging under lock")
}
r, err := attachment.NewReconciler(db.Pool, f.b, time.Hour)
if err != nil {
t.Fatal(err)
}
collect := make(chan error, 1)
go func() {
stats, err := r.Run(ctx, attachment.ReconcileOptions{Apply: true}, nil)
if err == nil && stats.Repaired != 0 {
err = errors.New("removed concurrent upload")
}
collect <- err
}()
waitReconcileLock(t, ctx, db.Pool)
close(resume)
if err := <-uploaded; err != nil {
t.Fatal(err)
}
if err := <-collect; err != nil {
t.Fatal(err)
}
if !f.b.has(key) {
t.Fatal("accepted source lost")
}
}
type lostCommitReply struct {
attachment.AttachmentRepository
}
func (r lostCommitReply) Enqueue(ctx context.Context, a attachment.Attachment, stage string, check func() error) error {
if err := r.AttachmentRepository.Enqueue(ctx, a, stage, check); err != nil {
return err
}
return io.ErrUnexpectedEOF
}
func TestUploadDeduplicatesContentButKeepsChatScopedIdentities(t *testing.T) {
ctx := context.Background()
db, err := testenv.StartPostgres(ctx)
if err != nil {
t.Fatal(err)
}
defer db.Close()
actor, c1, c2 := ident.New(), ident.New(), ident.New()
_, err = db.Pool.Exec(ctx, `INSERT INTO users VALUES($1,'alice','Alice','hash',now());`, actor)
if err != nil {
t.Fatal(err)
}
for _, c := range []uuid.UUID{c1, c2} {
_, err = db.Pool.Exec(ctx, `INSERT INTO chats VALUES($1,'room',now())`, c)
if err != nil {
t.Fatal(err)
}
_, err = db.Pool.Exec(ctx, `INSERT INTO chat_members VALUES($1,$2)`, c, actor)
if err != nil {
t.Fatal(err)
}
}
b := newReconcileBlobs()
s := attachment.NewService(store.NewAttachments(db.Pool), chatstore.NewChats(db.Pool), b, attachment.Config{})
data, err := os.ReadFile("../../tests/fixtures/sample.png")
if err != nil {
t.Fatal(err)
}
var results [10]attachment.Attachment
var wg sync.WaitGroup
for i := range results {
wg.Go(func() {
c := c1
if i%2 == 1 {
c = c2
}
var e error
input := attachment.UploadInput{ChatID: c, Filename: "photo.png", MIMEType: "image/png", SizeBytes: int64(len(data))}
results[i], e = s.Upload(ctx, actor, input, bytes.NewReader(data))
if e != nil {
t.Error(e)
}
})
}
wg.Wait()
var files, atts, jobs int
err = db.Pool.QueryRow(ctx, `SELECT (SELECT count(*) FROM files),(SELECT count(*) FROM attachments),
(SELECT count(*) FROM attachment_jobs WHERE state='queued' AND attempt=1 AND published_at IS NULL)`).Scan(&files, &atts, &jobs)
if err != nil || files != 1 || atts != 10 || jobs != 10 || len(b.objects) != 10 {
t.Fatalf("handoff: files=%d attachments=%d jobs=%d objects=%d err=%v", files, atts, jobs, len(b.objects), err)
}
for _, a := range results {
if a.Status != attachment.FileQueued || !bytes.Equal(b.bodies["staging/"+a.ID.String()], data) {
t.Fatal("missing queued source", a.ID)
}
}
if results[0].ID == results[1].ID {
t.Fatal("deduplication merged chat ACL identity")
}
if _, err := s.Get(ctx, ident.New(), results[0].ID); apperr.KindOf(err) != apperr.KindNotFound {
t.Fatalf("outsider got %v", err)
}
input := attachment.UploadInput{ChatID: c1, Filename: "lost.png", MIMEType: "image/png", SizeBytes: int64(len(data))}
lost := attachment.NewService(lostCommitReply{store.NewAttachments(db.Pool)}, chatstore.NewChats(db.Pool), b, attachment.Config{})
if _, err := lost.Upload(ctx, actor, input, bytes.NewReader(data)); !errors.Is(err, io.ErrUnexpectedEOF) {
t.Fatal("lost commit reply:", err)
}
var source string
if err := db.Pool.QueryRow(ctx, `SELECT j.source_key FROM attachment_jobs j JOIN attachments a ON a.id=j.attachment_id WHERE a.filename='lost.png'`).Scan(&source); err != nil || !bytes.Equal(b.bodies[source], data) {
t.Fatal("committed job lost source", err)
}
_, err = db.Pool.Exec(ctx, `CREATE FUNCTION reject_job() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN RAISE EXCEPTION 'injected insert failure'; END $$;
CREATE TRIGGER reject_job BEFORE INSERT ON attachment_jobs FOR EACH ROW EXECUTE FUNCTION reject_job()`)
if err != nil {
t.Fatal(err)
}
other := append(bytes.Clone(data), 0)
input.Filename, input.SizeBytes = "rollback.png", int64(len(other))
if _, err := s.Upload(ctx, actor, input, bytes.NewReader(other)); err == nil {
t.Fatal("accepted rejected job")
}
if err := db.Pool.QueryRow(ctx, `SELECT (SELECT count(*) FROM files),(SELECT count(*) FROM attachments),(SELECT count(*) FROM attachment_jobs)`).Scan(&files, &atts, &jobs); err != nil || files != 1 || atts != 11 || jobs != 11 || len(b.objects) != 12 {
t.Fatalf("rollback: files=%d attachments=%d jobs=%d objects=%d err=%v", files, atts, jobs, len(b.objects), err)
}
}