diff --git a/Dockerfile b/Dockerfile index 2a723b5..39cf6e7 100644 --- a/Dockerfile +++ b/Dockerfile @@ -3,7 +3,6 @@ FROM golang:1.26.5-alpine3.24 AS build WORKDIR /src COPY . . RUN go build -o /out/messenger ./cmd/messenger -RUN go build -o /out/migrate ./cmd/migrate RUN go build -o /out/lab3experiment ./cmd/lab3experiment RUN go build -o /out/lab3summary ./cmd/lab3summary @@ -33,7 +32,6 @@ FROM alpine:3.24.2 RUN addgroup -S app && adduser -S -G app -u 10001 app COPY --from=build --chown=app:app /out/messenger /app/messenger -COPY --from=build --chown=app:app /out/migrate /app/migrate COPY --from=build --chown=app:app /out/lab3experiment /app/lab3experiment COPY --from=build --chown=app:app /out/lab3summary /app/lab3summary diff --git a/REPORT.md b/REPORT.md index 22f7384..66e6902 100644 --- a/REPORT.md +++ b/REPORT.md @@ -94,11 +94,11 @@ Nginx OSS в этом стенде использует пассивное ис 4. Победившая транзакция резервирует UUID сообщения и вставляет сообщение. Отложенный внешний ключ проверяется при commit. 5. Повтор с тем же телом читает исходное сообщение и возвращает тот же объект. Повтор с другим телом получает `409 Conflict`. -Это позволяет безопасно повторить POST после timeout: подтверждённая ранее запись не дублируется, даже если повтор попал на другую реплику. Истёкшая запись заменяется при следующем использовании ключа. Фоновая очистка не реализована; для длительной эксплуатации нужен периодический job по индексу `expires_at`. +Это позволяет безопасно повторить POST после timeout: подтверждённая ранее запись не дублируется, даже если повтор попал на другую реплику. Каждый успешный запрос также удаляет до 100 истёкших записей по индексу `expires_at`; `SKIP LOCKED` не даёт параллельным репликам ждать одну и ту же пачку. ### Миграции, обновление и развёртывание -API не выполняет DDL при старте. Отдельная команда `/app/migrate` берёт advisory lock и применяет versioned SQL один раз. Миграция идемпотентности только добавляет таблицу и индекс, поэтому совместима с уже работающей предыдущей версией. +API не выполняет DDL при старте. Отдельная команда `/app/messenger migrate` берёт advisory lock и применяет versioned SQL один раз. Миграция идемпотентности только добавляет таблицу и индекс, поэтому совместима с уже работающей предыдущей версией. `scripts/rolling-update.sh` собирает образы, запускает миграции, временно увеличивает число API с двух до трёх и поочерёдно заменяет старые контейнеры. Скрипт ждёт health каждого состава и затем возвращает две реплики. Workflow deploy запускается только вручную из `main` через `workflow_dispatch`; перед подключением к серверу он повторяет check, formatting, Go tests и build для SHA запуска. На сервере выполняется reset именно на этот SHA, даже если `main` успел измениться. Для SSH используются environment secrets `DEPLOY_HOST`, `DEPLOY_USER`, `DEPLOY_SSH_KEY` и заранее проверенный `DEPLOY_KNOWN_HOSTS`; изменяемых actions для SSH нет. @@ -114,7 +114,7 @@ Provisioned dashboard Grafana показывает общий RPS, RPS и p95 п | --- | --- | --- | --- | | Публичный smoke | `make test` через Nginx | PASS: регистрация, сессия, чат, пагинация, доступ и идемпотентность | `evidence/lab3-verification.txt` | | Общие сессии и ≥2 реплики | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | Одна сессия обслужена двумя instance ID | `evidence/lab3-verification.txt` | -| Конкурентная идемпотентность | `docker compose --profile tests run --rm --build tests` | 8 конкурентных запросов через два Store вернули один message ID; в БД одна строка | `evidence/lab3-verification.txt` | +| Конкурентная идемпотентность | Go black-box через Nginx и database integration suite | 16 одновременных HTTP-запросов обработаны минимум двумя instance ID и вернули один message ID; история содержит одну запись | `evidence/lab3-verification.txt` | | Сохранность | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | API, PostgreSQL и Valkey перезапущены; старые данные и token доступны | `evidence/lab3-verification.txt` | | Отказ API | Два запуска failover с остановкой разных реплик | 125–131 успешная запись; 0–1 переходная ошибка; восстановление 1.35–1.44 с; дублей нет | `evidence/lab3-verification.txt` | | Rolling update | 60 секунд Go-нагрузки и `scripts/rolling-update.sh` | 134894 подтверждения, 2248.16 RPS, 0 ошибок, p95 13.12 ms | `evidence/lab3-rolling-update.json` | @@ -184,7 +184,7 @@ CPU и Nginx RPS считаются по разности монотонных ` - PostgreSQL и Valkey не реплицированы. AOF Valkey с `appendfsync everysec` ограничивает возможную потерю примерно последней секундой при аварии хранилища, но этот сценарий в работе не заявляется как защищённый. - Нагрузочный клиент closed-loop и подвержен coordinated omission. Результаты сравнивают конфигурации на одной машине и не являются абсолютной производительностью production-системы. - Все реплики и клиент делят ресурсы одного хоста; дельта process CPU показывает потребление API, а не полную стоимость Docker/network/storage. -- Для эксплуатации нужны TLS, внешнее управление secrets, репликация хранилищ, алерты, план очистки истёкших idempotency records и длительный soak test. +- Для эксплуатации нужны TLS, внешнее управление secrets, репликация хранилищ, алерты и длительный soak test; при большом потоке следует отдельно измерить стоимость пакетной очистки idempotency records. ## Источники и инструменты diff --git a/cmd/dependencycheck/main.go b/cmd/dependencycheck/main.go index d22455f..eaa3d64 100644 --- a/cmd/dependencycheck/main.go +++ b/cmd/dependencycheck/main.go @@ -10,6 +10,7 @@ import ( "os" "os/exec" "strings" + "sync" "time" "github.com/google/uuid" @@ -19,6 +20,7 @@ type apiClient struct { baseURL string client *http.Client token string + userID string } func main() { @@ -26,7 +28,7 @@ func main() { fmt.Fprintln(os.Stderr, err) os.Exit(1) } - fmt.Println("PASS: PostgreSQL and Valkey outage recovery") + fmt.Println("PASS: replica idempotency and dependency recovery") } func run() error { @@ -39,6 +41,9 @@ func run() error { if err := client.expect(http.MethodGet, "/api/v1/users/me", http.StatusOK, true); err != nil { return err } + if err := client.verifyConcurrentIdempotency(); err != nil { + return err + } if err := verifyOutage(client, "valkey"); err != nil { return err } @@ -62,9 +67,21 @@ func (c *apiClient) registerAndLogin() error { if err != nil { return fmt.Errorf("register: %w", err) } - if err := closeResponse(response, http.StatusCreated); err != nil { - return fmt.Errorf("register: %w", err) + registrationBody := response.Body + defer func() { _ = registrationBody.Close() }() + if response.StatusCode != http.StatusCreated { + return fmt.Errorf("register status = %d", response.StatusCode) } + var user struct { + ID string `json:"id"` + } + if err := json.NewDecoder(io.LimitReader(response.Body, 1<<20)).Decode(&user); err != nil { + return fmt.Errorf("decode user: %w", err) + } + if user.ID == "" { + return fmt.Errorf("register returned an empty user id") + } + c.userID = user.ID request, err = http.NewRequest(http.MethodPost, c.baseURL+"/api/v1/auth/sessions", nil) if err != nil { @@ -92,6 +109,154 @@ func (c *apiClient) registerAndLogin() error { return nil } +type messageResult struct { + messageID string + instanceID string + err error +} + +func (c *apiClient) verifyConcurrentIdempotency() error { + chatID, err := c.createChat() + if err != nil { + return err + } + + const workers = 16 + var ( + key = uuid.NewString() + start = make(chan struct{}) + results = make(chan messageResult, workers) + group sync.WaitGroup + instances = make(map[string]struct{}) + messageID string + ) + transport := &http.Transport{DisableKeepAlives: true, MaxConnsPerHost: workers} + client := &http.Client{Transport: transport, Timeout: 10 * time.Second} + defer transport.CloseIdleConnections() + + for range workers { + group.Add(1) + go func() { + defer group.Done() + <-start + id, instance, requestErr := c.createMessage(client, chatID, key, "concurrent message") + results <- messageResult{messageID: id, instanceID: instance, err: requestErr} + }() + } + close(start) + group.Wait() + close(results) + + for result := range results { + if result.err != nil { + return result.err + } + if result.instanceID == "" { + return fmt.Errorf("message response has an empty X-Instance-Id") + } + instances[result.instanceID] = struct{}{} + if messageID == "" { + messageID = result.messageID + } + if result.messageID != messageID { + return fmt.Errorf("idempotent responses returned different message ids") + } + } + if len(instances) < 2 { + return fmt.Errorf("requests reached %d API instance, want at least 2", len(instances)) + } + return c.verifyMessageHistory(chatID, messageID) +} + +func (c *apiClient) createChat() (string, error) { + payload, err := json.Marshal(map[string]any{ + "title": "Replica check", "member_ids": []string{c.userID}, + }) + if err != nil { + return "", err + } + request, err := http.NewRequest(http.MethodPost, c.baseURL+"/api/v1/chats", bytes.NewReader(payload)) + if err != nil { + return "", err + } + request.Header.Set("Authorization", "Bearer "+c.token) + request.Header.Set("Content-Type", "application/json") + response, err := c.client.Do(request) + if err != nil { + return "", fmt.Errorf("create chat: %w", err) + } + defer func() { _ = response.Body.Close() }() + if response.StatusCode != http.StatusCreated { + return "", fmt.Errorf("create chat status = %d", response.StatusCode) + } + var chat struct { + ID string `json:"id"` + } + if err := json.NewDecoder(io.LimitReader(response.Body, 1<<20)).Decode(&chat); err != nil { + return "", fmt.Errorf("decode chat: %w", err) + } + return chat.ID, nil +} + +func (c *apiClient) createMessage(client *http.Client, chatID, key, text string) (string, string, error) { + payload, err := json.Marshal(map[string]string{"text": text}) + if err != nil { + return "", "", err + } + request, err := http.NewRequest( + http.MethodPost, c.baseURL+"/api/v1/chats/"+chatID+"/messages", bytes.NewReader(payload), + ) + if err != nil { + return "", "", err + } + request.Header.Set("Authorization", "Bearer "+c.token) + request.Header.Set("Content-Type", "application/json") + request.Header.Set("Idempotency-Key", key) + response, err := client.Do(request) + if err != nil { + return "", "", fmt.Errorf("create message: %w", err) + } + defer func() { _ = response.Body.Close() }() + if response.StatusCode != http.StatusCreated { + return "", response.Header.Get("X-Instance-Id"), fmt.Errorf("create message status = %d", response.StatusCode) + } + var message struct { + ID string `json:"id"` + } + if err := json.NewDecoder(io.LimitReader(response.Body, 1<<20)).Decode(&message); err != nil { + return "", response.Header.Get("X-Instance-Id"), fmt.Errorf("decode message: %w", err) + } + return message.ID, response.Header.Get("X-Instance-Id"), nil +} + +func (c *apiClient) verifyMessageHistory(chatID, messageID string) error { + request, err := http.NewRequest(http.MethodGet, c.baseURL+"/api/v1/chats/"+chatID+"/messages?limit=100", nil) + if err != nil { + return err + } + request.Header.Set("Authorization", "Bearer "+c.token) + response, err := c.client.Do(request) + if err != nil { + return fmt.Errorf("list messages: %w", err) + } + defer func() { _ = response.Body.Close() }() + if response.StatusCode != http.StatusOK { + return fmt.Errorf("list messages status = %d", response.StatusCode) + } + var page struct { + Items []struct { + ID string `json:"id"` + } `json:"items"` + } + if err := json.NewDecoder(io.LimitReader(response.Body, 1<<20)).Decode(&page); err != nil { + return fmt.Errorf("decode messages: %w", err) + } + if len(page.Items) != 1 || page.Items[0].ID != messageID { + return fmt.Errorf("message history contains %d items with an unexpected id", len(page.Items)) + } + return nil +} + func verifyOutage(client *apiClient, service string) (returnErr error) { if err := compose("stop", service); err != nil { return err diff --git a/cmd/messenger/main.go b/cmd/messenger/main.go index 9926f0e..aefd2bc 100644 --- a/cmd/messenger/main.go +++ b/cmd/messenger/main.go @@ -2,6 +2,7 @@ package main import ( "context" + "fmt" "log/slog" "net" "net/http" @@ -20,13 +21,23 @@ import ( func main() { appLogger := logger.New() - if err := run(appLogger); err != nil { + if err := run(appLogger, os.Args[1:]); err != nil { appLogger.Error("server stopped", "error", err) os.Exit(1) } } -func run(logger *slog.Logger) error { +func run(logger *slog.Logger, arguments []string) error { + if len(arguments) == 0 { + return runServer(logger) + } + if len(arguments) == 1 && arguments[0] == "migrate" { + return runMigrations() + } + return fmt.Errorf("usage: messenger [migrate]") +} + +func runServer(logger *slog.Logger) error { settings, err := config.Load() if err != nil { return err @@ -102,3 +113,20 @@ func run(logger *slog.Logger) error { return nil } } + +func runMigrations() error { + settings, err := config.LoadMigration() + if err != nil { + return err + } + pool, err := database.Open(context.Background(), database.Config{ + URL: settings.DatabaseURL, MinConnections: settings.DBMinConns, MaxConnections: settings.DBMaxConns, + MaxConnectionAge: settings.DBMaxConnectionAge, MaxConnectionIdle: settings.DBMaxConnectionIdle, + HealthCheckPeriod: settings.DBHealthCheckPeriod, ConnectTimeout: settings.DependencyTimeout, + }) + if err != nil { + return err + } + defer pool.Close() + return database.Migrate(context.Background(), pool, settings.MigrationTimeout) +} diff --git a/cmd/migrate/main.go b/cmd/migrate/main.go deleted file mode 100644 index 81dac78..0000000 --- a/cmd/migrate/main.go +++ /dev/null @@ -1,34 +0,0 @@ -package main - -import ( - "context" - "fmt" - "os" - - "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/config" - "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/database" -) - -func main() { - if err := run(); err != nil { - fmt.Fprintln(os.Stderr, err) - os.Exit(1) - } -} - -func run() error { - settings, err := config.LoadMigration() - if err != nil { - return err - } - pool, err := database.Open(context.Background(), database.Config{ - URL: settings.DatabaseURL, MinConnections: settings.DBMinConns, MaxConnections: settings.DBMaxConns, - MaxConnectionAge: settings.DBMaxConnectionAge, MaxConnectionIdle: settings.DBMaxConnectionIdle, - HealthCheckPeriod: settings.DBHealthCheckPeriod, ConnectTimeout: settings.DependencyTimeout, - }) - if err != nil { - return err - } - defer pool.Close() - return database.Migrate(context.Background(), pool, settings.MigrationTimeout) -} diff --git a/compose.yaml b/compose.yaml index ffbe5bb..e8288df 100644 --- a/compose.yaml +++ b/compose.yaml @@ -34,7 +34,7 @@ services: migrate: image: ${API_IMAGE:-mtusi-messenger:lab3} - command: ["/app/migrate"] + command: ["/app/messenger", "migrate"] environment: DATABASE_URL: ${DATABASE_URL} DB_MIN_CONNS: ${DB_MIN_CONNS} diff --git a/evidence/lab3-verification.txt b/evidence/lab3-verification.txt index 0efd76d..97710ec 100644 --- a/evidence/lab3-verification.txt +++ b/evidence/lab3-verification.txt @@ -11,6 +11,7 @@ Contract and build Integration - docker compose --profile tests run --rm --build tests: PASS - PostgreSQL concurrent idempotency: 8 calls through two Store instances, one message ID and one row +- black-box replica idempotency: 16 concurrent calls through Nginx, at least two instance IDs, one message ID and one history item - PostgreSQL and Valkey stop/recovery: PASS - persistence after restarting API, PostgreSQL and Valkey: PASS; the original session and data remained valid - public smoke through Nginx: PASS diff --git a/go.mod b/go.mod index b644b7d..68b77ae 100644 --- a/go.mod +++ b/go.mod @@ -7,6 +7,7 @@ require ( github.com/jackc/pgx/v5 v5.11.0 github.com/prometheus/client_golang v1.23.2 github.com/spf13/viper v1.21.0 + github.com/stretchr/testify v1.11.1 github.com/valkey-io/valkey-go v1.0.78 golang.org/x/crypto v0.57.0 ) @@ -14,6 +15,7 @@ require ( require ( github.com/beorn7/perks v1.0.1 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect + github.com/davecgh/go-spew v1.1.1 // indirect github.com/fsnotify/fsnotify v1.9.0 // indirect github.com/go-viper/mapstructure/v2 v2.4.0 // indirect github.com/jackc/pgpassfile v1.0.0 // indirect @@ -21,6 +23,7 @@ require ( github.com/jackc/puddle/v2 v2.2.2 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect github.com/pelletier/go-toml/v2 v2.2.4 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect github.com/prometheus/client_model v0.6.2 // indirect github.com/prometheus/common v0.66.1 // indirect github.com/prometheus/procfs v0.16.1 // indirect @@ -36,4 +39,5 @@ require ( golang.org/x/sys v0.48.0 // indirect golang.org/x/text v0.42.0 // indirect google.golang.org/protobuf v1.36.8 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/internal/messenger/server_test.go b/internal/messenger/server_test.go index fe97aa5..011fb0f 100644 --- a/internal/messenger/server_test.go +++ b/internal/messenger/server_test.go @@ -12,12 +12,27 @@ import ( "testing" "time" + "github.com/stretchr/testify/suite" + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/model" "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/postgres" ) var errDependency = errors.New("dependency unavailable") +type MessengerSuite struct { + suite.Suite + logger *slog.Logger +} + +func TestMessengerSuite(t *testing.T) { + suite.Run(t, new(MessengerSuite)) +} + +func (s *MessengerSuite) SetupTest() { + s.logger = slog.New(slog.NewTextHandler(io.Discard, nil)) +} + type messengerStoreStub struct { pingErr error userByID model.User @@ -79,7 +94,8 @@ func (s passwordsStub) Verify(string, string) (bool, error) { return s.verified, s.err } -func TestReadinessReturnsUnavailableForDependencyFailure(t *testing.T) { +func (s *MessengerSuite) TestReadinessReturnsUnavailableForDependencyFailure() { + t := s.T() tests := []struct { name string store messengerStoreStub @@ -91,7 +107,7 @@ func TestReadinessReturnsUnavailableForDependencyFailure(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - server := newTestServer(tt.store, tt.sessions, passwordsStub{}) + server := s.newTestServer(tt.store, tt.sessions, passwordsStub{}) response := serveRequest(server, http.MethodGet, "/health/ready", "") if response.Code != http.StatusServiceUnavailable { t.Fatalf("status = %d, want %d", response.Code, http.StatusServiceUnavailable) @@ -100,7 +116,8 @@ func TestReadinessReturnsUnavailableForDependencyFailure(t *testing.T) { } } -func TestBusinessRequestReturnsUnavailableForDependencyFailure(t *testing.T) { +func (s *MessengerSuite) TestBusinessRequestReturnsUnavailableForDependencyFailure() { + t := s.T() tests := []struct { name string store messengerStoreStub @@ -112,7 +129,7 @@ func TestBusinessRequestReturnsUnavailableForDependencyFailure(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - server := newTestServer(tt.store, tt.sessions, passwordsStub{}) + server := s.newTestServer(tt.store, tt.sessions, passwordsStub{}) request := httptest.NewRequest(http.MethodGet, "/api/v1/users/me", nil) request.Header.Set("Authorization", "Bearer valid-token") response := httptest.NewRecorder() @@ -124,15 +141,16 @@ func TestBusinessRequestReturnsUnavailableForDependencyFailure(t *testing.T) { } } -func TestAuthenticationChallenges(t *testing.T) { - server := newTestServer(messengerStoreStub{}, sessionStub{}, passwordsStub{}) +func (s *MessengerSuite) TestAuthenticationChallenges() { + t := s.T() + server := s.newTestServer(messengerStoreStub{}, sessionStub{}, passwordsStub{}) bearer := serveRequest(server, http.MethodGet, "/api/v1/users/me", "") if bearer.Code != http.StatusUnauthorized || bearer.Header().Get("WWW-Authenticate") != `Bearer realm="messenger"` { t.Fatalf("business challenge = %d %q", bearer.Code, bearer.Header().Get("WWW-Authenticate")) } store := messengerStoreStub{credentials: model.UserCredentials{PasswordHash: "hash"}} - server = newTestServer(store, sessionStub{}, passwordsStub{verified: false}) + server = s.newTestServer(store, sessionStub{}, passwordsStub{verified: false}) request := httptest.NewRequest(http.MethodPost, "/api/v1/auth/sessions", nil) request.SetBasicAuth("user", "wrong-password") response := httptest.NewRecorder() @@ -142,8 +160,9 @@ func TestAuthenticationChallenges(t *testing.T) { } } -func TestSessionCreationRejectsChunkedBody(t *testing.T) { - server := newTestServer(messengerStoreStub{}, sessionStub{}, passwordsStub{}) +func (s *MessengerSuite) TestSessionCreationRejectsChunkedBody() { + t := s.T() + server := s.newTestServer(messengerStoreStub{}, sessionStub{}, passwordsStub{}) request := httptest.NewRequest(http.MethodPost, "/api/v1/auth/sessions", strings.NewReader("{}")) request.ContentLength = -1 request.SetBasicAuth("user", "password") @@ -154,16 +173,18 @@ func TestSessionCreationRejectsChunkedBody(t *testing.T) { } } -func TestRegistrationRejectsWhitespacePassword(t *testing.T) { - server := newTestServer(messengerStoreStub{}, sessionStub{}, passwordsStub{}) +func (s *MessengerSuite) TestRegistrationRejectsWhitespacePassword() { + t := s.T() + server := s.newTestServer(messengerStoreStub{}, sessionStub{}, passwordsStub{}) response := serveRequest(server, http.MethodPost, "/api/v1/users", `{"username":"student","display_name":"Student","password":" "}`) if response.Code != http.StatusBadRequest { t.Fatalf("status = %d, want %d", response.Code, http.StatusBadRequest) } } -func TestInstanceHeaderIsSetOnSuccessAndError(t *testing.T) { - server := newTestServer(messengerStoreStub{}, sessionStub{}, passwordsStub{}) +func (s *MessengerSuite) TestInstanceHeaderIsSetOnSuccessAndError() { + t := s.T() + server := s.newTestServer(messengerStoreStub{}, sessionStub{}, passwordsStub{}) for _, response := range []*httptest.ResponseRecorder{ serveRequest(server, http.MethodGet, "/health/live", ""), serveRequest(server, http.MethodGet, "/api/v1/users/me", ""), @@ -174,9 +195,10 @@ func TestInstanceHeaderIsSetOnSuccessAndError(t *testing.T) { } } -func TestMessageCreationValidatesIdempotencyKey(t *testing.T) { +func (s *MessengerSuite) TestMessageCreationValidatesIdempotencyKey() { + t := s.T() store := messengerStoreStub{userByID: model.User{ID: "user-id"}} - server := newTestServer(store, sessionStub{userID: "user-id"}, passwordsStub{}) + server := s.newTestServer(store, sessionStub{userID: "user-id"}, passwordsStub{}) tests := []struct { name string key string @@ -202,12 +224,13 @@ func TestMessageCreationValidatesIdempotencyKey(t *testing.T) { } } -func TestMessageCreationReturnsConflictForReusedKeyWithDifferentBody(t *testing.T) { +func (s *MessengerSuite) TestMessageCreationReturnsConflictForReusedKeyWithDifferentBody() { + t := s.T() store := messengerStoreStub{ userByID: model.User{ID: "user-id"}, messageErr: fmt.Errorf("create message: %w", postgres.ErrIdempotencyConflict), } - server := newTestServer(store, sessionStub{userID: "user-id"}, passwordsStub{}) + server := s.newTestServer(store, sessionStub{userID: "user-id"}, passwordsStub{}) request := httptest.NewRequest(http.MethodPost, "/api/v1/chats/00000000-0000-0000-0000-000000000001/messages", strings.NewReader(`{"text":"different"}`)) request.Header.Set("Authorization", "Bearer valid-token") request.Header.Set("Content-Type", "application/json") @@ -219,9 +242,8 @@ func TestMessageCreationReturnsConflictForReusedKeyWithDifferentBody(t *testing. } } -func newTestServer(messages MessengerStore, sessions SessionStore, passwords PasswordService) *Server { - logger := slog.New(slog.NewTextHandler(io.Discard, nil)) - return NewServer(logger, messages, sessions, passwords, time.Hour, 24*time.Hour, time.Second, "test-instance", "8081") +func (s *MessengerSuite) newTestServer(messages MessengerStore, sessions SessionStore, passwords PasswordService) *Server { + return NewServer(s.logger, messages, sessions, passwords, time.Hour, 24*time.Hour, time.Second, "test-instance", "8081") } func serveRequest(server *Server, method, path, body string) *httptest.ResponseRecorder { diff --git a/internal/model/model_test.go b/internal/model/model_test.go index 7c0f2e4..d3a54d9 100644 --- a/internal/model/model_test.go +++ b/internal/model/model_test.go @@ -4,15 +4,21 @@ import ( "encoding/json" "testing" "time" + + "github.com/stretchr/testify/suite" ) -func TestUserTimestampHasFixedMicroseconds(t *testing.T) { +type ModelSuite struct { + suite.Suite +} + +func TestModelSuite(t *testing.T) { + suite.Run(t, new(ModelSuite)) +} + +func (s *ModelSuite) TestUserTimestampHasFixedMicroseconds() { createdAt := time.Date(2026, time.September, 23, 21, 28, 15, 423030000, time.UTC) data, err := json.Marshal(User{ID: "id", Username: "user", DisplayName: "User", CreatedAt: createdAt}) - if err != nil { - t.Fatalf("Marshal() error = %v", err) - } - if string(data) != `{"id":"id","username":"user","display_name":"User","created_at":"2026-09-23T21:28:15.423030Z"}` { - t.Fatalf("Marshal() = %s", data) - } + s.Require().NoError(err) + s.Equal(`{"id":"id","username":"user","display_name":"User","created_at":"2026-09-23T21:28:15.423030Z"}`, string(data)) } diff --git a/internal/password/password_test.go b/internal/password/password_test.go index df25f40..8e88875 100644 --- a/internal/password/password_test.go +++ b/internal/password/password_test.go @@ -1,42 +1,42 @@ package password -import "testing" +import ( + "testing" -func TestHasher(t *testing.T) { - hasher, err := New(testConfig()) - if err != nil { - t.Fatalf("New() error = %v", err) - } - hash, err := hasher.Hash("T3st-password-123") - if err != nil { - t.Fatalf("Hash() error = %v", err) - } + "github.com/stretchr/testify/suite" +) - verified, err := hasher.Verify("T3st-password-123", hash) - if err != nil { - t.Fatalf("Verify() error = %v", err) - } - if !verified { - t.Fatal("Verify() = false for the original password") - } - - verified, err = hasher.Verify("wrong-password", hash) - if err != nil { - t.Fatalf("Verify() error = %v", err) - } - if verified { - t.Fatal("Verify() = true for a different password") - } +type PasswordSuite struct { + suite.Suite + hasher *Hasher } -func TestVerifyRejectsMalformedHash(t *testing.T) { +func TestPasswordSuite(t *testing.T) { + suite.Run(t, new(PasswordSuite)) +} + +func (s *PasswordSuite) SetupTest() { hasher, err := New(testConfig()) - if err != nil { - t.Fatalf("New() error = %v", err) - } - if _, err := hasher.Verify("password", "invalid"); err == nil { - t.Fatal("Verify() error = nil for malformed hash") - } + s.Require().NoError(err) + s.hasher = hasher +} + +func (s *PasswordSuite) TestHasher() { + hash, err := s.hasher.Hash("T3st-password-123") + s.Require().NoError(err) + + verified, err := s.hasher.Verify("T3st-password-123", hash) + s.Require().NoError(err) + s.True(verified) + + verified, err = s.hasher.Verify("wrong-password", hash) + s.Require().NoError(err) + s.False(verified) +} + +func (s *PasswordSuite) TestVerifyRejectsMalformedHash() { + _, err := s.hasher.Verify("password", "invalid") + s.Error(err) } func testConfig() Config { diff --git a/internal/postgres/idempotency.go b/internal/postgres/idempotency.go new file mode 100644 index 0000000..a4843ad --- /dev/null +++ b/internal/postgres/idempotency.go @@ -0,0 +1,285 @@ +package postgres + +import ( + "bytes" + "context" + "crypto/sha256" + "errors" + "fmt" + "time" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5" + + "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/model" +) + +const expiredIdempotencyCleanupBatch = 100 + +func (s *Store) CreateMessage( + ctx context.Context, + chatID string, + senderID string, + text string, + idempotencyKey string, + idempotencyTTL time.Duration, +) (model.Message, bool, error) { + var ( + tx pgx.Tx + err error + visible bool + requestHash [sha256.Size]byte + message model.Message + replay bool + ) + + tx, err = s.pool.BeginTx(ctx, pgx.TxOptions{}) + if err != nil { + return model.Message{}, false, fmt.Errorf("begin create message transaction: %w", err) + } + defer func() { _ = tx.Rollback(context.WithoutCancel(ctx)) }() + + visible, err = chatVisibleInTransaction(ctx, tx, chatID, senderID) + if err != nil { + return model.Message{}, false, err + } + if !visible { + return model.Message{}, false, ErrNotFound + } + if err = deleteExpiredIdempotencyRecords(ctx, tx, expiredIdempotencyCleanupBatch); err != nil { + return model.Message{}, false, err + } + + requestHash = sha256.Sum256([]byte(text)) + message, replay, err = createIdempotentMessage( + ctx, tx, chatID, senderID, text, idempotencyKey, requestHash[:], idempotencyTTL, + ) + if err != nil { + return model.Message{}, false, err + } + if err := tx.Commit(ctx); err != nil { + return model.Message{}, false, fmt.Errorf("commit create message transaction: %w", err) + } + return message, replay, nil +} + +func chatVisibleInTransaction(ctx context.Context, tx pgx.Tx, chatID, userID string) (bool, error) { + const query = ` + SELECT EXISTS ( + SELECT 1 + FROM chat_members + WHERE chat_id = $1 AND user_id = $2 + )` + + var visible bool + if err := tx.QueryRow(ctx, query, chatID, userID).Scan(&visible); err != nil { + return false, fmt.Errorf("check chat visibility: %w", err) + } + return visible, nil +} + +func createIdempotentMessage( + ctx context.Context, + tx pgx.Tx, + chatID string, + senderID string, + text string, + idempotencyKey string, + requestHash []byte, + idempotencyTTL time.Duration, +) (model.Message, bool, error) { + for { + var ( + record idempotencyRecord + found bool + err error + messageID string + reserved bool + message model.Message + ) + + record, found, err = lockIdempotencyRecord(ctx, tx, senderID, chatID, idempotencyKey) + if err != nil { + return model.Message{}, false, err + } + if found && record.active { + if !bytes.Equal(record.requestHash, requestHash) { + return model.Message{}, false, ErrIdempotencyConflict + } + message, err = messageByID(ctx, tx, record.messageID) + return message, true, err + } + if found { + if err := deleteIdempotencyRecord(ctx, tx, senderID, chatID, idempotencyKey); err != nil { + return model.Message{}, false, err + } + } + + messageID = uuid.NewString() + reserved, err = reserveIdempotencyKey( + ctx, tx, senderID, chatID, idempotencyKey, requestHash, messageID, idempotencyTTL, + ) + if err != nil { + return model.Message{}, false, err + } + if !reserved { + continue + } + + message, err = insertMessage(ctx, tx, messageID, chatID, senderID, text) + return message, false, err + } +} + +func deleteExpiredIdempotencyRecords(ctx context.Context, tx pgx.Tx, limit int) error { + const query = ` + WITH expired AS ( + SELECT ctid + FROM message_idempotency + WHERE expires_at <= statement_timestamp() + ORDER BY expires_at + LIMIT $1 + FOR UPDATE SKIP LOCKED + ) + DELETE FROM message_idempotency records + USING expired + WHERE records.ctid = expired.ctid` + + if _, err := tx.Exec(ctx, query, limit); err != nil { + return fmt.Errorf("delete expired idempotency records: %w", err) + } + return nil +} + +type idempotencyRecord struct { + requestHash []byte + messageID string + active bool +} + +func lockIdempotencyRecord( + ctx context.Context, + tx pgx.Tx, + userID string, + chatID string, + key string, +) (idempotencyRecord, bool, error) { + const query = ` + SELECT request_hash, message_id, expires_at > statement_timestamp() + FROM message_idempotency + WHERE user_id = $1 AND chat_id = $2 AND key = $3 + FOR UPDATE` + + var ( + record idempotencyRecord + err error + ) + err = tx.QueryRow(ctx, query, userID, chatID, key).Scan( + &record.requestHash, + &record.messageID, + &record.active, + ) + if errors.Is(err, pgx.ErrNoRows) { + return idempotencyRecord{}, false, nil + } + if err != nil { + return idempotencyRecord{}, false, fmt.Errorf("lock idempotency key: %w", err) + } + return record, true, nil +} + +func deleteIdempotencyRecord(ctx context.Context, tx pgx.Tx, userID, chatID, key string) error { + const query = ` + DELETE FROM message_idempotency + WHERE user_id = $1 AND chat_id = $2 AND key = $3` + if _, err := tx.Exec(ctx, query, userID, chatID, key); err != nil { + return fmt.Errorf("delete expired idempotency key: %w", err) + } + return nil +} + +func reserveIdempotencyKey( + ctx context.Context, + tx pgx.Tx, + userID string, + chatID string, + key string, + requestHash []byte, + messageID string, + ttl time.Duration, +) (bool, error) { + const query = ` + INSERT INTO message_idempotency (user_id, chat_id, key, request_hash, message_id, expires_at) + VALUES ($1, $2, $3, $4, $5, statement_timestamp() + $6 * INTERVAL '1 second') + ON CONFLICT (user_id, chat_id, key) DO NOTHING + RETURNING true` + + var ( + inserted bool + err error + ) + err = tx.QueryRow(ctx, query, userID, chatID, key, requestHash, messageID, int64(ttl/time.Second)).Scan(&inserted) + if errors.Is(err, pgx.ErrNoRows) { + return false, nil + } + if err != nil { + return false, fmt.Errorf("reserve idempotency key: %w", err) + } + return inserted, nil +} + +func insertMessage( + ctx context.Context, + tx pgx.Tx, + messageID string, + chatID string, + senderID string, + text string, +) (model.Message, error) { + const query = ` + INSERT INTO messages (id, chat_id, sender_id, text) + VALUES ($1, $2, $3, $4) + RETURNING id, chat_id, sender_id, text, created_at` + + var ( + message model.Message + err error + ) + err = tx.QueryRow(ctx, query, messageID, chatID, senderID, text).Scan( + &message.ID, + &message.ChatID, + &message.SenderID, + &message.Text, + &message.CreatedAt, + ) + if err != nil { + return model.Message{}, fmt.Errorf("insert message: %w", err) + } + return message, nil +} + +func messageByID(ctx context.Context, tx pgx.Tx, messageID string) (model.Message, error) { + const query = ` + SELECT id, chat_id, sender_id, text, created_at + FROM messages + WHERE id = $1` + + var ( + message model.Message + err error + ) + err = tx.QueryRow(ctx, query, messageID).Scan( + &message.ID, + &message.ChatID, + &message.SenderID, + &message.Text, + &message.CreatedAt, + ) + if errors.Is(err, pgx.ErrNoRows) { + return model.Message{}, fmt.Errorf("idempotency result message not found") + } + if err != nil { + return model.Message{}, fmt.Errorf("get idempotency result message: %w", err) + } + return message, nil +} diff --git a/internal/postgres/store.go b/internal/postgres/store.go index 8096d7e..2e07257 100644 --- a/internal/postgres/store.go +++ b/internal/postgres/store.go @@ -1,12 +1,9 @@ package postgres import ( - "bytes" "context" - "crypto/sha256" "errors" "fmt" - "time" "github.com/google/uuid" "github.com/jackc/pgx/v5" @@ -322,221 +319,6 @@ func (s *Store) visibleChatPositionExists( return exists, nil } -func (s *Store) CreateMessage( - ctx context.Context, - chatID string, - senderID string, - text string, - idempotencyKey string, - idempotencyTTL time.Duration, -) (model.Message, bool, error) { - tx, err := s.pool.BeginTx(ctx, pgx.TxOptions{}) - if err != nil { - return model.Message{}, false, fmt.Errorf("begin create message transaction: %w", err) - } - defer func() { _ = tx.Rollback(context.WithoutCancel(ctx)) }() - - visible, err := chatVisibleInTransaction(ctx, tx, chatID, senderID) - if err != nil { - return model.Message{}, false, err - } - if !visible { - return model.Message{}, false, ErrNotFound - } - - requestHash := sha256.Sum256([]byte(text)) - message, replay, err := createIdempotentMessage( - ctx, tx, chatID, senderID, text, idempotencyKey, requestHash[:], idempotencyTTL, - ) - if err != nil { - return model.Message{}, false, err - } - if err := tx.Commit(ctx); err != nil { - return model.Message{}, false, fmt.Errorf("commit create message transaction: %w", err) - } - return message, replay, nil -} - -func chatVisibleInTransaction(ctx context.Context, tx pgx.Tx, chatID, userID string) (bool, error) { - const query = ` - SELECT EXISTS ( - SELECT 1 - FROM chat_members - WHERE chat_id = $1 AND user_id = $2 - )` - - var visible bool - if err := tx.QueryRow(ctx, query, chatID, userID).Scan(&visible); err != nil { - return false, fmt.Errorf("check chat visibility: %w", err) - } - return visible, nil -} - -func createIdempotentMessage( - ctx context.Context, - tx pgx.Tx, - chatID string, - senderID string, - text string, - idempotencyKey string, - requestHash []byte, - idempotencyTTL time.Duration, -) (model.Message, bool, error) { - for { - record, found, err := lockIdempotencyRecord(ctx, tx, senderID, chatID, idempotencyKey) - if err != nil { - return model.Message{}, false, err - } - if found && record.active { - if !bytes.Equal(record.requestHash, requestHash) { - return model.Message{}, false, ErrIdempotencyConflict - } - message, err := messageByID(ctx, tx, record.messageID) - return message, true, err - } - if found { - if err := deleteIdempotencyRecord(ctx, tx, senderID, chatID, idempotencyKey); err != nil { - return model.Message{}, false, err - } - } - - messageID := uuid.NewString() - reserved, err := reserveIdempotencyKey( - ctx, tx, senderID, chatID, idempotencyKey, requestHash, messageID, idempotencyTTL, - ) - if err != nil { - return model.Message{}, false, err - } - if !reserved { - continue - } - - message, err := insertMessage(ctx, tx, messageID, chatID, senderID, text) - return message, false, err - } -} - -type idempotencyRecord struct { - requestHash []byte - messageID string - active bool -} - -func lockIdempotencyRecord( - ctx context.Context, - tx pgx.Tx, - userID string, - chatID string, - key string, -) (idempotencyRecord, bool, error) { - const query = ` - SELECT request_hash, message_id, expires_at > statement_timestamp() - FROM message_idempotency - WHERE user_id = $1 AND chat_id = $2 AND key = $3 - FOR UPDATE` - - var record idempotencyRecord - err := tx.QueryRow(ctx, query, userID, chatID, key).Scan( - &record.requestHash, - &record.messageID, - &record.active, - ) - if errors.Is(err, pgx.ErrNoRows) { - return idempotencyRecord{}, false, nil - } - if err != nil { - return idempotencyRecord{}, false, fmt.Errorf("lock idempotency key: %w", err) - } - return record, true, nil -} - -func deleteIdempotencyRecord(ctx context.Context, tx pgx.Tx, userID, chatID, key string) error { - const query = ` - DELETE FROM message_idempotency - WHERE user_id = $1 AND chat_id = $2 AND key = $3` - if _, err := tx.Exec(ctx, query, userID, chatID, key); err != nil { - return fmt.Errorf("delete expired idempotency key: %w", err) - } - return nil -} - -func reserveIdempotencyKey( - ctx context.Context, - tx pgx.Tx, - userID string, - chatID string, - key string, - requestHash []byte, - messageID string, - ttl time.Duration, -) (bool, error) { - const query = ` - INSERT INTO message_idempotency (user_id, chat_id, key, request_hash, message_id, expires_at) - VALUES ($1, $2, $3, $4, $5, statement_timestamp() + $6 * INTERVAL '1 second') - ON CONFLICT (user_id, chat_id, key) DO NOTHING - RETURNING true` - - var inserted bool - err := tx.QueryRow(ctx, query, userID, chatID, key, requestHash, messageID, int64(ttl/time.Second)).Scan(&inserted) - if errors.Is(err, pgx.ErrNoRows) { - return false, nil - } - if err != nil { - return false, fmt.Errorf("reserve idempotency key: %w", err) - } - return inserted, nil -} - -func insertMessage( - ctx context.Context, - tx pgx.Tx, - messageID string, - chatID string, - senderID string, - text string, -) (model.Message, error) { - const query = ` - INSERT INTO messages (id, chat_id, sender_id, text) - VALUES ($1, $2, $3, $4) - RETURNING id, chat_id, sender_id, text, created_at` - - var message model.Message - err := tx.QueryRow(ctx, query, messageID, chatID, senderID, text).Scan( - &message.ID, - &message.ChatID, - &message.SenderID, - &message.Text, - &message.CreatedAt, - ) - if err != nil { - return model.Message{}, fmt.Errorf("insert message: %w", err) - } - return message, nil -} - -func messageByID(ctx context.Context, tx pgx.Tx, messageID string) (model.Message, error) { - const query = ` - SELECT id, chat_id, sender_id, text, created_at - FROM messages - WHERE id = $1` - - var message model.Message - err := tx.QueryRow(ctx, query, messageID).Scan( - &message.ID, - &message.ChatID, - &message.SenderID, - &message.Text, - &message.CreatedAt, - ) - if errors.Is(err, pgx.ErrNoRows) { - return model.Message{}, fmt.Errorf("idempotency result message not found") - } - if err != nil { - return model.Message{}, fmt.Errorf("get idempotency result message: %w", err) - } - return message, nil -} - func (s *Store) ListMessages( ctx context.Context, chatID string, diff --git a/internal/postgres/store_integration_test.go b/internal/postgres/store_integration_test.go index b0efe22..469f5a2 100644 --- a/internal/postgres/store_integration_test.go +++ b/internal/postgres/store_integration_test.go @@ -11,15 +11,37 @@ import ( "github.com/google/uuid" "github.com/jackc/pgx/v5/pgxpool" + "github.com/stretchr/testify/suite" "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/database" "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/model" "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/postgres" ) -func TestConcurrentUsernameCreation(t *testing.T) { - pool := openTestDatabase(t) - store := postgres.New(pool) +type PostgresSuite struct { + suite.Suite + pool *pgxpool.Pool + store *postgres.Store +} + +func TestPostgresSuite(t *testing.T) { + suite.Run(t, new(PostgresSuite)) +} + +func (s *PostgresSuite) SetupSuite() { + s.pool = openTestDatabase(s.T()) + s.store = postgres.New(s.pool) +} + +func (s *PostgresSuite) TearDownSuite() { + if s.pool != nil { + s.pool.Close() + } +} + +func (s *PostgresSuite) TestConcurrentUsernameCreation() { + t := s.T() + store := s.store username := "race_" + strings.ReplaceAll(uuid.NewString(), "-", "")[:16] const workers = 8 @@ -52,9 +74,10 @@ func TestConcurrentUsernameCreation(t *testing.T) { } } -func TestCreateChatRollsBackForUnknownMember(t *testing.T) { - pool := openTestDatabase(t) - store := postgres.New(pool) +func (s *PostgresSuite) TestCreateChatRollsBackForUnknownMember() { + t := s.T() + pool := s.pool + store := s.store owner, err := store.CreateUser(context.Background(), uniqueUsername(), "Owner", "password-hash") if err != nil { t.Fatalf("CreateUser() error = %v", err) @@ -70,9 +93,10 @@ func TestCreateChatRollsBackForUnknownMember(t *testing.T) { } } -func TestMessageIdempotencyReplayAndConflict(t *testing.T) { - pool := openTestDatabase(t) - store := postgres.New(pool) +func (s *PostgresSuite) TestMessageIdempotencyReplayAndConflict() { + t := s.T() + pool := s.pool + store := s.store owner, chatID := createOwnerAndChat(t, store) key := uuid.NewString() @@ -95,8 +119,9 @@ func TestMessageIdempotencyReplayAndConflict(t *testing.T) { } } -func TestConcurrentMessageIdempotency(t *testing.T) { - pool := openTestDatabase(t) +func (s *PostgresSuite) TestConcurrentMessageIdempotency() { + t := s.T() + pool := s.pool stores := []*postgres.Store{postgres.New(pool), postgres.New(pool)} owner, chatID := createOwnerAndChat(t, stores[0]) key := uuid.NewString() @@ -146,9 +171,10 @@ func TestConcurrentMessageIdempotency(t *testing.T) { } } -func TestMessageIdempotencyScopeAndExpiry(t *testing.T) { - pool := openTestDatabase(t) - store := postgres.New(pool) +func (s *PostgresSuite) TestMessageIdempotencyScopeAndExpiry() { + t := s.T() + pool := s.pool + store := s.store owner, chatID := createOwnerAndChat(t, store) second, err := store.CreateUser(context.Background(), uniqueUsername(), "Second", "password-hash") if err != nil { @@ -182,6 +208,38 @@ func TestMessageIdempotencyScopeAndExpiry(t *testing.T) { } } +func (s *PostgresSuite) TestExpiredIdempotencyRecordsAreCleanedOnNewMessages() { + t := s.T() + owner, chatID := createOwnerAndChat(t, s.store) + expiredKey := uuid.NewString() + if _, _, err := s.store.CreateMessage(context.Background(), chatID, owner.ID, "expired", expiredKey, 24*time.Hour); err != nil { + t.Fatalf("create expired message: %v", err) + } + if _, err := s.pool.Exec(context.Background(), ` + UPDATE message_idempotency + SET created_at = clock_timestamp() - INTERVAL '2 days', + expires_at = clock_timestamp() - INTERVAL '1 day' + WHERE user_id = $1 AND chat_id = $2 AND key = $3`, owner.ID, chatID, expiredKey); err != nil { + t.Fatalf("expire idempotency key: %v", err) + } + if _, _, err := s.store.CreateMessage( + context.Background(), chatID, owner.ID, "new message", uuid.NewString(), 24*time.Hour, + ); err != nil { + t.Fatalf("create new message: %v", err) + } + + var remaining int + if err := s.pool.QueryRow(context.Background(), ` + SELECT count(*) + FROM message_idempotency + WHERE user_id = $1 AND chat_id = $2 AND key = $3`, owner.ID, chatID, expiredKey).Scan(&remaining); err != nil { + t.Fatalf("count expired idempotency records: %v", err) + } + if remaining != 0 { + t.Fatalf("expired idempotency records = %d, want 0", remaining) + } +} + func createOwnerAndChat(t *testing.T, store *postgres.Store) (model.User, string) { t.Helper() owner, err := store.CreateUser(context.Background(), uniqueUsername(), "Owner", "password-hash") @@ -219,7 +277,6 @@ func openTestDatabase(t *testing.T) *pgxpool.Pool { pool.Close() t.Fatalf("database.Migrate() error = %v", err) } - t.Cleanup(pool.Close) return pool } diff --git a/internal/session/session_integration_test.go b/internal/session/session_integration_test.go index 8016b3f..e22a63d 100644 --- a/internal/session/session_integration_test.go +++ b/internal/session/session_integration_test.go @@ -9,75 +9,64 @@ import ( "time" "github.com/google/uuid" + "github.com/stretchr/testify/suite" "gitea.privcloud.tech/dizi/mtusi2026lab3/internal/session" ) -func TestSessionLifecycle(t *testing.T) { - store := openTestStore(t) - userID := uuid.NewString() - token, expiresAt, err := store.Create(context.Background(), userID, time.Minute) - if err != nil { - t.Fatalf("Create() error = %v", err) - } - if token == "" || !expiresAt.After(time.Now()) { - t.Fatalf("invalid token or expiry: token length = %d, expires_at = %v", len(token), expiresAt) - } - - actualUserID, err := store.UserID(context.Background(), token) - if err != nil { - t.Fatalf("UserID() error = %v", err) - } - if actualUserID != userID { - t.Fatalf("UserID() = %q, want %q", actualUserID, userID) - } - if err := store.Delete(context.Background(), token); err != nil { - t.Fatalf("Delete() error = %v", err) - } - if _, err := store.UserID(context.Background(), token); !errors.Is(err, session.ErrNotFound) { - t.Fatalf("UserID() after delete error = %v, want ErrNotFound", err) - } +type SessionSuite struct { + suite.Suite + store *session.Store } -func TestSessionExpires(t *testing.T) { - store := openTestStore(t) - token, _, err := store.Create(context.Background(), uuid.NewString(), time.Second) - if err != nil { - t.Fatalf("Create() error = %v", err) - } - - deadline := time.Now().Add(3 * time.Second) - for time.Now().Before(deadline) { - _, err := store.UserID(context.Background(), token) - if errors.Is(err, session.ErrNotFound) { - return - } - if err != nil { - t.Fatalf("UserID() error = %v", err) - } - time.Sleep(50 * time.Millisecond) - } - t.Fatal("session did not expire within three seconds") +func TestSessionSuite(t *testing.T) { + suite.Run(t, new(SessionSuite)) } -func openTestStore(t *testing.T) *session.Store { - t.Helper() - url := strings.TrimSpace(os.Getenv("TEST_CACHE_URL")) - if url == "" { +func (s *SessionSuite) SetupSuite() { + rawURL := strings.TrimSpace(os.Getenv("TEST_CACHE_URL")) + if rawURL == "" { path := strings.TrimSpace(os.Getenv("TEST_CACHE_URL_FILE")) if path == "" { - t.Skip("set TEST_CACHE_URL or TEST_CACHE_URL_FILE to run integration tests") + s.T().Skip("set TEST_CACHE_URL or TEST_CACHE_URL_FILE to run integration tests") } data, err := os.ReadFile(path) - if err != nil { - t.Fatalf("read TEST_CACHE_URL_FILE: %v", err) - } - url = strings.TrimSpace(string(data)) + s.Require().NoError(err) + rawURL = strings.TrimSpace(string(data)) } - store, err := session.New(url) - if err != nil { - t.Fatalf("session.New() error = %v", err) + store, err := session.New(rawURL) + s.Require().NoError(err) + s.store = store +} + +func (s *SessionSuite) TearDownSuite() { + if s.store != nil { + s.Require().NoError(s.store.Close()) } - t.Cleanup(func() { _ = store.Close() }) - return store +} + +func (s *SessionSuite) TestSessionLifecycle() { + userID := uuid.NewString() + token, expiresAt, err := s.store.Create(context.Background(), userID, time.Minute) + s.Require().NoError(err) + s.NotEmpty(token) + s.True(expiresAt.After(time.Now())) + + actualUserID, err := s.store.UserID(context.Background(), token) + s.Require().NoError(err) + s.Equal(userID, actualUserID) + s.Require().NoError(s.store.Delete(context.Background(), token)) + + _, err = s.store.UserID(context.Background(), token) + s.ErrorIs(err, session.ErrNotFound) +} + +func (s *SessionSuite) TestSessionExpires() { + token, _, err := s.store.Create(context.Background(), uuid.NewString(), time.Second) + s.Require().NoError(err) + + s.Eventually(func() bool { + _, err = s.store.UserID(context.Background(), token) + return errors.Is(err, session.ErrNotFound) + }, 3*time.Second, 50*time.Millisecond) }