forked from mtusi2026/mtusi2026lab4
172 lines
6.1 KiB
Go
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)
|
|
}
|
|
}
|