Files
mtusi2026lab4/internal/pkg/repository/postgres/lab4_test.go
T
2026-10-28 22:41:10 +03:00

342 lines
11 KiB
Go

package postgres_test
import (
"bufio"
"bytes"
"context"
"encoding/xml"
"fmt"
"image"
"image/png"
"io"
"net/http"
"net/http/httptest"
"strconv"
"strings"
"sync"
"testing"
"time"
"gitflic.ru/akselbant/mtusi2026lab1-fork/internal/attachment"
"gitflic.ru/akselbant/mtusi2026lab1-fork/internal/pkg/domain"
"gitflic.ru/akselbant/mtusi2026lab1-fork/internal/pkg/repository/postgres"
"github.com/google/uuid"
"github.com/jackc/pgx/v5/pgxpool"
"github.com/minio/minio-go/v7"
"github.com/minio/minio-go/v7/pkg/credentials"
)
type fakeObject struct {
data []byte
modified time.Time
}
type fakeS3 struct {
mu sync.Mutex
objects map[string]fakeObject
failPUT bool
}
func (f *fakeS3) ServeHTTP(w http.ResponseWriter, r *http.Request) {
f.mu.Lock()
defer f.mu.Unlock()
key := strings.TrimPrefix(r.URL.Path, "/attachments/")
if r.Method == "GET" && r.URL.Path == "/attachments/" || r.Method == "GET" && r.URL.Path == "/attachments" {
type item struct {
Key string
LastModified string
ETag string
Size int
}
type listing struct {
XMLName xml.Name `xml:"ListBucketResult"`
Xmlns string `xml:"xmlns,attr"`
Name string
Prefix string
MaxKeys int
IsTruncated bool
Contents []item
}
l := listing{Xmlns: "http://s3.amazonaws.com/doc/2006-03-01/", Name: "attachments", Prefix: r.URL.Query().Get("prefix"), MaxKeys: 1000}
for k, v := range f.objects {
if strings.HasPrefix(k, l.Prefix) {
l.Contents = append(l.Contents, item{Key: k, LastModified: v.modified.UTC().Format("2006-01-02T15:04:05.000Z"), ETag: `"abc"`, Size: len(v.data)})
}
}
w.Header().Set("Content-Type", "application/xml")
xml.NewEncoder(w).Encode(l)
return
}
if r.Method == "PUT" {
if f.failPUT {
w.WriteHeader(503)
fmt.Fprint(w, `<Error><Code>ServiceUnavailable</Code></Error>`)
return
}
var data []byte
var err error
if strings.Contains(r.Header.Get("Content-Encoding"), "aws-chunked") || strings.HasPrefix(r.Header.Get("X-Amz-Content-Sha256"), "STREAMING-") {
reader := bufio.NewReader(r.Body)
for {
line, e := reader.ReadString('\n')
if e != nil {
err = e
break
}
size, e := strconv.ParseInt(strings.Split(strings.TrimSpace(line), ";")[0], 16, 64)
if e != nil {
err = e
break
}
if size == 0 {
break
}
chunk := make([]byte, size)
if _, e = io.ReadFull(reader, chunk); e != nil {
err = e
break
}
data = append(data, chunk...)
if _, e = reader.Discard(2); e != nil {
err = e
break
}
}
} else {
data, err = io.ReadAll(r.Body)
}
if err != nil {
w.WriteHeader(400)
return
}
f.objects[key] = fakeObject{data: data, modified: time.Now().UTC()}
w.Header().Set("ETag", `"900150983cd24fb0d6963f7d28e17f72"`)
w.WriteHeader(200)
return
}
obj, ok := f.objects[key]
if !ok {
w.WriteHeader(404)
if r.Method != "HEAD" {
fmt.Fprint(w, `<Error><Code>NoSuchKey</Code></Error>`)
}
return
}
if r.Method == "DELETE" {
delete(f.objects, key)
w.WriteHeader(204)
return
}
w.Header().Set("Last-Modified", obj.modified.UTC().Format(http.TimeFormat))
w.Header().Set("ETag", `"abc"`)
w.Header().Set("Content-Length", fmt.Sprint(len(obj.data)))
w.Header().Set("Content-Type", "image/png")
if r.Method == "GET" {
w.Write(obj.data)
}
}
func lab4Backend(t *testing.T, pool *pgxpool.Pool, repo *postgres.Storage, user domain.User, chat domain.Chat) {
ctx := context.Background()
fake := &fakeS3{objects: map[string]fakeObject{}}
server := httptest.NewServer(fake)
defer server.Close()
client, err := minio.New(strings.TrimPrefix(server.URL, "http://"), &minio.Options{Creds: credentials.NewStaticV4("test-key", "test-secret", ""), Region: "us-east-1", MaxRetries: 1})
if err != nil {
t.Fatal(err)
}
service := attachment.New(pool, &attachment.Store{Client: client, Bucket: "attachments"})
var imageBytes bytes.Buffer
if err = png.Encode(&imageBytes, image.NewRGBA(image.Rect(0, 0, 10, 8))); err != nil {
t.Fatal(err)
}
upload := func(name string) attachment.Attachment {
t.Helper()
a, e := service.Upload(ctx, chat.ID, user.ID, name, "image/png", bytes.NewReader(imageBytes.Bytes()))
if e != nil {
t.Fatal(e)
}
return a
}
first := upload("first.png")
second := upload("second.png")
requireCode := func(err error, want domain.ErrorCode) {
t.Helper()
e, ok := domain.AsApplicationError(err)
if !ok || e.Code != want {
t.Fatalf("expected %s, got %v", want, err)
}
}
outside, err := repo.CreateUser(ctx, "attachment_outsider", "Outside", "hash")
if err != nil {
t.Fatal(err)
}
_, err = service.Get(ctx, first.ID, outside.ID)
requireCode(err, domain.ErrorNotFound)
obj, err := service.Content(ctx, first)
if err != nil {
t.Fatal(err)
}
data, err := io.ReadAll(obj)
obj.Close()
if err != nil || !bytes.Equal(data, imageBytes.Bytes()) {
t.Fatalf("original mismatch: %v", err)
}
otherChat, err := repo.CreateChat(ctx, "Other", []string{user.ID})
if err != nil {
t.Fatal(err)
}
_, err = repo.CreateMessageWithAttachments(ctx, otherChat.ID, user.ID, "", "cross-chat", []string{first.ID})
requireCode(err, domain.ErrorNotFound)
_, err = repo.CreateMessageWithAttachments(ctx, chat.ID, user.ID, "", "unknown", []string{uuid.NewString()})
requireCode(err, domain.ErrorNotFound)
sent, err := repo.CreateMessageWithAttachments(ctx, chat.ID, user.ID, "", "ordered", []string{first.ID, second.ID})
if err != nil {
t.Fatal(err)
}
replay, err := repo.CreateMessageWithAttachments(ctx, chat.ID, user.ID, "", "ordered", []string{first.ID, second.ID})
if err != nil || sent.ID != replay.ID {
t.Fatalf("replay failed: %v", err)
}
_, err = repo.CreateMessageWithAttachments(ctx, chat.ID, user.ID, "", "ordered", []string{second.ID, first.ID})
requireCode(err, domain.ErrorConflict)
textOnly, err := repo.CreateMessageWithAttachments(ctx, chat.ID, user.ID, "text", "empty-equivalent", nil)
if err != nil {
t.Fatal(err)
}
replay, err = repo.CreateMessageWithAttachments(ctx, chat.ID, user.ID, "text", "empty-equivalent", []string{})
if err != nil || textOnly.ID != replay.ID {
t.Fatalf("absent/empty differs: %v", err)
}
const callers = 12
outcomes := make(chan domain.Message, callers)
failures := make(chan error, callers)
var concurrent sync.WaitGroup
start := make(chan struct{})
for i := 0; i < callers; i++ {
concurrent.Add(1)
go func() {
defer concurrent.Done()
<-start
m, e := repo.CreateMessageWithAttachments(ctx, chat.ID, user.ID, "", "concurrent-attachments", []string{first.ID, second.ID})
if e != nil {
failures <- e
} else {
outcomes <- m
}
}()
}
close(start)
concurrent.Wait()
close(outcomes)
close(failures)
for e := range failures {
t.Fatal(e)
}
identity := ""
for m := range outcomes {
if identity == "" {
identity = m.ID
}
if m.ID != identity {
t.Fatal("duplicate concurrent attachment message")
}
}
var effects int
if err = pool.QueryRow(ctx, `SELECT count(*) FROM messages WHERE chat_id=$1 AND idempotency_key='concurrent-attachments'`, chat.ID).Scan(&effects); err != nil || effects != 1 {
t.Fatalf("concurrent effects=%d %v", effects, err)
}
t.Log("ACL, original bytes, cross-chat attachment rejection, ordered/concurrent idempotency and absent=[] passed")
old := time.Now().Add(-3 * time.Minute)
orphan := "original/" + uuid.NewString()
fresh := "original/" + uuid.NewString()
locked := "original/" + uuid.NewString()
fake.mu.Lock()
delete(fake.objects, first.Key)
v := fake.objects[second.Key]
v.modified = old
fake.objects[second.Key] = v
fake.objects[orphan] = fakeObject{data: []byte("orphan"), modified: old}
fake.objects[fresh] = fakeObject{data: []byte("fresh"), modified: time.Now()}
fake.objects[locked] = fakeObject{data: []byte("locked"), modified: old}
fake.mu.Unlock()
if _, err = pool.Exec(ctx, `UPDATE attachments SET created_at=$1 WHERE id=ANY($2::uuid[])`, old, []string{first.ID, second.ID}); err != nil {
t.Fatal(err)
}
hold, err := pool.Begin(ctx)
if err != nil {
t.Fatal(err)
}
defer hold.Rollback(ctx)
if _, err = hold.Exec(ctx, `SELECT pg_advisory_xact_lock(hashtextextended($1,0))`, locked); err != nil {
t.Fatal(err)
}
dry, err := service.Reconcile(ctx, false, 90*time.Second)
if err != nil {
t.Fatal(err)
}
if dry.Orphans != 1 || dry.Missing != 1 || dry.ReferencedMissing != 1 || dry.LockedSkipped != 1 || dry.FreshSkipped < 1 || dry.Deleted != 0 || dry.MarkedFailed != 0 {
t.Fatalf("bad dry-run %+v", dry)
}
var status string
if err = pool.QueryRow(ctx, `SELECT status FROM attachments WHERE id=$1`, first.ID).Scan(&status); err != nil || status != "ready" {
t.Fatalf("dry-run mutated metadata %s %v", status, err)
}
applied, err := service.Reconcile(ctx, true, 90*time.Second)
if err != nil {
t.Fatal(err)
}
if applied.Deleted != 1 || applied.MarkedFailed != 1 {
t.Fatalf("bad apply %+v", applied)
}
fake.mu.Lock()
_, hasOrphan := fake.objects[orphan]
_, hasFresh := fake.objects[fresh]
_, hasLinked := fake.objects[second.Key]
_, hasLocked := fake.objects[locked]
fake.mu.Unlock()
if hasOrphan || !hasFresh || !hasLinked || !hasLocked {
t.Fatal("unsafe object cleanup")
}
_, err = service.Get(ctx, first.ID, user.ID)
requireCode(err, domain.ErrorConflict)
_, err = repo.CreateMessageWithAttachments(ctx, chat.ID, user.ID, "", "failed-attachment", []string{first.ID})
requireCode(err, domain.ErrorConflict)
replay, err = repo.CreateMessageWithAttachments(ctx, chat.ID, user.ID, "", "ordered", []string{first.ID, second.ID})
if err != nil || replay.ID != sent.ID {
t.Fatalf("historical replay changed after missing: %v", err)
}
repeated, err := service.Reconcile(ctx, true, 90*time.Second)
if err != nil {
t.Fatal(err)
}
if repeated.Deleted != 0 || repeated.MarkedFailed != 0 || repeated.Orphans != 0 || repeated.Missing != 0 {
t.Fatalf("not repeatable %+v", repeated)
}
t.Logf("dry-run=%+v apply=%+v repeat=%+v; fresh, locked and referenced objects retained", dry, applied, repeated)
}
func TestS3WireFixture(t *testing.T) {
fake := &fakeS3{objects: map[string]fakeObject{}}
server := httptest.NewServer(fake)
defer server.Close()
client, err := minio.New(strings.TrimPrefix(server.URL, "http://"), &minio.Options{Creds: credentials.NewStaticV4("test-key", "test-secret", ""), Region: "us-east-1", MaxRetries: 1})
if err != nil {
t.Fatal(err)
}
payload := []byte("exact object bytes")
_, err = client.PutObject(context.Background(), "attachments", "original/test", bytes.NewReader(payload), int64(len(payload)), minio.PutObjectOptions{ContentType: "image/png", DisableMultipart: true})
if err != nil {
t.Fatal(err)
}
obj, err := client.GetObject(context.Background(), "attachments", "original/test", minio.GetObjectOptions{})
if err != nil {
t.Fatal(err)
}
defer obj.Close()
got, err := io.ReadAll(obj)
if err != nil || !bytes.Equal(got, payload) {
t.Fatalf("wire fixture did not store original: %q %v", got, err)
}
}