fix: address review comments
CI / verify (pull_request) Successful in 4m21s

This commit is contained in:
2026-10-02 17:23:58 +03:00
parent 18d51db435
commit 0062313c0b
15 changed files with 698 additions and 395 deletions
-2
View File
@@ -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
+4 -4
View File
@@ -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.
## Источники и инструменты
+168 -3
View File
@@ -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
+30 -2
View File
@@ -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)
}
-34
View File
@@ -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)
}
+1 -1
View File
@@ -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}
+1
View File
@@ -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
+4
View File
@@ -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
)
+42 -20
View File
@@ -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 {
+13 -7
View File
@@ -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))
}
+32 -32
View File
@@ -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 {
+285
View File
@@ -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
}
-218
View File
@@ -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,
+72 -15
View File
@@ -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
}
+46 -57
View File
@@ -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)
}