Files
mtusi2026lab2/app/internal/api/http/limits_test.go
T

313 lines
10 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package http
import (
"bytes"
"context"
"encoding/json"
"fmt"
"io"
"net/http"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/api/http/dto"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/config"
"gitflic.ru/project/relationskatie/mtusi2026lab1-ashchkl/internal/session"
)
func TestLimits_PayloadTooLarge(t *testing.T) {
r := newTestRigWithLimits(t, config.Limits{
MaxBodyBytes: 256,
MaxInFlight: 16,
MaxMessagesGlobal: 100,
MaxHeapBytes: 1 << 40,
})
alice := r.createUser("a_"+randomSuffix(), "Алиса")
bob := r.createUser("b_"+randomSuffix(), "Боб")
chat := r.createChat(alice, "Деградация", alice.ID, bob.ID)
ok, _, _ := r.sendRaw(alice, chat.ID, mustJSON(dto.CreateMessageRequest{Text: "ok"}))
if ok != http.StatusCreated {
t.Fatalf("baseline send expected 201, got %d", ok)
}
stored := r.memory.MessagesTotal()
if stored != 1 {
t.Fatalf("baseline total expected 1, got %d", stored)
}
big := strings.Repeat("x", 512)
status, _, body := r.sendRaw(alice, chat.ID, mustJSON(dto.CreateMessageRequest{Text: big}))
if status != http.StatusRequestEntityTooLarge {
t.Fatalf("expected 413 by content-length, got %d body=%s", status, string(body))
}
code := extractErrorCode(t, body)
if code != CodePayloadTooLarge {
t.Fatalf("expected code %q, got %q", CodePayloadTooLarge, code)
}
if got := r.memory.MessagesTotal(); got != stored {
t.Fatalf("после 413 store изменился: было %d, стало %d", stored, got)
}
}
func TestLimits_PayloadBoundaries(t *testing.T) {
const limit = 256
r := newTestRigWithLimits(t, config.Limits{
MaxBodyBytes: limit,
MaxInFlight: 16,
MaxMessagesGlobal: 100,
MaxHeapBytes: 1 << 40,
})
alice := r.createUser("a_"+randomSuffix(), "Алиса")
bob := r.createUser("b_"+randomSuffix(), "Боб")
chat := r.createChat(alice, "Деградация", alice.ID, bob.ID)
exact := []byte(`{"text":"` + strings.Repeat("x", limit-len(`{"text":""}`)) + `"}`)
if len(exact) != limit {
t.Fatalf("test bug: body is %d bytes, want %d", len(exact), limit)
}
post := func(body io.Reader) (int, []byte) {
req, _ := http.NewRequest(http.MethodPost,
r.server.URL+"/api/v1/chats/"+chat.ID+"/messages", body)
req.Header.Set("Content-Type", "application/json")
r.setAuth(req, alice.ID)
resp, err := r.client.Do(req)
if err != nil {
t.Fatalf("send: %v", err)
}
defer resp.Body.Close()
data, _ := io.ReadAll(resp.Body)
return resp.StatusCode, data
}
chunked := func(b []byte) io.Reader { return io.MultiReader(bytes.NewReader(b)) }
if status, body := post(bytes.NewReader(exact)); status != http.StatusCreated {
t.Fatalf("body ровно %d байт с Content-Length: expected 201, got %d body=%s", limit, status, body)
}
if status, body := post(chunked(exact)); status != http.StatusCreated {
t.Fatalf("body ровно %d байт без Content-Length: expected 201, got %d body=%s", limit, status, body)
}
stored := r.memory.MessagesTotal()
over := []byte(`{"text":"` + strings.Repeat("x", limit) + `"}`)
status, body := post(chunked(over))
if status != http.StatusRequestEntityTooLarge {
t.Fatalf("body %d байт без Content-Length: expected 413, got %d body=%s", len(over), status, body)
}
if code := extractErrorCode(t, body); code != CodePayloadTooLarge {
t.Fatalf("expected code %q, got %q", CodePayloadTooLarge, code)
}
if got := r.memory.MessagesTotal(); got != stored {
t.Fatalf("после 413 store изменился: было %d, стало %d", stored, got)
}
}
type slowSessions struct {
*session.Memory
delay atomic.Int64
}
func (s *slowSessions) Get(ctx context.Context, h []byte) (session.Session, error) {
time.Sleep(time.Duration(s.delay.Load()))
return s.Memory.Get(ctx, h)
}
func TestLimits_RateLimited(t *testing.T) {
sessions := &slowSessions{Memory: session.NewMemory()}
r := newRig(t, config.Limits{
MaxBodyBytes: 1 << 16,
MaxInFlight: 2,
MaxMessagesGlobal: 10000,
MaxHeapBytes: 1 << 40,
}, sessions, time.Hour)
alice := r.createUser("c_"+randomSuffix(), "Алиса")
bob := r.createUser("d_"+randomSuffix(), "Боб")
chat := r.createChat(alice, "Деградация", alice.ID, bob.ID)
sessions.delay.Store(int64(20 * time.Millisecond))
const total = 50
var (
ok atomic.Int32
throttled atomic.Int32
errs atomic.Int32
wg sync.WaitGroup
)
wg.Add(total)
start := make(chan struct{})
for i := 0; i < total; i++ {
i := i
go func() {
defer wg.Done()
<-start
client := &http.Client{Timeout: 10 * time.Second}
body, _ := json.Marshal(dto.CreateMessageRequest{Text: fmt.Sprintf("flood-%d", i)})
req, _ := http.NewRequest(http.MethodPost,
r.server.URL+"/api/v1/chats/"+chat.ID+"/messages",
bytes.NewReader(body))
req.Header.Set("Content-Type", "application/json")
r.setAuth(req, alice.ID)
resp, err := client.Do(req)
if err != nil {
errs.Add(1)
return
}
switch resp.StatusCode {
case http.StatusCreated:
ok.Add(1)
case http.StatusTooManyRequests:
throttled.Add(1)
default:
errs.Add(1)
}
resp.Body.Close()
}()
}
close(start)
wg.Wait()
sessions.delay.Store(0)
if errs.Load() != 0 {
t.Fatalf("неожиданные ошибки/статусы под нагрузкой: %d", errs.Load())
}
if throttled.Load() == 0 {
t.Fatalf("ожидался хотя бы один 429 при maxInFlight=2 и %d параллельных запросах", total)
}
if ok.Load() == 0 {
t.Fatalf("ни одного 201 — лимит не пропускает валидный трафик")
}
if int(ok.Load()+throttled.Load()) != total {
t.Fatalf("ok=%d throttled=%d не покрывают total=%d", ok.Load(), throttled.Load(), total)
}
deadline := time.Now().Add(3 * time.Second)
for time.Now().Before(deadline) {
status, _ := r.send(alice, chat.ID, "после-пика "+randomSuffix())
if status == http.StatusCreated {
break
}
time.Sleep(20 * time.Millisecond)
}
status, _ := r.send(alice, chat.ID, "после-пика-2 "+randomSuffix())
if status != http.StatusCreated {
t.Fatalf("после отступления нагрузки сервис не восстановился: %d", status)
}
collected, _ := r.listMessages(alice, chat.ID, 100)
if int32(len(collected)) < ok.Load() {
t.Fatalf("часть подтверждённых сообщений потеряна: подтверждено %d, в истории %d",
ok.Load(), len(collected))
}
t.Logf("ok=%d throttled=%d errors=%d; history=%d", ok.Load(), throttled.Load(), errs.Load(), len(collected))
}
func TestLimits_MessageQuota(t *testing.T) {
const quota = 10
r := newTestRigWithLimits(t, config.Limits{
MaxBodyBytes: 1 << 16,
MaxInFlight: 16,
MaxMessagesGlobal: quota,
MaxHeapBytes: 1 << 40,
})
alice := r.createUser("e_"+randomSuffix(), "Алиса")
bob := r.createUser("f_"+randomSuffix(), "Боб")
chat := r.createChat(alice, "Деградация", alice.ID, bob.ID)
var saved []string
for i := 0; i < quota; i++ {
status, msg := r.send(alice, chat.ID, fmt.Sprintf("saved-%02d", i))
if status != http.StatusCreated {
t.Fatalf("send %d: expected 201, got %d", i, status)
}
saved = append(saved, msg.ID)
}
status, _, body := r.sendRaw(alice, chat.ID, mustJSON(dto.CreateMessageRequest{Text: "overflow"}))
if status != http.StatusServiceUnavailable {
t.Fatalf("expected 503 after quota exhausted, got %d body=%s", status, string(body))
}
if code := extractErrorCode(t, body); code != CodeUnavailable {
t.Fatalf("expected code %q, got %q", CodeUnavailable, code)
}
collected, _ := r.listMessages(alice, chat.ID, 100)
if len(collected) != quota {
t.Fatalf("после 503 история чата %d, ожидалось %d", len(collected), quota)
}
gotIDs := make(map[string]struct{}, len(collected))
for _, m := range collected {
gotIDs[m.ID] = struct{}{}
}
for _, id := range saved {
if _, ok := gotIDs[id]; !ok {
t.Fatalf("подтверждённое сообщение %s исчезло из истории", id)
}
}
for i := 0; i < 5; i++ {
s, _, _ := r.sendRaw(alice, chat.ID, mustJSON(dto.CreateMessageRequest{Text: "still-over"}))
if s != http.StatusServiceUnavailable {
t.Fatalf("повторный 503 ожидался, получен %d", s)
}
}
req, _ := http.NewRequest(http.MethodGet, r.server.URL+"/health/live", nil)
resp, err := r.client.Do(req)
if err != nil {
t.Fatalf("health/live: %v", err)
}
resp.Body.Close()
if resp.StatusCode != http.StatusOK {
t.Fatalf("health/live под перегрузкой: ожидали 200, получили %d", resp.StatusCode)
}
}
func TestLimits_NoSilentLoss(t *testing.T) {
const quota = 20
r := newTestRigWithLimits(t, config.Limits{
MaxBodyBytes: 1 << 16,
MaxInFlight: 8,
MaxMessagesGlobal: quota,
MaxHeapBytes: 1 << 40,
})
alice := r.createUser("g_"+randomSuffix(), "Алиса")
bob := r.createUser("h_"+randomSuffix(), "Боб")
chat := r.createChat(alice, "Деградация", alice.ID, bob.ID)
const attempts = quota * 3
acked := make([]string, 0, quota)
codes := make(map[int]int)
for i := 0; i < attempts; i++ {
status, msg, _ := r.sendRaw(alice, chat.ID, mustJSON(dto.CreateMessageRequest{Text: fmt.Sprintf("loss-%03d", i)}))
codes[status]++
if status == http.StatusCreated {
acked = append(acked, msg.ID)
}
}
if len(acked) != quota {
t.Fatalf("ожидалось ровно %d подтверждённых записей, получено %d; codes=%v", quota, len(acked), codes)
}
if codes[http.StatusServiceUnavailable] == 0 {
t.Fatalf("ни одного 503 — лимит не сработал")
}
collected, _ := r.listMessages(alice, chat.ID, 100)
gotIDs := make(map[string]struct{}, len(collected))
for _, m := range collected {
gotIDs[m.ID] = struct{}{}
}
for _, id := range acked {
if _, ok := gotIDs[id]; !ok {
t.Fatalf("подтверждённое сообщение %s исчезло из истории — незаметная потеря данных", id)
}
}
if len(collected) != len(acked) {
t.Fatalf("история чата содержит %d сообщений, подтверждено %d — скрытое отличие",
len(collected), len(acked))
}
t.Logf("codes=%v acked=%d history=%d", codes, len(acked), len(collected))
}