Files
pages/internal/server/upload_handler_test.go
Anya Tokugawa b90aef79d0
Build and publish container images / images (push) Successful in 11m37s
Release container images / release (push) Successful in 22s
feat: add browser upload queue and trusted sessions with bounded projections
2026-11-08 20:27:04 +09:00

142 lines
3.9 KiB
Go

package server
import (
"bytes"
"encoding/json"
"mime/multipart"
"net/http"
"net/http/httptest"
"testing"
"pageswiki/internal/db"
"pageswiki/internal/store"
)
func TestWebUploadCreatesAndRevisesSpecifiedPath(t *testing.T) {
database, err := db.Open(t.TempDir() + "/pages.db")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = database.Close() })
if err := db.Migrate(database); err != nil {
t.Fatal(err)
}
st := store.New(database)
campus, err := st.GetDefaultCampus()
if err != nil {
t.Fatal(err)
}
srv := &Server{store: st}
upload := func(payload string) *httptest.ResponseRecorder {
t.Helper()
var body bytes.Buffer
writer := multipart.NewWriter(&body)
if err := writer.WriteField("path", "/uploads/manual"); err != nil {
t.Fatal(err)
}
part, err := writer.CreateFormFile("file", "manual.txt")
if err != nil {
t.Fatal(err)
}
if _, err := part.Write([]byte(payload)); err != nil {
t.Fatal(err)
}
if err := writer.Close(); err != nil {
t.Fatal(err)
}
request := httptest.NewRequest(http.MethodPost, "/v/upload", &body)
request.Host = campus.FQDN
request.Header.Set("Content-Type", writer.FormDataContentType())
response := httptest.NewRecorder()
srv.handleUpload(response, request)
return response
}
for _, payload := range []string{"first", "second"} {
response := upload(payload)
if response.Code != http.StatusSeeOther {
t.Fatalf("upload status = %d, body=%q", response.Code, response.Body.String())
}
if location := response.Header().Get("Location"); location != "/uploads/manual" {
t.Fatalf("redirect = %q", location)
}
}
objectUUID, err := st.ResolvePathInDomain(
mustServerDomainUUID(t, st),
"/uploads/manual",
)
if err != nil {
t.Fatal(err)
}
revisions, err := st.ListRevisions(objectUUID)
if err != nil {
t.Fatal(err)
}
if len(revisions) != 2 {
t.Fatalf("revision count = %d, want 2", len(revisions))
}
latest, err := st.GetRevision(revisions[0].UUID)
if err != nil {
t.Fatal(err)
}
if latest.Body != "second" || latest.Filename != "manual.txt" {
t.Fatalf("latest upload = body %q filename %q", latest.Body, latest.Filename)
}
}
func TestWebUploadCreateOnlyJSON(t *testing.T) {
s, token, domain := configFixture(t)
upload := func(payload string, authenticated bool) *httptest.ResponseRecorder {
var body bytes.Buffer
writer := multipart.NewWriter(&body)
writer.WriteField("path", "/uploads/日本語 #1.txt")
file, _ := writer.CreateFormFile("file", "日本語 #1.txt")
file.Write([]byte(payload))
writer.Close()
r := httptest.NewRequest("POST", "http://localhost/v/upload", &body)
r.Header.Set("Content-Type", writer.FormDataContentType())
r.Header.Set("Accept", "application/json")
r.Header.Set("If-None-Match", "*")
if authenticated {
r.Header.Set("Authorization", "Bearer "+token)
}
w := httptest.NewRecorder()
s.handleUpload(w, r)
return w
}
if w := upload("denied", false); w.Code != 403 {
t.Fatalf("unauthorized: %d", w.Code)
}
w := upload("original", true)
var result map[string]string
if w.Code != 201 || json.Unmarshal(w.Body.Bytes(), &result) != nil || result["path"] != "/uploads/日本語 #1.txt" || result["revision_uuid"] == "" {
t.Fatalf("JSON upload %d %s", w.Code, w.Body.String())
}
if w = upload("overwrite", true); w.Code != 412 {
t.Fatalf("duplicate: %d %s", w.Code, w.Body.String())
}
object, err := s.store.ResolvePathInDomain(domain, result["path"])
if err != nil {
t.Fatal(err)
}
revisions, err := s.store.ListRevisions(object)
if err != nil || len(revisions) != 1 {
t.Fatalf("unexpected revisions %d %v", len(revisions), err)
}
rev, err := s.store.GetRevision(revisions[0].UUID)
if err != nil || rev.Body != "original" {
t.Fatal("overwritten", err)
}
}
func mustServerDomainUUID(t *testing.T, st *store.Store) string {
t.Helper()
domain, err := st.GetDefaultDomain()
if err != nil {
t.Fatal(err)
}
return domain.UUID
}