Files
mtusi2026lab4-fork/src/backend/tests/attachment_http_test.go
T

172 lines
6.1 KiB
Go

package tests
import (
"bytes"
"context"
"encoding/binary"
"encoding/json"
"hash/crc32"
"io"
"net"
"net/http"
"net/http/httptest"
"net/url"
"os"
"strings"
"testing"
"time"
"messenger/src/backend/handlers"
"messenger/src/backend/repositories"
"messenger/src/backend/services"
"github.com/google/uuid"
)
func attachmentRouter(f *testFixture, objects *repositories.ObjectStore) http.Handler {
users := services.NewUserService(f.users)
return handlers.NewRouter(services.NewHealthService(repositories.NewHealthStore(f.db), f.sessionStore), users, f.sessions, services.NewChatService(f.chats), services.NewMessageService(f.messages), services.NewAttachmentService(repositories.NewAttachmentStore(f.db), objects))
}
func attachmentCall(t *testing.T, f *testFixture, router http.Handler, method, path, user, mime string, body []byte, status int) *httptest.ResponseRecorder {
t.Helper()
r := httptest.NewRequest(method, path, bytes.NewReader(body))
if mime != "" {
r.Header.Set("Content-Type", mime)
}
if method == "POST" && strings.HasSuffix(path, "/messages") {
r.Header.Set("Idempotency-Key", uuid.NewString())
}
if user != "" {
authorizeTestRequest(t, f, r, user)
}
w := httptest.NewRecorder()
router.ServeHTTP(w, r)
if w.Code != status {
t.Fatalf("%s %s: expected %d, got %d: %s", method, path, status, w.Code, w.Body.String())
}
if status >= 400 {
var error struct {
Error struct {
RequestID string `json:"request_id"`
}
}
if err := json.Unmarshal(w.Body.Bytes(), &error); err != nil || error.Error.RequestID != w.Header().Get("X-Request-Id") {
t.Fatal("invalid error envelope")
}
}
return w
}
func TestAttachmentValidationHTTP(t *testing.T) {
f, _, objects, user, chat := uploadFixture(t)
router := attachmentRouter(f, objects)
path := "/api/v1/chats/" + chat + "/attachments?filename=photo.png"
png := uploadPNG(t)
for _, sample := range []struct {
body []byte
mime string
status int
}{{bytes.Repeat([]byte("x"), 10485761), "image/png", 413}, {png[:40], "image/png", 415}, {png, "image/jpeg", 415}, {png, "text/plain", 415}} {
attachmentCall(t, f, router, "POST", path, user, sample.mime, sample.body, sample.status)
}
huge := append([]byte(nil), png...)
binary.BigEndian.PutUint32(huge[16:20], 10001)
binary.BigEndian.PutUint32(huge[20:24], 4000)
binary.BigEndian.PutUint32(huge[29:33], crc32.ChecksumIEEE(huge[12:29]))
attachmentCall(t, f, router, "POST", path, user, "image/png", huge, 413)
for _, name := range []string{"", " ", "../file.png", `a\b.png`, "a\x00.png", "a\n.png", strings.Repeat("x", 256)} {
attachmentCall(t, f, router, "POST", "/api/v1/chats/"+chat+"/attachments?"+url.Values{"filename": {name}}.Encode(), user, "image/png", png, 400)
}
// Exercise the real HTTP chunked path without Content-Length.
server := httptest.NewServer(router)
defer server.Close()
token, _, err := f.sessions.CreateForUser(context.Background(), user)
if err != nil {
t.Fatal(err)
}
reader, writer := io.Pipe()
done := make(chan struct{})
go func() {
defer close(done)
defer writer.Close()
io.Copy(writer, bytes.NewReader(bytes.Repeat([]byte("x"), 10485761)))
}()
request, err := http.NewRequest("POST", server.URL+path, reader)
if err != nil {
t.Fatal(err)
}
request.Header.Set("Authorization", "Bearer "+token)
request.Header.Set("Content-Type", "image/png")
response, err := server.Client().Do(request)
if err != nil {
reader.Close()
<-done
t.Fatal(err)
}
response.Body.Close()
reader.Close()
<-done
if response.StatusCode != 413 {
t.Fatalf("chunked limit: %d", response.StatusCode)
}
}
func TestAttachmentAccessHTTP(t *testing.T) {
f, store, objects, user, chat := uploadFixture(t)
router := attachmentRouter(f, objects)
eve, _ := createTestUser(t, f.users, "eve", "Eve")
other := createTestChat(t, f.chats, "Other", []string{user})
a, err := services.NewAttachmentService(store, objects).Upload(context.Background(), user, chat, "photo.png", "image/png", bytes.NewReader(uploadPNG(t)))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { objects.Delete(context.Background(), a.ObjectKey) })
for _, suffix := range []string{"", "/content"} {
path := "/api/v1/attachments/" + a.ID + suffix
attachmentCall(t, f, router, "GET", path, eve.ID, "", nil, 404)
attachmentCall(t, f, router, "GET", path, "", "", nil, 401)
}
attachmentCall(t, f, router, "POST", "/api/v1/chats/"+chat+"/attachments?filename=photo.png", eve.ID, "image/png", uploadPNG(t), 404)
for _, target := range []string{uuid.NewString(), a.ID} {
attachmentCall(t, f, router, "POST", "/api/v1/chats/"+other.ID+"/messages", user, "application/json", []byte(`{"text":"","attachment_ids":["`+target+`"]}`), 404)
}
attachmentCall(t, f, router, "POST", "/api/v1/chats/"+chat+"/messages", user, "application/json", []byte(`{"text":"","attachment_ids":["`+a.ID+`","`+a.ID+`"]}`), 400)
}
func TestUploadRecoveryHTTPDisconnect(t *testing.T) {
f, _, objects, user, chat := uploadFixture(t)
directory := t.TempDir()
t.Setenv("UPLOAD_TMP_DIR", directory)
completed := make(chan struct{})
router := attachmentRouter(f, objects)
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { defer close(completed); router.ServeHTTP(w, r) }))
defer server.Close()
token, _, err := f.sessions.CreateForUser(context.Background(), user)
if err != nil {
t.Fatal(err)
}
address := strings.TrimPrefix(server.URL, "http://")
connection, err := net.Dial("tcp", address)
if err != nil {
t.Fatal(err)
}
raw := "POST /api/v1/chats/" + chat + "/attachments?filename=aborted.png HTTP/1.1\r\nHost: " + address + "\r\nAuthorization: Bearer " + token + "\r\nContent-Type: image/png\r\nContent-Length: 10485760\r\n\r\npartial"
if _, err = io.WriteString(connection, raw); err != nil {
t.Fatal(err)
}
connection.Close()
select {
case <-completed:
case <-time.After(5 * time.Second):
t.Fatal("disconnected upload did not stop")
}
var count int
f.db.QueryRow(context.Background(), "SELECT count(*) FROM upload_attempts").Scan(&count)
if count != 0 {
t.Fatal("incomplete HTTP body reserved an object")
}
files, err := os.ReadDir(directory)
if err != nil || len(files) > 0 {
t.Fatalf("temporary paths remain: %v %v", files, err)
}
}