forked from mtusi2026/mtusi2026lab2
313 lines
10 KiB
Go
313 lines
10 KiB
Go
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))
|
||
}
|