164 lines
4.5 KiB
Go
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")
|
|
}
|