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) } }