forked from mtusi2026/mtusi2026lab4
chore(solution): port lab3 sources
This commit is contained in:
@@ -0,0 +1,324 @@
|
||||
package handler_test
|
||||
|
||||
import (
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"fmt"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"strings"
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
"uuid"
|
||||
|
||||
"messenger/internal/handler"
|
||||
"messenger/internal/repository/postgres"
|
||||
"messenger/internal/repository/redis"
|
||||
"messenger/internal/router"
|
||||
"messenger/internal/service"
|
||||
)
|
||||
|
||||
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)
|
||||
h := handler.New(users, auth, chats, messages, []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"])
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user