forked from mtusi2026/mtusi2026lab4
168 lines
5.1 KiB
Go
168 lines
5.1 KiB
Go
package tests
|
|
|
|
import (
|
|
"context"
|
|
"messenger/src/backend/handlers"
|
|
"messenger/src/backend/repositories"
|
|
"messenger/src/backend/services"
|
|
"net/http"
|
|
"os"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
"github.com/jackc/pgx/v5"
|
|
"github.com/jackc/pgx/v5/pgxpool"
|
|
)
|
|
|
|
type testFixture struct {
|
|
db *pgxpool.Pool
|
|
users *repositories.UserStore
|
|
chats *repositories.ChatStore
|
|
messages *repositories.MessageStore
|
|
sessionStore *repositories.SessionStore
|
|
sessions *services.SessionService
|
|
router http.Handler
|
|
}
|
|
|
|
// Each test owns a new schema; public application tables are never modified.
|
|
func newTestFixture(t *testing.T) *testFixture {
|
|
t.Helper()
|
|
url := os.Getenv("TEST_DATABASE_URL")
|
|
redisAddress := os.Getenv("TEST_REDIS_ADDR")
|
|
if url == "" || redisAddress == "" {
|
|
t.Skip("integration tests: run make test-backend, or set TEST_DATABASE_URL and TEST_REDIS_ADDR")
|
|
}
|
|
ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
|
|
defer cancel()
|
|
admin, err := pgxpool.New(ctx, url)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(admin.Close)
|
|
schema := "test_" + strings.ReplaceAll(uuid.NewString(), "-", "")
|
|
identifier := pgx.Identifier{schema}.Sanitize()
|
|
if _, err = admin.Exec(ctx, "CREATE SCHEMA "+identifier); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() {
|
|
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
|
|
defer cancel()
|
|
if _, err := admin.Exec(ctx, "DROP SCHEMA "+identifier+" CASCADE"); err != nil {
|
|
t.Errorf("cleanup test schema: %v", err)
|
|
}
|
|
})
|
|
cfg, err := pgxpool.ParseConfig(url)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cfg.ConnConfig.RuntimeParams["search_path"] = schema
|
|
cfg.ConnConfig.RuntimeParams["application_name"] = schema
|
|
db, err := pgxpool.NewWithConfig(ctx, cfg)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(db.Close)
|
|
ddl, err := os.ReadFile("../repositories/migrations/000001_initial.up.sql")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = db.Exec(ctx, string(ddl)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ddl, err = os.ReadFile("../repositories/migrations/000002_redis_sessions.up.sql")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = db.Exec(ctx, string(ddl)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
redisClient := repositories.NewRedisClient(redisAddress)
|
|
ddl, err = os.ReadFile("../repositories/migrations/000003_message_idempotency.up.sql")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = db.Exec(ctx, string(ddl)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ddl, err = os.ReadFile("../repositories/migrations/000004_attachments.up.sql")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = db.Exec(ctx, string(ddl)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ddl, err = os.ReadFile("../repositories/migrations/000005_upload_attempts.up.sql")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = db.Exec(ctx, string(ddl)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ddl, err = os.ReadFile("../repositories/migrations/000006_direct_uploads.up.sql")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = db.Exec(ctx, string(ddl)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() { _ = redisClient.Close() })
|
|
if err := redisClient.Ping(ctx).Err(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
users := repositories.NewUserStore(db)
|
|
chats := repositories.NewChatStore(db)
|
|
messages := repositories.NewMessageStore(db)
|
|
userService := services.NewUserService(users)
|
|
sessionStore := repositories.NewSessionStore(redisClient, "test:"+schema+":session:")
|
|
sessions := services.NewSessionService(userService, sessionStore, time.Hour)
|
|
router := handlers.NewRouter(services.NewHealthService(repositories.NewHealthStore(db), sessionStore), userService, sessions, services.NewChatService(chats), services.NewMessageService(messages))
|
|
return &testFixture{db: db, users: users, chats: chats, messages: messages, sessionStore: sessionStore, sessions: sessions, router: router}
|
|
}
|
|
|
|
func createTestUser(t *testing.T, store *repositories.UserStore, username, name string) (repositories.User, bool) {
|
|
t.Helper()
|
|
user, err := services.NewUserService(store).Create(context.Background(), username, name, "lab2-test-password")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return user, true
|
|
}
|
|
|
|
func createTestChat(t *testing.T, store *repositories.ChatStore, title string, members []string) repositories.Chat {
|
|
t.Helper()
|
|
chat, err := store.Create(context.Background(), title, members)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return chat
|
|
}
|
|
|
|
func createTestMessage(t *testing.T, store *repositories.MessageStore, chatID, userID, text string) repositories.Message {
|
|
t.Helper()
|
|
message, err := store.Create(context.Background(), chatID, userID, text)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return message
|
|
}
|
|
|
|
func listTestMessages(t *testing.T, store *repositories.MessageStore, chatID string) []repositories.Message {
|
|
t.Helper()
|
|
items, _, err := store.ListPageByChat(context.Background(), chatID, nil, 100)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return items
|
|
}
|
|
|
|
func authorizeTestRequest(t *testing.T, fixture *testFixture, request *http.Request, userID string) {
|
|
t.Helper()
|
|
token, _, err := fixture.sessions.CreateForUser(request.Context(), userID)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
request.Header.Set("Authorization", "Bearer "+token)
|
|
}
|