Files
mtusi2026lab6/internal/messenger/database_test.go
T

164 lines
4.5 KiB
Go

package messenger
import (
"context"
"encoding/base64"
"encoding/json"
"fmt"
"io"
"mtusi/messenger/internal/database"
"net/http"
"net/http/httptest"
"os"
"strings"
"sync"
"testing"
"time"
)
// Real PostgreSQL + HTTP + the race detector, in the optional Compose tests
// service. Local go test skips this test unless the DB secret path is supplied.
func TestDatabaseConcurrentHTTP(t *testing.T) {
path := os.Getenv("DATABASE_TEST_URL_FILE")
if path == "" {
t.Skip("run make test-race for real PostgreSQL HTTP integration")
}
raw, err := os.ReadFile(path)
if err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
pool, err := database.Open(ctx, strings.TrimSpace(string(raw)))
if err != nil {
t.Fatal(err)
}
defer pool.Close()
if err = database.Migrate(ctx, pool); err != nil {
t.Fatal(err)
}
api := New(pool, nil, make([]byte, 32), 3600, nil)
ts := httptest.NewServer(api)
defer ts.Close()
call := func(method, path, body, auth string, status int) map[string]any {
t.Helper()
r, err := http.NewRequest(method, ts.URL+path, strings.NewReader(body))
if err != nil {
t.Error(err)
return nil
}
if body != "" {
r.Header.Set("Content-Type", "application/json")
}
r.Header.Set("Authorization", auth)
if method == "POST" && strings.HasSuffix(path, "/messages") {
r.Header.Set("Idempotency-Key", uuid())
}
response, err := ts.Client().Do(r)
if err != nil {
t.Error(err)
return nil
}
defer response.Body.Close()
b, err := io.ReadAll(response.Body)
if err != nil {
t.Error(err)
return nil
}
if response.StatusCode != status {
t.Errorf("%s %s: want %d got %d", method, path, status, response.StatusCode)
return nil
}
var v map[string]any
if err = json.Unmarshal(b, &v); err != nil {
t.Error(err)
}
return v
}
username := "go_" + strings.ReplaceAll(uuid(), "-", "")[:20]
user := call("POST", "/api/v1/users", fmt.Sprintf(`{"username":%q,"display_name":"Race","password":"Synthetic-Go-Test-123"}`, username), "", 201)
if user == nil {
t.Fatal("create failed")
}
basic := "Basic " + base64.StdEncoding.EncodeToString([]byte(username+":Synthetic-Go-Test-123"))
session := call("POST", "/api/v1/auth/sessions", "", basic, 201)
if session == nil {
t.Fatal("login failed")
}
bearer := "Bearer " + session["token"].(string)
chat := call("POST", "/api/v1/chats", fmt.Sprintf(`{"title":"Race","member_ids":[%q]}`, user["id"]), bearer, 201)
if chat == nil {
t.Fatal("chat failed")
}
messages := "/api/v1/chats/" + chat["id"].(string) + "/messages"
var wg sync.WaitGroup
for worker := 0; worker < 10; worker++ {
wg.Add(1)
go func(worker int) {
defer wg.Done()
for j := 0; j < 10; j++ {
call("POST", messages, fmt.Sprintf(`{"text":"worker-%d-message-%d"}`, worker, j), bearer, 201)
}
}(worker)
}
wg.Wait()
page := call("GET", messages+"?limit=100", "", bearer, 200)
if page == nil {
t.Fatal("history failed")
}
items := page["items"].([]any)
if len(items) != 100 {
t.Fatalf("expected 100 messages, got %d", len(items))
}
seen := map[string]bool{}
for _, v := range items {
m := v.(map[string]any)
id := m["id"].(string)
if seen[id] {
t.Fatal("duplicate ID")
}
seen[id] = true
}
// Race a single key through the real server, then verify only one side effect.
var repeatWG sync.WaitGroup
ids := make(chan string, 12)
for i := 0; i < 12; i++ {
repeatWG.Add(1)
go func() {
defer repeatWG.Done()
req, _ := http.NewRequest("POST", ts.URL+messages, strings.NewReader(`{"text":"one key"}`))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("Authorization", bearer)
req.Header.Set("Idempotency-Key", "same-concurrent-key")
res, err := ts.Client().Do(req)
if err != nil {
t.Error(err)
return
}
defer res.Body.Close()
var m Message
if res.StatusCode != 201 || json.NewDecoder(res.Body).Decode(&m) != nil {
t.Error("repeat failed")
return
}
ids <- m.ID
}()
}
repeatWG.Wait()
close(ids)
var expected string
for id := range ids {
if expected == "" {
expected = id
}
if id != expected {
t.Error("idempotency duplicate")
}
}
var count int
if err := pool.QueryRow(context.Background(), "SELECT count(*) FROM messages WHERE chat_id=$1", chat["id"]).Scan(&count); err != nil || count != 101 {
t.Errorf("want 101 persisted messages, got %d: %v", count, err)
}
t.Log("100 confirmed messages from 10 clients through real HTTP and PostgreSQL; race detector enabled")
}