forked from mtusi2026/mtusi2026lab2
402 lines
9.2 KiB
Go
402 lines
9.2 KiB
Go
package student_tests
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"runtime"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"mtusi2026lab2/internal/domain"
|
|
)
|
|
|
|
func fetchCursorPage(
|
|
t *testing.T,
|
|
baseURL, chatID, userID string,
|
|
limit int,
|
|
cursor string,
|
|
) domain.MessagePage {
|
|
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 domain.MessagePage
|
|
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 *domain.Message
|
|
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 *domain.Message
|
|
|
|
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]
|
|
cursor = domain.EncodeCursor(
|
|
last.CreatedAt,
|
|
last.ID,
|
|
chat.ID,
|
|
)
|
|
}
|
|
|
|
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,
|
|
)
|
|
}
|
|
}
|