package httpapi import ( "bytes" "context" "encoding/json" "fmt" "net/http" "net/http/httptest" "strings" "testing" "time" "mtusi2026/internal/cache" "mtusi2026/internal/idgen" "mtusi2026/internal/model" "mtusi2026/internal/sessionstore" "mtusi2026/internal/store" "github.com/redis/go-redis/v9" ) //вспомогательные функции func newKey() string { return idgen.GenerateUUIDv4() } func doMessage(srv *httptest.Server, chatID, token, key string, body any) (*http.Response, error) { var buf bytes.Buffer if s, ok := body.(string); ok { buf.WriteString(s) } else if err := json.NewEncoder(&buf).Encode(body); err != nil { return nil, err } req, err := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/api/v1/chats/%s/messages", srv.URL, chatID), &buf) if err != nil { return nil, err } req.Header.Set("Content-Type", "application/json") if token != "" { req.Header.Set("Authorization", "Bearer "+token) } if key != "" { req.Header.Set("Idempotency-Key", key) } return srv.Client().Do(req) } func postMessage(t *testing.T, srv *httptest.Server, chatID, token, key string, body any) *http.Response { t.Helper() resp, err := doMessage(srv, chatID, token, key, body) if err != nil { t.Fatalf("do request: %v", err) } return resp } func newUnlimitedLimiter() *store.Limiter { return store.NewLimiter(1_000_000, 1000) } func newTestServer(t *testing.T) *httptest.Server { t.Helper() srv, _ := newTestServerWithStore(t) return srv } func newTestServerWithStore(t *testing.T) (*httptest.Server, *store.Store) { t.Helper() truncateAll(t) s := store.New(testPool, newUnlimitedLimiter()) ss := newMemorySessionStore() return httptest.NewServer(NewRouter(s, testPool, ss)), s } func newRedisTestServer(t *testing.T) *httptest.Server { t.Helper() srv, _ := newRedisTestServerWithStore(t) return srv } func newRedisTestServerWithStore(t *testing.T) (*httptest.Server, *store.Store) { t.Helper() truncateAll(t) if err := testRedis.FlushDB(context.Background()).Err(); err != nil { t.Fatalf("flush redis: %v", err) } s := store.New(testPool, newUnlimitedLimiter()) ss := sessionstore.NewRedis(testRedis) return httptest.NewServer(NewRouter(s, testPool, ss)), s } func newCachedRedisTestServer(t *testing.T) (*httptest.Server, *store.Store) { t.Helper() truncateAll(t) if err := testRedis.FlushDB(context.Background()).Err(); err != nil { t.Fatalf("flush redis: %v", err) } s := store.New(testPool, newUnlimitedLimiter()) ss := sessionstore.NewRedis(testRedis) chatCache := cache.New(testRedis, 30*time.Second) srv := httptest.NewServer( NewRouterWithCache(s, testPool, ss, chatCache), ) return srv, s } type testUser struct { model.User Token string } func postJSON(t *testing.T, srv *httptest.Server, path string, token string, body any) *http.Response { t.Helper() var buf bytes.Buffer if s, ok := body.(string); ok { buf.WriteString(s) } else if err := json.NewEncoder(&buf).Encode(body); err != nil { t.Fatalf("encode request body: %v", err) } req, err := http.NewRequest(http.MethodPost, srv.URL+path, &buf) if err != nil { t.Fatalf("build request: %v", err) } req.Header.Set("Content-Type", "application/json") if token != "" { req.Header.Set("Authorization", "Bearer "+token) } resp, err := srv.Client().Do(req) if err != nil { t.Fatalf("do request: %v", err) } return resp } func getJSON(t *testing.T, srv *httptest.Server, path string, token string) *http.Response { t.Helper() req, err := http.NewRequest(http.MethodGet, srv.URL+path, nil) if err != nil { t.Fatalf("build request: %v", err) } if token != "" { req.Header.Set("Authorization", "Bearer "+token) } resp, err := srv.Client().Do(req) if err != nil { t.Fatalf("do request: %v", err) } return resp } func decodeBody[T any](t *testing.T, resp *http.Response) T { t.Helper() defer resp.Body.Close() var v T if err := json.NewDecoder(resp.Body).Decode(&v); err != nil { t.Fatalf("decode response body: %v", err) } return v } func mustLogin(t *testing.T, srv *httptest.Server, username, password string) string { t.Helper() req, err := http.NewRequest(http.MethodPost, srv.URL+"/api/v1/auth/sessions", nil) if err != nil { t.Fatalf("build login request: %v", err) } req.SetBasicAuth(username, password) resp, err := srv.Client().Do(req) if err != nil { t.Fatalf("do login request: %v", err) } if resp.StatusCode != http.StatusCreated { t.Fatalf("login %s: expected 201, got %d", username, resp.StatusCode) } session := decodeBody[model.Session](t, resp) return session.Token } func mustRegisterUser(t *testing.T, srv *httptest.Server, username string) testUser { t.Helper() const password = "correct-horse-battery-staple" resp := postJSON(t, srv, "/api/v1/users", "", model.CreateUserRequest{ Username: username, DisplayName: "Test " + username, Password: password, }) if resp.StatusCode != http.StatusCreated { t.Fatalf("register %s: expected 201, got %d", username, resp.StatusCode) } u := decodeBody[model.User](t, resp) token := mustLogin(t, srv, username, password) return testUser{User: u, Token: token} } func mustCreateChat(t *testing.T, srv *httptest.Server, caller testUser, title string, memberIDs []string) model.Chat { t.Helper() resp := postJSON(t, srv, "/api/v1/chats", caller.Token, model.CreateChatRequest{ Title: title, MemberIDs: memberIDs, }) if resp.StatusCode != http.StatusCreated { t.Fatalf("create chat: expected 201, got %d", resp.StatusCode) } return decodeBody[model.Chat](t, resp) } // тесты пользователи func TestRegisterUser_DuplicateUsername_Returns409(t *testing.T) { srv := newTestServer(t) defer srv.Close() mustRegisterUser(t, srv, "alice") resp := postJSON(t, srv, "/api/v1/users", "", model.CreateUserRequest{ Username: "alice", DisplayName: "Другая Алиса", Password: "correct-horse-battery-staple", }) if resp.StatusCode != http.StatusConflict { t.Fatalf("expected 409, got %d", resp.StatusCode) } errBody := decodeBody[model.ErrorEnvelope](t, resp) if errBody.Error.Code != "conflict" { t.Fatalf("expected error code 'conflict', got %q", errBody.Error.Code) } if errBody.Error.RequestID == "" { t.Fatal("expected non-empty request_id") } } func TestRegisterUser_InvalidPasswordLength_Returns400(t *testing.T) { srv := newTestServer(t) defer srv.Close() cases := []string{"short", strings.Repeat("a", 129)} for _, password := range cases { resp := postJSON(t, srv, "/api/v1/users", "", model.CreateUserRequest{ Username: "alice", DisplayName: "Алиса", Password: password, }) if resp.StatusCode != http.StatusBadRequest { t.Errorf("password len %d: expected 400, got %d", len(password), resp.StatusCode) } } } func TestRegisterUser_InvalidJSON_Returns400(t *testing.T) { srv := newTestServer(t) defer srv.Close() resp := postJSON(t, srv, "/api/v1/users", "", `{"username":`) if resp.StatusCode != http.StatusBadRequest { t.Fatalf("expected 400, got %d", resp.StatusCode) } } func TestRegisterUser_UnknownField_Returns400(t *testing.T) { srv := newTestServer(t) defer srv.Close() resp := postJSON(t, srv, "/api/v1/users", "", `{"username":"bob","display_name":"Боб","password":"correct-horse-battery-staple","extra":"whatever"}`) if resp.StatusCode != http.StatusBadRequest { t.Fatalf("expected 400 on unknown field, got %d", resp.StatusCode) } } func TestRegisterUser_InvalidUsernamePattern_Returns400(t *testing.T) { srv := newTestServer(t) defer srv.Close() cases := []string{"AB", "ab", "Has-Dash", "こんにちは"} for _, username := range cases { resp := postJSON(t, srv, "/api/v1/users", "", model.CreateUserRequest{ Username: username, DisplayName: "Тест", Password: "correct-horse-battery-staple", }) if resp.StatusCode != http.StatusBadRequest { t.Errorf("username %q: expected 400, got %d", username, resp.StatusCode) } } } func TestCurrentUser_MissingHeader_Returns401(t *testing.T) { srv := newTestServer(t) defer srv.Close() resp := getJSON(t, srv, "/api/v1/users/me", "") if resp.StatusCode != http.StatusUnauthorized { t.Fatalf("expected 401, got %d", resp.StatusCode) } } func TestCurrentUser_UnknownToken_Returns401(t *testing.T) { srv := newTestServer(t) defer srv.Close() resp := getJSON(t, srv, "/api/v1/users/me", "totally-made-up-token") if resp.StatusCode != http.StatusUnauthorized { t.Fatalf("expected 401, got %d", resp.StatusCode) } } //тесты вход и сессии func TestCreateSession_WrongPassword_Returns401(t *testing.T) { srv := newTestServer(t) defer srv.Close() mustRegisterUser(t, srv, "alice") req, _ := http.NewRequest(http.MethodPost, srv.URL+"/api/v1/auth/sessions", nil) req.SetBasicAuth("alice", "totally-wrong-password") resp, err := srv.Client().Do(req) if err != nil { t.Fatalf("do request: %v", err) } if resp.StatusCode != http.StatusUnauthorized { t.Fatalf("expected 401, got %d", resp.StatusCode) } if resp.Header.Get("WWW-Authenticate") == "" { t.Error("expected WWW-Authenticate header on failed login") } } func TestCreateSession_UnknownUsername_Returns401(t *testing.T) { srv := newTestServer(t) defer srv.Close() req, _ := http.NewRequest(http.MethodPost, srv.URL+"/api/v1/auth/sessions", nil) req.SetBasicAuth("nobody_here", "whatever-password-12") resp, err := srv.Client().Do(req) if err != nil { t.Fatalf("do request: %v", err) } if resp.StatusCode != http.StatusUnauthorized { t.Fatalf("expected 401, got %d", resp.StatusCode) } } func TestDeleteSession_ThenReuse_Returns401(t *testing.T) { srv := newTestServer(t) defer srv.Close() alice := mustRegisterUser(t, srv, "alice") req, _ := http.NewRequest(http.MethodDelete, srv.URL+"/api/v1/auth/sessions/current", nil) req.Header.Set("Authorization", "Bearer "+alice.Token) resp, err := srv.Client().Do(req) if err != nil { t.Fatalf("do logout request: %v", err) } if resp.StatusCode != http.StatusNoContent { t.Fatalf("expected 204, got %d", resp.StatusCode) } // повторное использование отозванного токена -401 resp2 := getJSON(t, srv, "/api/v1/users/me", alice.Token) if resp2.StatusCode != http.StatusUnauthorized { t.Fatalf("expected 401 after logout, got %d", resp2.StatusCode) } } //тесты чаты и membership func TestCreateChat_CallerNotInMembers_Returns400(t *testing.T) { srv := newTestServer(t) defer srv.Close() alice := mustRegisterUser(t, srv, "alice") bob := mustRegisterUser(t, srv, "bob") resp := postJSON(t, srv, "/api/v1/chats", alice.Token, model.CreateChatRequest{ Title: "Без себя", MemberIDs: []string{bob.ID}, }) if resp.StatusCode != http.StatusBadRequest { t.Fatalf("expected 400, got %d", resp.StatusCode) } } func TestCreateChat_DuplicateMemberIDs_Returns400(t *testing.T) { srv := newTestServer(t) defer srv.Close() alice := mustRegisterUser(t, srv, "alice") resp := postJSON(t, srv, "/api/v1/chats", alice.Token, model.CreateChatRequest{ Title: "Дубли", MemberIDs: []string{alice.ID, alice.ID}, }) if resp.StatusCode != http.StatusBadRequest { t.Fatalf("expected 400, got %d", resp.StatusCode) } } func TestGetChat_NotMember_Returns404NotForbidden(t *testing.T) { srv := newTestServer(t) defer srv.Close() alice := mustRegisterUser(t, srv, "alice") bob := mustRegisterUser(t, srv, "bob") carol := mustRegisterUser(t, srv, "carol") chat := mustCreateChat(t, srv, alice, "Приватный", []string{alice.ID, bob.ID}) resp := getJSON(t, srv, "/api/v1/chats/"+chat.ID, carol.Token) if resp.StatusCode != http.StatusNotFound { t.Fatalf("expected 404 for non-member (never 403), got %d", resp.StatusCode) } } func TestGetChat_UnknownChatID_Returns404(t *testing.T) { srv := newTestServer(t) defer srv.Close() alice := mustRegisterUser(t, srv, "alice") resp := getJSON(t, srv, "/api/v1/chats/11111111-1111-4111-8111-111111111111", alice.Token) if resp.StatusCode != http.StatusNotFound { t.Fatalf("expected 404, got %d", resp.StatusCode) } } // тесты: сообщения func TestCreateMessage_EmptyText_Returns400(t *testing.T) { srv := newTestServer(t) defer srv.Close() alice := mustRegisterUser(t, srv, "alice") chat := mustCreateChat(t, srv, alice, "Чат", []string{alice.ID}) resp := postMessage(t, srv, chat.ID, alice.Token, newKey(), model.CreateMessageRequest{Text: ""}) if resp.StatusCode != http.StatusBadRequest { t.Fatalf("expected 400 for empty text, got %d", resp.StatusCode) } } func TestCreateMessage_WhitespaceOnlyText_Returns400(t *testing.T) { srv := newTestServer(t) defer srv.Close() alice := mustRegisterUser(t, srv, "alice") chat := mustCreateChat(t, srv, alice, "Чат", []string{alice.ID}) resp := postMessage(t, srv, chat.ID, alice.Token, newKey(), model.CreateMessageRequest{Text: " \t\n "}) if resp.StatusCode != http.StatusBadRequest { t.Fatalf("expected 400 for whitespace-only text, got %d", resp.StatusCode) } } func TestCreateMessage_ForeignChat_Returns404(t *testing.T) { srv := newTestServer(t) defer srv.Close() alice := mustRegisterUser(t, srv, "alice") bob := mustRegisterUser(t, srv, "bob") carol := mustRegisterUser(t, srv, "carol") chat := mustCreateChat(t, srv, alice, "Приватный", []string{alice.ID, bob.ID}) resp := postMessage(t, srv, chat.ID, carol.Token, newKey(), model.CreateMessageRequest{Text: "Я тут чужая"}) if resp.StatusCode != http.StatusNotFound { t.Fatalf("expected 404 for foreign chat, got %d", resp.StatusCode) } } func TestCreateMessage_SenderIDIgnoredFromRequestBody(t *testing.T) { srv := newTestServer(t) defer srv.Close() alice := mustRegisterUser(t, srv, "alice") bob := mustRegisterUser(t, srv, "bob") chat := mustCreateChat(t, srv, alice, "Чат", []string{alice.ID, bob.ID}) raw := fmt.Sprintf(`{"text":"Привет","sender_id":%q}`, bob.ID) resp := postMessage(t, srv, chat.ID, alice.Token, newKey(), raw) if resp.StatusCode != http.StatusBadRequest { t.Fatalf("expected 400 (unknown field sender_id), got %d", resp.StatusCode) } } // тесты пагинация func TestListMessages_PaginationAcrossMultiplePages(t *testing.T) { srv := newTestServer(t) defer srv.Close() alice := mustRegisterUser(t, srv, "alice") chat := mustCreateChat(t, srv, alice, "Чат", []string{alice.ID}) const total = 5 for i := 0; i < total; i++ { resp := postMessage(t, srv, chat.ID, alice.Token, newKey(), model.CreateMessageRequest{ Text: fmt.Sprintf("сообщение %d", i), }) if resp.StatusCode != http.StatusCreated { t.Fatalf("create message %d: expected 201, got %d", i, resp.StatusCode) } resp.Body.Close() } seen := make(map[string]bool) cursor := "" pages := 0 for { path := fmt.Sprintf("/api/v1/chats/%s/messages?limit=2", chat.ID) if cursor != "" { path += "&cursor=" + cursor } resp := getJSON(t, srv, path, alice.Token) if resp.StatusCode != http.StatusOK { t.Fatalf("list messages: expected 200, got %d", resp.StatusCode) } page := decodeBody[model.MessagePage](t, resp) pages++ for _, m := range page.Items { if seen[m.ID] { t.Fatalf("duplicate message across pages: %s", m.ID) } seen[m.ID] = true } if page.NextCursor == nil { break } cursor = *page.NextCursor if pages > total { t.Fatal("too many pages — possible cursor bug (infinite loop)") } } if len(seen) != total { t.Fatalf("expected %d unique messages across all pages, got %d", total, len(seen)) } if pages < 2 { t.Fatalf("expected pagination to span multiple pages, got %d page(s)", pages) } } func TestListMessages_CursorFromDifferentChat_Returns400(t *testing.T) { srv := newTestServer(t) defer srv.Close() alice := mustRegisterUser(t, srv, "alice") chatA := mustCreateChat(t, srv, alice, "Чат A", []string{alice.ID}) chatB := mustCreateChat(t, srv, alice, "Чат B", []string{alice.ID}) postMessage(t, srv, chatA.ID, alice.Token, newKey(), model.CreateMessageRequest{Text: "первое"}).Body.Close() postMessage(t, srv, chatA.ID, alice.Token, newKey(), model.CreateMessageRequest{Text: "второе"}).Body.Close() respA := getJSON(t, srv, fmt.Sprintf("/api/v1/chats/%s/messages?limit=1", chatA.ID), alice.Token) pageA := decodeBody[model.MessagePage](t, respA) if pageA.NextCursor == nil { t.Fatal("expected next_cursor to be present after inserting 2 messages with limit=1") } resp := getJSON(t, srv, fmt.Sprintf("/api/v1/chats/%s/messages?cursor=%s", chatB.ID, *pageA.NextCursor), alice.Token) if resp.StatusCode != http.StatusBadRequest { t.Fatalf("expected 400 for cross-chat cursor, got %d", resp.StatusCode) } } func TestCreateSession_RedisTTLExpires(t *testing.T) { srv := newRedisTestServer(t) defer srv.Close() mustRegisterUser(t, srv, "alice") t.Setenv("SESSION_TTL_SECONDS", "1") token := mustLogin(t, srv, "alice", "correct-horse-battery-staple") resp := getJSON(t, srv, "/api/v1/users/me", token) if resp.StatusCode != http.StatusOK { t.Fatalf("expected 200 immediately after login, got %d", resp.StatusCode) } resp.Body.Close() time.Sleep(1500 * time.Millisecond) resp = getJSON(t, srv, "/api/v1/users/me", token) if resp.StatusCode != http.StatusUnauthorized { t.Fatalf("expected 401 after session TTL expiration, got %d", resp.StatusCode) } resp.Body.Close() } func TestCurrentUser_RedisUnavailable_Returns503(t *testing.T) { srv, s := newRedisTestServerWithStore(t) defer srv.Close() alice := mustRegisterUser(t, srv, "alice") resp := getJSON(t, srv, "/api/v1/users/me", alice.Token) if resp.StatusCode != http.StatusOK { t.Fatalf("expected 200 before redis failure, got %d", resp.StatusCode) } resp.Body.Close() redisDownClient := redis.NewClient(&redis.Options{ Addr: "127.0.0.1:1", }) defer redisDownClient.Close() redisDownSessionStore := sessionstore.NewRedis(redisDownClient) downSrv := httptest.NewServer( NewRouter(s, testPool, redisDownSessionStore), ) defer downSrv.Close() resp = getJSON(t, downSrv, "/api/v1/users/me", alice.Token) if resp.StatusCode != http.StatusServiceUnavailable { t.Fatalf( "expected 503 when redis is unavailable, got %d", resp.StatusCode, ) } resp.Body.Close() } func TestChatCache_ConcurrentRequests(t *testing.T) { const concurrentRequests = 50 baselineSrv, baselineStore := newTestServerWithStore(t) defer baselineSrv.Close() baselineUser := mustRegisterUser(t, baselineSrv, "cachebaseline") baselineChat := mustCreateChat( t, baselineSrv, baselineUser, "Cache baseline", []string{baselineUser.ID}, ) baselineStore.ResetChatSQLQueries() start := make(chan struct{}) errCh := make(chan error, concurrentRequests) baselineStart := time.Now() for i := 0; i < concurrentRequests; i++ { go func() { <-start _, err := baselineStore.GetChat( context.Background(), baselineChat.ID, baselineUser.ID, ) errCh <- err }() } close(start) for i := 0; i < concurrentRequests; i++ { if err := <-errCh; err != nil { t.Fatal(err) } } baselineLatency := time.Since(baselineStart) baselineQueries := baselineStore.ChatSQLQueries() cachedSrv, cachedStore := newCachedRedisTestServer(t) defer cachedSrv.Close() cachedUser := mustRegisterUser(t, cachedSrv, "cacheprotected") cachedChat := mustCreateChat( t, cachedSrv, cachedUser, "Cache protected", []string{cachedUser.ID}, ) cacheKey := "chat:" + cachedUser.ID + ":" + cachedChat.ID if err := testRedis.Del(context.Background(), cacheKey).Err(); err != nil { t.Fatalf("delete cache key: %v", err) } cachedStore.ResetChatSQLQueries() start = make(chan struct{}) errCh = make(chan error, concurrentRequests) cachedStart := time.Now() for i := 0; i < concurrentRequests; i++ { go func() { <-start resp := getJSON( t, cachedSrv, "/api/v1/chats/"+cachedChat.ID, cachedUser.Token, ) defer resp.Body.Close() if resp.StatusCode != http.StatusOK { errCh <- fmt.Errorf("unexpected status: %d", resp.StatusCode) return } errCh <- nil }() } close(start) for i := 0; i < concurrentRequests; i++ { if err := <-errCh; err != nil { t.Fatal(err) } } cachedLatency := time.Since(cachedStart) cachedQueries := cachedStore.ChatSQLQueries() t.Logf( "baseline: requests=%d sql_queries=%d latency=%s", concurrentRequests, baselineQueries, baselineLatency, ) t.Logf( "cold cache + singleflight: requests=%d sql_queries=%d latency=%s", concurrentRequests, cachedQueries, cachedLatency, ) expectedBaselineQueries := int64(concurrentRequests * 2) if baselineQueries != expectedBaselineQueries { t.Errorf( "baseline: expected %d SQL queries, got %d", expectedBaselineQueries, baselineQueries, ) } if cachedQueries > 2 { t.Errorf( "cold cache + singleflight: expected <=2 SQL queries, got %d", cachedQueries, ) } } func TestChatCache_WarmCache(t *testing.T) { const concurrentRequests = 50 srv, s := newCachedRedisTestServer(t) defer srv.Close() user := mustRegisterUser(t, srv, "cachewarm") chat := mustCreateChat( t, srv, user, "Warm cache", []string{user.ID}, ) // Первый GET прогревает cache resp := getJSON( t, srv, "/api/v1/chats/"+chat.ID, user.Token, ) resp.Body.Close() if resp.StatusCode != http.StatusOK { t.Fatalf("warm-up GET: unexpected status %d", resp.StatusCode) } s.ResetChatSQLQueries() start := make(chan struct{}) errCh := make(chan error, concurrentRequests) startedAt := time.Now() for i := 0; i < concurrentRequests; i++ { go func() { <-start resp := getJSON( t, srv, "/api/v1/chats/"+chat.ID, user.Token, ) defer resp.Body.Close() if resp.StatusCode != http.StatusOK { errCh <- fmt.Errorf( "unexpected status: %d", resp.StatusCode, ) return } errCh <- nil }() } close(start) for i := 0; i < concurrentRequests; i++ { if err := <-errCh; err != nil { t.Fatal(err) } } latency := time.Since(startedAt) queries := s.ChatSQLQueries() t.Logf( "warm cache: requests=%d sql_queries=%d latency=%s", concurrentRequests, queries, latency, ) if queries != 0 { t.Errorf( "warm cache: expected 0 SQL queries, got %d", queries, ) } } func TestChatCache_ReadAfterWriteAndRecovery(t *testing.T) { srv, s := newCachedRedisTestServer(t) defer srv.Close() user := mustRegisterUser(t, srv, "cacherecovery") chat := mustCreateChat( t, srv, user, "Read after write", []string{user.ID}, ) s.ResetChatSQLQueries() resp := getJSON( t, srv, "/api/v1/chats/"+chat.ID, user.Token, ) defer resp.Body.Close() if resp.StatusCode != http.StatusOK { t.Fatalf("read-after-write: unexpected status %d", resp.StatusCode) } got := decodeBody[model.Chat](t, resp) if got.ID != chat.ID { t.Fatalf( "read-after-write: expected chat %s, got %s", chat.ID, got.ID, ) } if got.Title != "Read after write" { t.Fatalf( "read-after-write: expected title %q, got %q", "Read after write", got.Title, ) } if queries := s.ChatSQLQueries(); queries != 2 { t.Fatalf( "read-after-write: expected 2 SQL queries on cache miss, got %d", queries, ) } cacheKey := "chat:" + user.ID + ":" + chat.ID exists, err := testRedis.Exists(context.Background(), cacheKey).Result() if err != nil { t.Fatalf("check cache: %v", err) } if exists != 1 { t.Fatalf("expected chat to be present in cache") } if err := testRedis.Del(context.Background(), cacheKey).Err(); err != nil { t.Fatalf("delete cache: %v", err) } s.ResetChatSQLQueries() resp2 := getJSON( t, srv, "/api/v1/chats/"+chat.ID, user.Token, ) defer resp2.Body.Close() if resp2.StatusCode != http.StatusOK { t.Fatalf( "recovery after cache loss: unexpected status %d", resp2.StatusCode, ) } recovered := decodeBody[model.Chat](t, resp2) if recovered.ID != chat.ID { t.Fatalf( "recovery: expected chat %s, got %s", chat.ID, recovered.ID, ) } if recovered.Title != chat.Title { t.Fatalf( "recovery: expected title %q, got %q", chat.Title, recovered.Title, ) } if queries := s.ChatSQLQueries(); queries != 2 { t.Fatalf( "recovery: expected 2 SQL queries after cache loss, got %d", queries, ) } exists, err = testRedis.Exists(context.Background(), cacheKey).Result() if err != nil { t.Fatalf("check recovered cache: %v", err) } if exists != 1 { t.Fatalf("expected cache to be restored after database read") } }