mirror of
https://github.com/usememos/memos.git
synced 2026-11-19 10:29:11 +01:00
218 lines
8.6 KiB
Go
218 lines
8.6 KiB
Go
package fileserver
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/usememos/memos/core/memoexport"
|
|
"github.com/usememos/memos/internal/httphandler"
|
|
"github.com/usememos/memos/internal/ratelimit"
|
|
apipb "github.com/usememos/memos/proto/gen/api"
|
|
"github.com/usememos/memos/server/api"
|
|
"github.com/usememos/memos/server/auth"
|
|
"github.com/usememos/memos/store"
|
|
)
|
|
|
|
type memoExportFixture struct {
|
|
svc *api.APIService
|
|
fs *FileServerService
|
|
stores *store.Store
|
|
mux *http.ServeMux
|
|
admin *store.User
|
|
member *store.User
|
|
}
|
|
|
|
func newMemoExportFixture(ctx context.Context, t *testing.T) (*memoExportFixture, func()) {
|
|
t.Helper()
|
|
svc, fs, stores, cleanup := newShareAttachmentTestServices(ctx, t)
|
|
fs.MemoExporter = svc
|
|
fs.RateLimiter = ratelimit.NewMemoryLimiter(ratelimit.DefaultPolicy())
|
|
|
|
admin, err := stores.CreateUser(ctx, &store.User{Username: "export-admin", Role: store.RoleAdmin, Email: "export-admin@example.com"})
|
|
require.NoError(t, err)
|
|
member, err := stores.CreateUser(ctx, &store.User{Username: "export-member", Role: store.RoleUser, Email: "export-member@example.com"})
|
|
require.NoError(t, err)
|
|
for _, owner := range []*store.User{admin, member} {
|
|
ownerCtx := context.WithValue(ctx, auth.UserIDContextKey, owner.ID)
|
|
for i := range 2 {
|
|
_, err := svc.CreateMemo(ownerCtx, &apipb.CreateMemoRequest{Memo: &apipb.Memo{
|
|
Content: fmt.Sprintf("%s memo %d", owner.Username, i),
|
|
Visibility: apipb.Visibility_PRIVATE,
|
|
}})
|
|
require.NoError(t, err)
|
|
}
|
|
}
|
|
|
|
mux := http.NewServeMux()
|
|
fs.RegisterRoutes(mux, http.HandlerFunc(httphandler.NotFound))
|
|
return &memoExportFixture{svc: svc, fs: fs, stores: stores, mux: mux, admin: admin, member: member}, cleanup
|
|
}
|
|
|
|
func (f *memoExportFixture) request(ctx context.Context, t *testing.T, method, username string, as *store.User) *httptest.ResponseRecorder {
|
|
t.Helper()
|
|
req := httptest.NewRequest(method, "/file/users/"+username+"/export", nil)
|
|
if as != nil {
|
|
req.AddCookie(newRefreshTokenCookie(ctx, t, f.stores, as.ID, f.svc.Secret))
|
|
}
|
|
recorder := httptest.NewRecorder()
|
|
f.mux.ServeHTTP(recorder, req)
|
|
return recorder
|
|
}
|
|
|
|
func TestServeMemoExport_AdminStreamsAnotherUsersArchive(t *testing.T) {
|
|
ctx := context.Background()
|
|
f, cleanup := newMemoExportFixture(ctx, t)
|
|
defer cleanup()
|
|
|
|
recorder := f.request(ctx, t, http.MethodGet, f.member.Username, f.admin)
|
|
require.Equal(t, http.StatusOK, recorder.Code)
|
|
require.Equal(t, memoexport.MediaType, recorder.Header().Get("Content-Type"))
|
|
require.Regexp(t, `^attachment; filename=memos-export-export-member-\d{8}T\d{6}Z\.zip$`, recorder.Header().Get("Content-Disposition"))
|
|
require.Equal(t, privateAttachmentCacheControl, recorder.Header().Get("Cache-Control"))
|
|
require.Equal(t, "nosniff", recorder.Header().Get("X-Content-Type-Options"))
|
|
|
|
archive, err := memoexport.Read(bytes.NewReader(recorder.Body.Bytes()), int64(recorder.Body.Len()))
|
|
require.NoError(t, err)
|
|
require.Equal(t, "export-member", archive.Manifest.Scope.User.Username)
|
|
require.Len(t, archive.Memos, 2)
|
|
for _, memo := range archive.Memos {
|
|
require.Equal(t, "export-member", memo.Creator)
|
|
}
|
|
|
|
own := f.request(ctx, t, http.MethodGet, f.admin.Username, f.admin)
|
|
require.Equal(t, http.StatusOK, own.Code)
|
|
ownArchive, err := memoexport.Read(bytes.NewReader(own.Body.Bytes()), int64(own.Body.Len()))
|
|
require.NoError(t, err)
|
|
require.Equal(t, "export-admin", ownArchive.Manifest.Scope.User.Username)
|
|
}
|
|
|
|
func TestServeMemoExport_RefusesMembersAndAnonymous(t *testing.T) {
|
|
ctx := context.Background()
|
|
f, cleanup := newMemoExportFixture(ctx, t)
|
|
defer cleanup()
|
|
|
|
require.Equal(t, http.StatusForbidden, f.request(ctx, t, http.MethodGet, f.member.Username, f.member).Code)
|
|
require.Equal(t, http.StatusForbidden, f.request(ctx, t, http.MethodGet, f.admin.Username, f.member).Code)
|
|
require.Equal(t, http.StatusUnauthorized, f.request(ctx, t, http.MethodGet, f.member.Username, nil).Code)
|
|
require.Equal(t, http.StatusNotFound, f.request(ctx, t, http.MethodGet, "nobody", f.admin).Code)
|
|
|
|
// The error envelope is JSON; nothing of the archive leaks.
|
|
forbidden := f.request(ctx, t, http.MethodGet, f.member.Username, f.member)
|
|
require.Equal(t, "application/json", forbidden.Header().Get("Content-Type"))
|
|
require.Contains(t, forbidden.Body.String(), "forbidden access")
|
|
}
|
|
|
|
func TestServeMemoExport_HeadPreflightChecksWithoutExporting(t *testing.T) {
|
|
ctx := context.Background()
|
|
f, cleanup := newMemoExportFixture(ctx, t)
|
|
defer cleanup()
|
|
|
|
head := f.request(ctx, t, http.MethodHead, f.member.Username, f.admin)
|
|
require.Equal(t, http.StatusOK, head.Code)
|
|
require.Equal(t, memoexport.MediaType, head.Header().Get("Content-Type"))
|
|
require.Regexp(t, `^attachment; filename=memos-export-export-member-`, head.Header().Get("Content-Disposition"))
|
|
require.Zero(t, head.Body.Len())
|
|
|
|
require.Equal(t, http.StatusForbidden, f.request(ctx, t, http.MethodHead, f.member.Username, f.member).Code)
|
|
require.Equal(t, http.StatusUnauthorized, f.request(ctx, t, http.MethodHead, f.member.Username, nil).Code)
|
|
|
|
// A preflight charges nothing: the full hourly budget is still available.
|
|
budget := ratelimit.DefaultPolicy()[ratelimit.ScopeArchiveUser].Limit
|
|
for range budget {
|
|
require.Equal(t, http.StatusOK, f.request(ctx, t, http.MethodHead, f.member.Username, f.admin).Code)
|
|
}
|
|
for range budget {
|
|
require.Equal(t, http.StatusOK, f.request(ctx, t, http.MethodGet, f.member.Username, f.admin).Code)
|
|
}
|
|
exhausted := f.request(ctx, t, http.MethodGet, f.member.Username, f.admin)
|
|
require.Equal(t, http.StatusTooManyRequests, exhausted.Code)
|
|
require.NotEmpty(t, exhausted.Header().Get("Retry-After"))
|
|
require.Equal(t, http.StatusTooManyRequests, f.request(ctx, t, http.MethodHead, f.member.Username, f.admin).Code)
|
|
}
|
|
|
|
// stubExporter stands in for the API service. It parks inside WriteMemoExport
|
|
// until released, so a test can observe a running export, or fails before
|
|
// writing a byte when err is set.
|
|
type stubExporter struct {
|
|
started chan struct{}
|
|
release chan struct{}
|
|
err error
|
|
}
|
|
|
|
func (e *stubExporter) WriteMemoExport(ctx context.Context, _ *store.User, w io.Writer, _ time.Time) error {
|
|
if e.err != nil {
|
|
return e.err
|
|
}
|
|
close(e.started)
|
|
select {
|
|
case <-e.release:
|
|
case <-ctx.Done():
|
|
return ctx.Err()
|
|
}
|
|
_, err := w.Write([]byte("PK"))
|
|
return err
|
|
}
|
|
|
|
func TestServeMemoExport_OneExportAtATime(t *testing.T) {
|
|
ctx := context.Background()
|
|
f, cleanup := newMemoExportFixture(ctx, t)
|
|
defer cleanup()
|
|
|
|
exporter := &stubExporter{started: make(chan struct{}), release: make(chan struct{})}
|
|
f.fs.MemoExporter = exporter
|
|
running := make(chan *httptest.ResponseRecorder, 1)
|
|
go func() { running <- f.request(ctx, t, http.MethodGet, f.member.Username, f.admin) }()
|
|
<-exporter.started
|
|
|
|
// The lock spans the whole export: while one streams, another is refused.
|
|
busy := f.request(ctx, t, http.MethodGet, f.member.Username, f.admin)
|
|
require.Equal(t, http.StatusTooManyRequests, busy.Code)
|
|
require.Contains(t, busy.Body.String(), "another export is running")
|
|
require.Equal(t, http.StatusTooManyRequests, f.request(ctx, t, http.MethodHead, f.member.Username, f.admin).Code)
|
|
|
|
close(exporter.release)
|
|
require.Equal(t, http.StatusOK, (<-running).Code)
|
|
|
|
// The refused request refunded its budget unit and the lock is free again.
|
|
f.fs.MemoExporter = f.svc
|
|
require.Equal(t, http.StatusOK, f.request(ctx, t, http.MethodGet, f.member.Username, f.admin).Code)
|
|
require.Equal(t, ratelimit.DefaultPolicy()[ratelimit.ScopeArchiveUser].Limit-2,
|
|
f.fs.RateLimiter.Allowed(ratelimit.ScopeArchiveUser, fmt.Sprint(f.admin.ID), 1).Remaining)
|
|
}
|
|
|
|
func TestServeMemoExport_FailureBeforeFirstByteIsAnErrorResponse(t *testing.T) {
|
|
ctx := context.Background()
|
|
f, cleanup := newMemoExportFixture(ctx, t)
|
|
defer cleanup()
|
|
|
|
f.fs.MemoExporter = &stubExporter{err: errors.New("storage unavailable")}
|
|
failed := f.request(ctx, t, http.MethodGet, f.member.Username, f.admin)
|
|
require.Equal(t, http.StatusInternalServerError, failed.Code)
|
|
require.Equal(t, "application/json", failed.Header().Get("Content-Type"))
|
|
require.Empty(t, failed.Header().Get("Content-Disposition"))
|
|
require.Contains(t, failed.Body.String(), "failed to export memos")
|
|
require.NotContains(t, failed.Body.String(), "storage unavailable")
|
|
|
|
// The lock is released after a failure.
|
|
f.fs.MemoExporter = f.svc
|
|
require.Equal(t, http.StatusOK, f.request(ctx, t, http.MethodGet, f.member.Username, f.admin).Code)
|
|
}
|
|
|
|
func TestServeMemoExport_RouteDisabledWithoutExporter(t *testing.T) {
|
|
ctx := context.Background()
|
|
f, cleanup := newMemoExportFixture(ctx, t)
|
|
defer cleanup()
|
|
|
|
f.fs.MemoExporter = nil
|
|
require.Equal(t, http.StatusNotFound, f.request(ctx, t, http.MethodGet, f.member.Username, f.admin).Code)
|
|
}
|