Files
mtusi2026lab4/student_tests/cursor_concurrency_test.go
T
2026-10-28 12:40:39 +03:00

407 lines
9.4 KiB
Go

package student_tests
import (
"encoding/json"
"fmt"
"io"
"net/http"
"net/url"
"runtime"
"sync"
"testing"
"time"
"mtusi2026lab4/internal/domain"
"mtusi2026lab4/internal/transport/http/dto"
)
func fetchCursorPage(
t *testing.T,
baseURL, chatID, userID string,
limit int,
cursor string,
) dto.MessagePageResponse {
t.Helper()
endpoint := fmt.Sprintf(
"%s/api/v1/chats/%s/messages?limit=%d",
baseURL,
chatID,
limit,
)
if cursor != "" {
endpoint += "&cursor=" + url.QueryEscape(cursor)
}
req, err := http.NewRequest(http.MethodGet, endpoint, nil)
if err != nil {
t.Fatal(err)
}
req.Header.Set("X-User-Id", userID)
res, err := http.DefaultClient.Do(req)
if err != nil {
t.Fatal(err)
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
body, _ := io.ReadAll(res.Body)
t.Fatalf("expected 200, got %d: %s", res.StatusCode, body)
}
var page dto.MessagePageResponse
if err := json.NewDecoder(res.Body).Decode(&page); err != nil {
t.Fatalf("decode message page: %v", err)
}
return page
}
func TestCursorTraversalAfterConcurrentWrites(t *testing.T) {
ts, st := setupTestServer()
defer ts.Close()
const (
clients = 10
messagesPerClient = 100
expectedMessages = clients * messagesPerClient
)
memberIDs := make([]string, 0, clients)
for client := 0; client < clients; client++ {
user, err := st.CreateUser(
fmt.Sprintf("cursor_client_%d", client),
fmt.Sprintf("Cursor client %d", client),
)
if err != nil {
t.Fatal(err)
}
memberIDs = append(memberIDs, user.ID)
}
chat, err := st.CreateChat("Concurrent cursor test", memberIDs)
if err != nil {
t.Fatal(err)
}
start := make(chan struct{})
var writers sync.WaitGroup
for client := 0; client < clients; client++ {
writers.Add(1)
go func(client int) {
defer writers.Done()
<-start
for message := 0; message < messagesPerClient; message++ {
_, err := st.CreateMessage(
chat.ID,
memberIDs[client],
fmt.Sprintf("client=%d message=%d", client, message),
)
if err != nil {
t.Errorf("create message: %v", err)
return
}
}
}(client)
}
close(start)
writers.Wait()
seen := make(map[string]struct{}, expectedMessages)
duplicateCount := 0
var previous *dto.MessageResponse
firstOrderingViolation := ""
cursor := ""
pageCount := 0
for {
pageCount++
if pageCount > expectedMessages {
t.Fatal("pagination did not terminate")
}
page := fetchCursorPage(t, ts.URL, chat.ID, memberIDs[0], 17, cursor)
for index := range page.Items {
message := page.Items[index]
if _, duplicate := seen[message.ID]; duplicate {
duplicateCount++
}
seen[message.ID] = struct{}{}
if previous != nil {
outOfOrder := message.CreatedAt.Before(previous.CreatedAt) ||
(message.CreatedAt.Equal(previous.CreatedAt) && message.ID <= previous.ID)
if outOfOrder && firstOrderingViolation == "" {
firstOrderingViolation = fmt.Sprintf(
"previous=(%s,%s), current=(%s,%s)",
previous.CreatedAt.Format("15:04:05.999999999"), previous.ID,
message.CreatedAt.Format("15:04:05.999999999"), message.ID,
)
}
}
messageCopy := message
previous = &messageCopy
}
if page.NextCursor == nil {
break
}
cursor = *page.NextCursor
}
if len(seen) != expectedMessages || duplicateCount != 0 {
t.Fatalf(
"cursor traversal returned %d unique messages of %d and %d duplicates; first ordering violation: %s",
len(seen), expectedMessages, duplicateCount, firstOrderingViolation,
)
}
if firstOrderingViolation != "" {
t.Fatalf("history is not ordered: %s", firstOrderingViolation)
}
}
func TestCursorTraversalDuringConcurrentWrites(t *testing.T) {
ts, st := setupTestServer()
defer ts.Close()
const (
clients = 16
messagesPerClient = 100
seedMessages = 100
pageLimit = 7
expectedTotal = seedMessages + clients*messagesPerClient
)
memberIDs := make([]string, 0, clients)
for client := 0; client < clients; client++ {
user, err := st.CreateUser(
fmt.Sprintf("live_cursor_client_%d", client),
fmt.Sprintf("Live cursor client %d", client),
)
if err != nil {
t.Fatalf("create user %d: %v", client, err)
}
memberIDs = append(memberIDs, user.ID)
}
chat, err := st.CreateChat("Live concurrent cursor test", memberIDs)
if err != nil {
t.Fatalf("create chat: %v", err)
}
// Начальные сообщения нужны, чтобы читатель сразу начал
// двигать курсор, пока остальные сообщения ещё записываются.
expectedIDs := make(map[string]struct{}, expectedTotal)
for index := 0; index < seedMessages; index++ {
message, err := st.CreateMessage(
chat.ID,
memberIDs[0],
fmt.Sprintf("seed message=%d", index),
)
if err != nil {
t.Fatalf("create seed message %d: %v", index, err)
}
expectedIDs[message.ID] = struct{}{}
}
var expectedMu sync.Mutex
var writers sync.WaitGroup
var ready sync.WaitGroup
start := make(chan struct{})
writerErrors := make(chan error, clients)
for client := 0; client < clients; client++ {
writers.Add(1)
ready.Add(1)
go func(client int) {
defer writers.Done()
ready.Done()
<-start
for index := 0; index < messagesPerClient; index++ {
// Отдаём планировщику возможность чаще переключать
// конкурентные горутины.
runtime.Gosched()
message, err := st.CreateMessage(
chat.ID,
memberIDs[client],
fmt.Sprintf("client=%d message=%d", client, index),
)
if err != nil {
writerErrors <- fmt.Errorf(
"client %d, message %d: %w",
client,
index,
err,
)
return
}
expectedMu.Lock()
expectedIDs[message.ID] = struct{}{}
expectedMu.Unlock()
// Не даём всем писателям завершиться до того,
// как читатель успеет продвинуть курсор.
time.Sleep(50 * time.Microsecond)
}
}(client)
}
// Сначала убеждаемся, что все горутины готовы,
// и только потом одновременно разрешаем запись.
ready.Wait()
writersDone := make(chan struct{})
go func() {
writers.Wait()
close(writersDone)
}()
close(start)
seen := make(map[string]struct{}, expectedTotal)
cursor := ""
var previous *dto.MessageResponse
const maxPageRequests = expectedTotal * 4
finished := false
for requestNumber := 0; requestNumber < maxPageRequests; requestNumber++ {
page := fetchCursorPage(
t,
ts.URL,
chat.ID,
memberIDs[0],
pageLimit,
cursor,
)
for index := range page.Items {
message := page.Items[index]
if _, duplicate := seen[message.ID]; duplicate {
t.Fatalf(
"message %s was returned more than once",
message.ID,
)
}
if previous != nil {
outOfOrder :=
message.CreatedAt.Before(previous.CreatedAt) ||
(message.CreatedAt.Equal(previous.CreatedAt) &&
message.ID <= previous.ID)
if outOfOrder {
t.Fatalf(
"messages are out of order: previous=(%s,%s), current=(%s,%s)",
previous.CreatedAt.Format(time.RFC3339Nano),
previous.ID,
message.CreatedAt.Format(time.RFC3339Nano),
message.ID,
)
}
}
seen[message.ID] = struct{}{}
messageCopy := message
previous = &messageCopy
}
// Для продолжающегося чтения строим курсор по последнему
// фактически полученному сообщению. Это позволяет опрашивать
// историю, даже если в промежуточный момент сервер вернул
// NextCursor=nil.
if len(page.Items) > 0 {
last := page.Items[len(page.Items)-1]
var encodeErr error
cursor, encodeErr = newTestCursorCodec().EncodeMessage(domain.MessageCursor{
CreatedAt: last.CreatedAt,
MessageID: last.ID,
ChatID: chat.ID,
})
if encodeErr != nil {
t.Fatalf("encode traversal cursor: %v", encodeErr)
}
}
select {
case <-writersDone:
finished = true
default:
}
// Все писатели завершились, а после текущего курсора
// больше ничего нет: обход закончен.
if finished && len(page.Items) == 0 {
break
}
if len(page.Items) == 0 {
runtime.Gosched()
}
if requestNumber == maxPageRequests-1 {
t.Fatalf(
"pagination did not terminate after %d requests",
maxPageRequests,
)
}
}
<-writersDone
close(writerErrors)
for writerErr := range writerErrors {
t.Errorf("create message: %v", writerErr)
}
expectedMu.Lock()
missingIDs := make([]string, 0)
for id := range expectedIDs {
if _, found := seen[id]; !found {
missingIDs = append(missingIDs, id)
}
}
expectedCount := len(expectedIDs)
expectedMu.Unlock()
if expectedCount != expectedTotal {
t.Fatalf(
"writers confirmed %d messages, expected %d",
expectedCount,
expectedTotal,
)
}
if len(missingIDs) != 0 {
const displayedMissingIDs = 5
if len(missingIDs) > displayedMissingIDs {
missingIDs = missingIDs[:displayedMissingIDs]
}
t.Fatalf(
"cursor traversal returned %d of %d confirmed messages; "+
"examples of missing IDs: %v",
len(seen),
expectedTotal,
missingIDs,
)
}
if len(seen) != expectedTotal {
t.Fatalf(
"cursor traversal returned %d messages, expected %d",
len(seen),
expectedTotal,
)
}
}