142 lines
3.9 KiB
Go
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
|
|
}
|