package handler_test import ( "context" "encoding/base64" "encoding/json" "fmt" "io" "log/slog" "net/http" "net/http/httptest" "os" "strings" "sync" "testing" "time" "uuid" "messenger/internal/domain" "messenger/internal/handler" "messenger/internal/repository/postgres" "messenger/internal/repository/redis" "messenger/internal/router" "messenger/internal/service" ) type stubObjectStore struct { objects map[string][]byte } func newStubObjectStore() *stubObjectStore { return &stubObjectStore{objects: map[string][]byte{}} } func (s *stubObjectStore) Put(_ context.Context, key string, r io.Reader, _ int64, _ string) error { data, err := io.ReadAll(r) if err != nil { return err } s.objects[key] = data return nil } func (s *stubObjectStore) Get(_ context.Context, key string) (io.ReadCloser, error) { data, ok := s.objects[key] if !ok { return nil, domain.ErrNotFound } return io.NopCloser(strings.NewReader(string(data))), nil } func (s *stubObjectStore) Delete(_ context.Context, key string) error { delete(s.objects, key) return nil } func (s *stubObjectStore) Ping(context.Context) error { return nil } func testURLs(t *testing.T) (string, string) { t.Helper() dbURL, redisURL := os.Getenv("TEST_DATABASE_URL"), os.Getenv("TEST_REDIS_URL") if dbURL == "" || redisURL == "" { t.Skip("TEST_DATABASE_URL and TEST_REDIS_URL are required") } return dbURL, redisURL } func newServer(t *testing.T) *httptest.Server { t.Helper() dbURL, redisURL := testURLs(t) return newStack(t, dbURL, redisURL, time.Hour) } func newStack(t *testing.T, dbURL, redisURL string, ttl time.Duration) *httptest.Server { t.Helper() pool, err := postgres.NewPool(context.Background(), dbURL) if err != nil { t.Fatal(err) } t.Cleanup(pool.Close) store := postgres.New(pool) client, err := redis.NewClient(redisURL) if err != nil { t.Fatal(err) } t.Cleanup(func() { client.Close() }) sessions := redis.NewSessionStore(client) users := service.NewUserService(store) auth := service.NewAuthService(store, sessions, ttl) chats := service.NewChatService(store) messages := service.NewMessageService(chats, store) attachments := service.NewAttachmentService(chats, store, newStubObjectStore(), 10485760, 40000000, 8, 2) h := handler.New(users, auth, chats, messages, attachments, []handler.Pinger{store.Ping, sessions.Ping}, slog.New(slog.DiscardHandler)) srv := httptest.NewServer(router.New(h, "test")) t.Cleanup(srv.Close) return srv } type testUser struct { ID string Username string Password string Token string } func request(t *testing.T, srv *httptest.Server, method, path, token, body string) *http.Response { t.Helper() req, err := http.NewRequest(method, srv.URL+path, strings.NewReader(body)) if err != nil { t.Fatal(err) } if body != "" { req.Header.Set("Content-Type", "application/json") } if token != "" { req.Header.Set("Authorization", "Bearer "+token) } if method == http.MethodPost && strings.HasSuffix(path, "/messages") { req.Header.Set("Idempotency-Key", uuid.New().String()) } resp, err := srv.Client().Do(req) if err != nil { t.Fatal(err) } return resp } func do(t *testing.T, srv *httptest.Server, method, path, token, body string) (int, map[string]any) { t.Helper() resp := request(t, srv, method, path, token, body) defer resp.Body.Close() var out map[string]any if err := json.NewDecoder(resp.Body).Decode(&out); err != nil { t.Fatalf("%s %s: invalid JSON response: %v", method, path, err) } return resp.StatusCode, out } func errorCode(body map[string]any) string { e, _ := body["error"].(map[string]any) code, _ := e["code"].(string) return code } func basic(username, password string) string { return "Basic " + base64.StdEncoding.EncodeToString([]byte(username+":"+password)) } func login(t *testing.T, srv *httptest.Server, username, password string) *http.Response { t.Helper() req, err := http.NewRequest(http.MethodPost, srv.URL+"/api/v1/auth/sessions", nil) if err != nil { t.Fatal(err) } req.Header.Set("Authorization", basic(username, password)) resp, err := srv.Client().Do(req) if err != nil { t.Fatal(err) } return resp } func createUser(t *testing.T, srv *httptest.Server, label string) testUser { t.Helper() u := testUser{ Username: label + "_" + strings.ReplaceAll(uuid.New().String(), "-", "")[:12], Password: "Test-password-" + label, } status, body := do(t, srv, http.MethodPost, "/api/v1/users", "", fmt.Sprintf(`{"username":%q,"display_name":"Test","password":%q}`, u.Username, u.Password)) if status != http.StatusCreated { t.Fatalf("create user %s: status %d", u.Username, status) } u.ID = body["id"].(string) resp := login(t, srv, u.Username, u.Password) defer resp.Body.Close() var session map[string]any if err := json.NewDecoder(resp.Body).Decode(&session); err != nil || resp.StatusCode != http.StatusCreated { t.Fatalf("login %s: status %d", u.Username, resp.StatusCode) } u.Token = session["token"].(string) return u } func createChat(t *testing.T, srv *httptest.Server, owner testUser, members ...testUser) string { t.Helper() ids := make([]string, len(members)) for i, m := range members { ids[i] = m.ID } raw, _ := json.Marshal(ids) status, body := do(t, srv, http.MethodPost, "/api/v1/chats", owner.Token, fmt.Sprintf(`{"title":"Test","member_ids":%s}`, raw)) if status != http.StatusCreated { t.Fatalf("create chat: status %d", status) } return body["id"].(string) } func TestInvalidJSON(t *testing.T) { srv := newServer(t) for _, body := range []string{`{"username":`, `not json`, `{"username":5,"display_name":"x","password":"long-enough-pass"}`} { status, resp := do(t, srv, http.MethodPost, "/api/v1/users", "", body) if status != http.StatusBadRequest || errorCode(resp) != "invalid_request" { t.Errorf("body %q: got %d %q, want 400 invalid_request", body, status, errorCode(resp)) } } } func TestForeignChat(t *testing.T) { srv := newServer(t) alice := createUser(t, srv, "alice") bob := createUser(t, srv, "bob") eve := createUser(t, srv, "eve") chat := createChat(t, srv, alice, alice, bob) cases := []struct{ method, path, body string }{ {http.MethodGet, "/api/v1/chats/" + chat, ""}, {http.MethodGet, "/api/v1/chats/" + chat + "/messages", ""}, {http.MethodPost, "/api/v1/chats/" + chat + "/messages", `{"text":"hi"}`}, } for _, c := range cases { status, resp := do(t, srv, c.method, c.path, eve.Token, c.body) if status != http.StatusNotFound || errorCode(resp) != "not_found" { t.Errorf("%s %s by outsider: got %d, want 404", c.method, c.path, status) } } status, resp := do(t, srv, http.MethodGet, "/api/v1/chats", eve.Token, "") if status != http.StatusOK || len(resp["items"].([]any)) != 0 { t.Errorf("outsider chat list: got %d %v, want 200 with no items", status, resp["items"]) } } func TestEmptyMessage(t *testing.T) { srv := newServer(t) alice := createUser(t, srv, "alice") chat := createChat(t, srv, alice, alice) for _, text := range []string{"", " ", "\n\t"} { body, _ := json.Marshal(map[string]string{"text": text}) status, resp := do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", alice.Token, string(body)) if status != http.StatusBadRequest || errorCode(resp) != "invalid_request" { t.Errorf("text %q: got %d, want 400", text, status) } } } func TestDuplicateUsername(t *testing.T) { srv := newServer(t) alice := createUser(t, srv, "alice") status, resp := do(t, srv, http.MethodPost, "/api/v1/users", "", fmt.Sprintf(`{"username":%q,"display_name":"Other","password":"another-password"}`, alice.Username)) if status != http.StatusConflict || errorCode(resp) != "conflict" { t.Errorf("got %d %q, want 409 conflict", status, errorCode(resp)) } } func TestPaginationMultiplePages(t *testing.T) { srv := newServer(t) alice := createUser(t, srv, "alice") chat := createChat(t, srv, alice, alice) const total, limit = 7, 3 for i := range total { status, _ := do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", alice.Token, fmt.Sprintf(`{"text":"msg %d"}`, i)) if status != http.StatusCreated { t.Fatalf("send message %d: status %d", i, status) } } seen := map[string]bool{} pages := 0 prevCreatedAt := "" cursor := "" for { path := fmt.Sprintf("/api/v1/chats/%s/messages?limit=%d", chat, limit) if cursor != "" { path += "&cursor=" + cursor } status, resp := do(t, srv, http.MethodGet, path, alice.Token, "") if status != http.StatusOK { t.Fatalf("page %d: status %d", pages+1, status) } pages++ for _, it := range resp["items"].([]any) { m := it.(map[string]any) id, createdAt := m["id"].(string), m["created_at"].(string) if seen[id] { t.Errorf("message %s returned twice", id) } if createdAt < prevCreatedAt { t.Errorf("messages out of order: %s after %s", createdAt, prevCreatedAt) } seen[id] = true prevCreatedAt = createdAt } next, ok := resp["next_cursor"].(string) if !ok { break } cursor = next } if len(seen) != total { t.Errorf("got %d messages, want %d", len(seen), total) } if want := (total + limit - 1) / limit; pages != want { t.Errorf("got %d pages, want %d", pages, want) } } func TestConcurrentMessages(t *testing.T) { srv := newServer(t) const clients, perClient = 10, 10 users := make([]testUser, clients) for i := range users { users[i] = createUser(t, srv, fmt.Sprintf("client_%d", i)) } chat := createChat(t, srv, users[0], users...) var wg sync.WaitGroup errs := make(chan error, clients*perClient) for c, user := range users { wg.Go(func() { for i := range perClient { status, _ := do(t, srv, http.MethodPost, "/api/v1/chats/"+chat+"/messages", user.Token, fmt.Sprintf(`{"text":"client %d msg %d"}`, c, i)) if status != http.StatusCreated { errs <- fmt.Errorf("client %d msg %d: status %d", c, i, status) } } }) } wg.Wait() close(errs) for err := range errs { t.Error(err) } status, resp := do(t, srv, http.MethodGet, "/api/v1/chats/"+chat+"/messages?limit=100", users[0].Token, "") if status != http.StatusOK { t.Fatalf("read history: status %d", status) } items := resp["items"].([]any) ids := map[string]bool{} for _, it := range items { ids[it.(map[string]any)["id"].(string)] = true } if len(items) != clients*perClient || len(ids) != clients*perClient { t.Errorf("got %d messages (%d unique), want %d", len(items), len(ids), clients*perClient) } if resp["next_cursor"] != nil { t.Errorf("next_cursor = %v, want null", resp["next_cursor"]) } }