182 lines
6.0 KiB
Go
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)
|
|
}
|
|
}
|