mirror of
https://github.com/usememos/memos.git
synced 2026-11-19 10:29:11 +01:00
153 lines
5.9 KiB
Go
153 lines
5.9 KiB
Go
package test
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"net/http"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// TestUsageLimitRefusalOnBothTransports proves the quota refusal contract on
|
|
// the wire: HTTP 429 with an ErrorInfo of reason QUOTA_EXCEEDED and a
|
|
// QuotaFailure, and no Retry-After or RateLimit fields, because waiting does
|
|
// not lift a usage limit. It also proves that the usage limits setting and
|
|
// the user usage routes reach their handlers. Admins are limited like
|
|
// everyone else, so the first user is enough.
|
|
func TestUsageLimitRefusalOnBothTransports(t *testing.T) {
|
|
ctx := context.Background()
|
|
inst := bootInstance(ctx, t, instanceOptions{instanceURL: "http://127.0.0.1"})
|
|
inst.createAdmin(t)
|
|
token := inst.signIn(t)
|
|
|
|
send := func(method, path string, body any, headers map[string]string) *http.Response {
|
|
t.Helper()
|
|
encoded, err := json.Marshal(body)
|
|
require.NoError(t, err)
|
|
req, err := http.NewRequestWithContext(ctx, method, inst.baseURL+path, bytes.NewReader(encoded))
|
|
require.NoError(t, err)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("Authorization", "Bearer "+token)
|
|
for key, value := range headers {
|
|
req.Header.Set(key, value)
|
|
}
|
|
resp, err := inst.client.Do(req)
|
|
require.NoError(t, err)
|
|
return resp
|
|
}
|
|
|
|
status, body := inst.do(t, http.MethodPatch, "/api/instance/settings/USAGE_LIMITS", token, map[string]any{
|
|
"usageLimitsSetting": map[string]any{
|
|
"limits": []map[string]any{{"allUsers": true, "memoCount": "1", "memoContentBytes": "8192", "uploadBytes": "33554432"}},
|
|
},
|
|
})
|
|
require.Equal(t, http.StatusOK, status, "replacing the usage limits should succeed: %s", body)
|
|
|
|
status, body = inst.do(t, http.MethodGet, "/api/instance/settings/USAGE_LIMITS", token, nil)
|
|
require.Equal(t, http.StatusOK, status, "%s", body)
|
|
var setting struct {
|
|
Name string `json:"name"`
|
|
UsageLimitsSetting struct {
|
|
Limits []struct {
|
|
AllUsers bool `json:"allUsers"`
|
|
MemoCount string `json:"memoCount"`
|
|
MemoContentBytes string `json:"memoContentBytes"`
|
|
UploadBytes string `json:"uploadBytes"`
|
|
} `json:"limits"`
|
|
} `json:"usageLimitsSetting"`
|
|
}
|
|
require.NoError(t, json.Unmarshal(body, &setting))
|
|
require.Equal(t, "instance/settings/USAGE_LIMITS", setting.Name)
|
|
require.Len(t, setting.UsageLimitsSetting.Limits, 1)
|
|
require.True(t, setting.UsageLimitsSetting.Limits[0].AllUsers)
|
|
require.Equal(t, "1", setting.UsageLimitsSetting.Limits[0].MemoCount)
|
|
require.Equal(t, "8192", setting.UsageLimitsSetting.Limits[0].MemoContentBytes)
|
|
require.Equal(t, "33554432", setting.UsageLimitsSetting.Limits[0].UploadBytes)
|
|
|
|
inst.createMemo(t, token, "first", "the only memo the limit allows")
|
|
|
|
userName := "users/" + testAdminUsername
|
|
status, body = inst.do(t, http.MethodGet, "/api/"+userName+"/usage", token, nil)
|
|
require.Equal(t, http.StatusOK, status, "%s", body)
|
|
var usage struct {
|
|
Name string `json:"name"`
|
|
MemoCount string `json:"memoCount"`
|
|
Limits struct {
|
|
MemoCount string `json:"memoCount"`
|
|
} `json:"limits"`
|
|
LimitIndex int `json:"limitIndex"`
|
|
}
|
|
require.NoError(t, json.Unmarshal(body, &usage))
|
|
require.Equal(t, userName+"/usage", usage.Name)
|
|
require.Equal(t, "1", usage.MemoCount)
|
|
require.Equal(t, "1", usage.Limits.MemoCount)
|
|
require.Equal(t, 0, usage.LimitIndex)
|
|
|
|
requireNoWaitHeaders := func(resp *http.Response) {
|
|
t.Helper()
|
|
require.Empty(t, resp.Header.Get("Retry-After"))
|
|
require.Empty(t, resp.Header.Get("RateLimit"))
|
|
require.Empty(t, resp.Header.Get("RateLimit-Policy"))
|
|
}
|
|
memo := map[string]any{"content": "over the limit", "visibility": "PRIVATE"}
|
|
|
|
refused := send(http.MethodPost, "/api/memos", memo, nil)
|
|
defer refused.Body.Close()
|
|
require.Equal(t, http.StatusTooManyRequests, refused.StatusCode)
|
|
requireNoWaitHeaders(refused)
|
|
var gatewayError struct {
|
|
Code int `json:"code"`
|
|
Message string `json:"message"`
|
|
Details []struct {
|
|
Type string `json:"@type"`
|
|
Reason string `json:"reason"`
|
|
Domain string `json:"domain"`
|
|
Metadata map[string]string `json:"metadata"`
|
|
Violations []struct {
|
|
Subject string `json:"subject"`
|
|
} `json:"violations"`
|
|
} `json:"details"`
|
|
}
|
|
require.NoError(t, json.NewDecoder(refused.Body).Decode(&gatewayError))
|
|
require.Equal(t, 8, gatewayError.Code, "RESOURCE_EXHAUSTED")
|
|
require.Equal(t, "quota exceeded", gatewayError.Message)
|
|
types := []string{}
|
|
for _, detail := range gatewayError.Details {
|
|
types = append(types, detail.Type)
|
|
switch detail.Type {
|
|
case "type.googleapis.com/google.rpc.ErrorInfo":
|
|
require.Equal(t, "QUOTA_EXCEEDED", detail.Reason)
|
|
require.Equal(t, "memos.api", detail.Domain)
|
|
require.Equal(t, map[string]string{"metric": "MEMO_COUNT", "limit": "1", "usage": "1"}, detail.Metadata)
|
|
case "type.googleapis.com/google.rpc.QuotaFailure":
|
|
require.Len(t, detail.Violations, 1)
|
|
require.Equal(t, userName, detail.Violations[0].Subject)
|
|
default:
|
|
t.Fatalf("unexpected error detail %s", detail.Type)
|
|
}
|
|
}
|
|
require.ElementsMatch(t, []string{"type.googleapis.com/google.rpc.ErrorInfo", "type.googleapis.com/google.rpc.QuotaFailure"}, types)
|
|
|
|
connectResp := send(http.MethodPost, "/memos.api.MemoService/CreateMemo", map[string]any{"memo": memo}, map[string]string{"Connect-Protocol-Version": "1"})
|
|
defer connectResp.Body.Close()
|
|
require.Equal(t, http.StatusTooManyRequests, connectResp.StatusCode)
|
|
requireNoWaitHeaders(connectResp)
|
|
var connectError struct {
|
|
Code string `json:"code"`
|
|
Message string `json:"message"`
|
|
Details []struct {
|
|
Type string `json:"type"`
|
|
} `json:"details"`
|
|
}
|
|
require.NoError(t, json.NewDecoder(connectResp.Body).Decode(&connectError))
|
|
require.Equal(t, "resource_exhausted", connectError.Code)
|
|
require.Equal(t, "quota exceeded", connectError.Message)
|
|
connectTypes := []string{}
|
|
for _, detail := range connectError.Details {
|
|
connectTypes = append(connectTypes, detail.Type)
|
|
}
|
|
require.ElementsMatch(t, []string{"google.rpc.ErrorInfo", "google.rpc.QuotaFailure"}, connectTypes)
|
|
}
|