Files
mtusi2026lab4/student_tests/idempotency_test.go
T

314 lines
7.8 KiB
Go

package student_tests
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"reflect"
"sync"
"testing"
store "mtusi2026lab4/internal/adapter/memory"
"mtusi2026lab4/internal/domain"
"mtusi2026lab4/internal/transport/http/dto"
)
func sendMessageRequest(
t *testing.T,
serverURL string,
chatID string,
actorID string,
key string,
body string,
) (int, []byte) {
t.Helper()
request, err := http.NewRequest(
http.MethodPost,
fmt.Sprintf("%s/api/v1/chats/%s/messages", serverURL, chatID),
bytes.NewBufferString(body),
)
if err != nil {
t.Fatalf("create message request: %v", err)
}
request.Header.Set("Content-Type", "application/json")
request.Header.Set("X-User-Id", actorID)
if key != "" {
request.Header.Set("Idempotency-Key", key)
}
response, err := http.DefaultClient.Do(request)
if err != nil {
t.Fatalf("send message request: %v", err)
}
defer response.Body.Close()
payload, err := io.ReadAll(response.Body)
if err != nil {
t.Fatalf("read message response: %v", err)
}
return response.StatusCode, payload
}
func decodeMessageResponse(t *testing.T, payload []byte) dto.MessageResponse {
t.Helper()
var message dto.MessageResponse
if err := json.Unmarshal(payload, &message); err != nil {
t.Fatalf("decode message response: %v; body=%s", err, payload)
}
return message
}
func createMessageFixture(t *testing.T) (*store.MemoryStore, string, domain.User, string) {
t.Helper()
server, memoryStore := setupTestServer()
t.Cleanup(server.Close)
user, err := memoryStore.CreateUser("idempotency_user", "Idempotency User")
if err != nil {
t.Fatalf("create fixture user: %v", err)
}
chat, err := memoryStore.CreateChat("Idempotency Chat", []string{user.ID})
if err != nil {
t.Fatalf("create fixture chat: %v", err)
}
return memoryStore, server.URL, user, chat.ID
}
func TestMessageIdempotencyKeyValidation(t *testing.T) {
_, serverURL, user, chatID := createMessageFixture(t)
testCases := []struct {
name string
key string
}{
{name: "missing", key: ""},
{name: "space", key: "invalid key"},
{name: "non ascii", key: "ключ"},
{name: "too long", key: string(bytes.Repeat([]byte{'a'}, 129))},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
status, _ := sendMessageRequest(
t,
serverURL,
chatID,
user.ID,
testCase.key,
`{"text":"hello"}`,
)
if status != http.StatusBadRequest {
t.Fatalf("expected 400, got %d", status)
}
})
}
}
func TestMessageIdempotencyReplayAndConflict(t *testing.T) {
memoryStore, serverURL, user, chatID := createMessageFixture(t)
status, firstPayload := sendMessageRequest(
t, serverURL, chatID, user.ID, "replay-key", `{"text":"hello"}`,
)
if status != http.StatusCreated {
t.Fatalf("first request: expected 201, got %d: %s", status, firstPayload)
}
status, replayPayload := sendMessageRequest(
t,
serverURL,
chatID,
user.ID,
"replay-key",
"{\n \"text\": \"hello\"\n}",
)
if status != http.StatusCreated {
t.Fatalf("replay: expected 201, got %d: %s", status, replayPayload)
}
first := decodeMessageResponse(t, firstPayload)
replay := decodeMessageResponse(t, replayPayload)
if !reflect.DeepEqual(first, replay) {
t.Fatalf("replay changed message: first=%+v replay=%+v", first, replay)
}
status, _ = sendMessageRequest(
t, serverURL, chatID, user.ID, "replay-key", `{"text":"different"}`,
)
if status != http.StatusConflict {
t.Fatalf("different body: expected 409, got %d", status)
}
messages, _, err := memoryStore.GetMessages(chatID, user.ID, 10, nil)
if err != nil {
t.Fatalf("list messages: %v", err)
}
if len(messages) != 1 {
t.Fatalf("expected one stored message, got %d", len(messages))
}
}
func TestMessageIdempotencyScopesAreIndependent(t *testing.T) {
server, memoryStore := setupTestServer()
t.Cleanup(server.Close)
alice, _ := memoryStore.CreateUser("scope_alice", "Alice")
bob, _ := memoryStore.CreateUser("scope_bob", "Bob")
firstChat, _ := memoryStore.CreateChat("First", []string{alice.ID, bob.ID})
secondChat, _ := memoryStore.CreateChat("Second", []string{alice.ID, bob.ID})
testCases := []struct {
actorID string
chatID string
text string
}{
{actorID: alice.ID, chatID: firstChat.ID, text: "alice first"},
{actorID: bob.ID, chatID: firstChat.ID, text: "bob first"},
{actorID: alice.ID, chatID: secondChat.ID, text: "alice second"},
}
for _, testCase := range testCases {
status, payload := sendMessageRequest(
t,
server.URL,
testCase.chatID,
testCase.actorID,
"shared-key",
fmt.Sprintf(`{"text":%q}`, testCase.text),
)
if status != http.StatusCreated {
t.Fatalf("independent scope: expected 201, got %d: %s", status, payload)
}
}
}
func TestConcurrentMessageIdempotencyCreatesExactlyOneMessage(t *testing.T) {
memoryStore, serverURL, user, chatID := createMessageFixture(t)
const clients = 32
start := make(chan struct{})
results := make(chan dto.MessageResponse, clients)
errors := make(chan error, clients)
var waitGroup sync.WaitGroup
for index := 0; index < clients; index++ {
waitGroup.Add(1)
go func() {
defer waitGroup.Done()
<-start
request, err := http.NewRequest(
http.MethodPost,
fmt.Sprintf("%s/api/v1/chats/%s/messages", serverURL, chatID),
bytes.NewBufferString(`{"text":"concurrent replay"}`),
)
if err != nil {
errors <- err
return
}
request.Header.Set("Content-Type", "application/json")
request.Header.Set("X-User-Id", user.ID)
request.Header.Set("Idempotency-Key", "one-concurrent-key")
response, err := http.DefaultClient.Do(request)
if err != nil {
errors <- err
return
}
defer response.Body.Close()
payload, err := io.ReadAll(response.Body)
if err != nil {
errors <- err
return
}
if response.StatusCode != http.StatusCreated {
errors <- fmt.Errorf("expected 201, got %d: %s", response.StatusCode, payload)
return
}
var message dto.MessageResponse
if err = json.Unmarshal(payload, &message); err != nil {
errors <- err
return
}
results <- message
}()
}
close(start)
waitGroup.Wait()
close(results)
close(errors)
for err := range errors {
if err != nil {
t.Fatal(err)
}
}
var expected dto.MessageResponse
count := 0
for message := range results {
if count == 0 {
expected = message
} else if !reflect.DeepEqual(message, expected) {
t.Fatalf("concurrent replay returned different message: %+v != %+v", message, expected)
}
count++
}
if count != clients {
t.Fatalf("expected %d successful responses, got %d", clients, count)
}
messages, _, err := memoryStore.GetMessages(chatID, user.ID, clients+1, nil)
if err != nil {
t.Fatalf("list messages: %v", err)
}
if len(messages) != 1 {
t.Fatalf("expected exactly one stored message, got %d", len(messages))
}
}
func TestMessageIdempotencyTreatsMissingAndEmptyAttachmentsEqually(t *testing.T) {
_, serverURL, user, chatID := createMessageFixture(t)
status, firstPayload := sendMessageRequest(
t,
serverURL,
chatID,
user.ID,
"default-attachments",
`{"text":"same semantic request"}`,
)
if status != http.StatusCreated {
t.Fatalf("first request: expected 201, got %d: %s", status, firstPayload)
}
status, replayPayload := sendMessageRequest(
t,
serverURL,
chatID,
user.ID,
"default-attachments",
`{"attachment_ids":[],"text":"same semantic request"}`,
)
if status != http.StatusCreated {
t.Fatalf("replay: expected 201, got %d: %s", status, replayPayload)
}
first := decodeMessageResponse(t, firstPayload)
replay := decodeMessageResponse(t, replayPayload)
if !reflect.DeepEqual(first, replay) {
t.Fatalf("missing attachment_ids and [] must replay identically")
}
if first.AttachmentIDs == nil || len(first.AttachmentIDs) != 0 {
t.Fatalf("response must contain attachment_ids: [], got %#v", first.AttachmentIDs)
}
}