Перенесена ЛР1

This commit is contained in:
2026-10-06 21:26:18 +03:00
parent 65003b6119
commit 4455850c6a
18 changed files with 1884 additions and 0 deletions
+34
View File
@@ -0,0 +1,34 @@
FROM golang:1.27.1-alpine AS builder
WORKDIR /build
COPY go.mod go.sum ./
RUN go mod download
COPY cmd/ ./cmd/
COPY internal/ ./internal/
RUN CGO_ENABLED=0 GOOS=linux go build -trimpath -ldflags="-w -s" -o /build/server ./cmd/server/main.go
FROM alpine:3.24
RUN addgroup -g 1000 appgroup && \
adduser -u 1000 -G appgroup -s /bin/sh -D appuser
WORKDIR /app
COPY --from=builder /build/server /app/server
RUN chown -R appuser:appgroup /app
USER appuser:appgroup
EXPOSE 8080
# Проверка здоровья контейнера через /health/live и wget
HEALTHCHECK --interval=5s --timeout=3s --start-period=2s --retries=3 \
CMD wget -qO- http://127.0.0.1:8080/health/live || exit 1
ENTRYPOINT ["/app/server"]
+95
View File
@@ -0,0 +1,95 @@
package main
import (
"context"
"errors"
"log"
"net/http"
"os"
"os/signal"
"syscall"
"time"
"mtusi2026lab2/internal/store"
"mtusi2026lab2/internal/transport/http/handlers"
"mtusi2026lab2/internal/transport/http/middleware"
)
func main() {
addr := os.Getenv("HTTP_ADDR")
if addr == "" {
port := os.Getenv("PORT")
if port == "" {
port = "8080"
}
addr = "0.0.0.0:" + port
}
memStore := store.NewMemoryStore()
h := handlers.NewHandler(memStore)
mux := http.NewServeMux()
//паблик систем ручки
mux.HandleFunc("GET /health/live", h.HealthLive)
mux.HandleFunc("GET /health/ready", h.HealthReady)
// паблик рег юзера
mux.HandleFunc("POST /api/v1/users", h.CreateUser)
//защищенные через мидлварьки
mux.HandleFunc("GET /api/v1/users/me", middleware.RequireAuth(memStore, h.GetMe))
mux.HandleFunc("POST /api/v1/chats", middleware.RequireAuth(memStore, h.CreateChat))
mux.HandleFunc("GET /api/v1/chats", middleware.RequireAuth(memStore, h.ListChats))
mux.HandleFunc("GET /api/v1/chats/{chat_id}", middleware.RequireAuth(memStore, h.GetChat))
mux.HandleFunc("POST /api/v1/chats/{chat_id}/messages", middleware.RequireAuth(memStore, h.CreateMessage))
mux.HandleFunc("GET /api/v1/chats/{chat_id}/messages", middleware.RequireAuth(memStore, h.GetMessages))
//конвейер
var rootHandler http.Handler = mux
rootHandler = middleware.Recovery(rootHandler)
rootHandler = middleware.Logger(rootHandler)
rootHandler = middleware.RequestID(rootHandler)
//конф сервака
server := &http.Server{
Addr: addr,
Handler: rootHandler,
ReadTimeout: 15 * time.Second,
WriteTimeout: 15 * time.Second,
IdleTimeout: 60 * time.Second,
}
//серв в рутине запущен
serverErrors := make(chan error, 1)
go func() {
log.Printf("[INFO] Server starting on %s", addr)
serverErrors <- server.ListenAndServe()
}()
shutdown := make(chan os.Signal, 1)
signal.Notify(shutdown, os.Interrupt, syscall.SIGTERM)
//падение/сигнал на выкл
select {
case err := <-serverErrors:
if !errors.Is(err, http.ErrServerClosed) {
log.Fatalf("[FATAL] Server crashed: %v", err)
}
case sig := <-shutdown:
log.Printf("[INFO] Signal %v received. Starting graceful shutdown...", sig)
// завершение не более чем за 10 секунд
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
if err := server.Shutdown(ctx); err != nil {
log.Printf("[WARN] Graceful shutdown failed: %v. Forcing close.", err)
_ = server.Close()
}
log.Println("[INFO] Server stopped gracefully.")
}
}
+5
View File
@@ -0,0 +1,5 @@
module mtusi2026lab2
go 1.27.1
require github.com/google/uuid v1.6.0
+2
View File
@@ -0,0 +1,2 @@
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+155
View File
@@ -0,0 +1,155 @@
package domain
import (
"encoding/base64"
"fmt"
"regexp"
"strings"
"time"
"unicode/utf8"
"github.com/google/uuid"
)
var (
//регулярка по контракту
usernameRegex = regexp.MustCompile(`^[a-z0-9_]{3,32}$`)
)
type User struct {
ID string `json:"id"`
Username string `json:"username"`
DisplayName string `json:"display_name"`
CreatedAt time.Time `json:"created_at"`
}
type Chat struct {
ID string `json:"id"`
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
CreatedAt time.Time `json:"created_at"`
}
type Message struct {
ID string `json:"id"`
ChatID string `json:"chat_id"`
SenderID string `json:"sender_id"`
Text string `json:"text"`
CreatedAt time.Time `json:"created_at"`
}
// страница выдачи истории сообщений
type MessagePage struct {
Items []Message `json:"items"`
NextCursor *string `json:"next_cursor"`
}
func (u *User) Validate() error {
if !usernameRegex.MatchString(u.Username) {
return fmt.Errorf("username must match [a-z0-9_]{3,32}")
}
nameRunes := utf8.RuneCountInString(u.DisplayName)
if nameRunes < 1 || nameRunes > 100 {
return fmt.Errorf("display_name length must be between 1 and 100 code points")
}
if strings.TrimSpace(u.DisplayName) == "" {
return fmt.Errorf("display_name cannot be only whitespace")
}
return nil
}
func ValidateChatInput(title string, memberIDs []string, callerID string) error {
titleRunes := utf8.RuneCountInString(title)
if titleRunes < 1 || titleRunes > 100 || strings.TrimSpace(title) == "" {
return fmt.Errorf("invalid chat title")
}
if len(memberIDs) == 0 {
return fmt.Errorf("member_ids cannot be empty")
}
hasCaller := false
seen := make(map[string]bool)
for _, id := range memberIDs {
if _, err := uuid.Parse(id); err != nil {
return fmt.Errorf("invalid member uuid: %s", id)
}
if seen[id] {
return fmt.Errorf("duplicate member_id: %s", id)
}
seen[id] = true
if id == callerID {
hasCaller = true
}
}
if !hasCaller {
return fmt.Errorf("caller must be in member_ids")
}
return nil
}
func ValidateMessageText(text string) error {
textRunes := utf8.RuneCountInString(text)
if textRunes < 1 || textRunes > 4000 {
return fmt.Errorf("message text length must be between 1 and 4000 code points")
}
if strings.TrimSpace(text) == "" {
return fmt.Errorf("message text cannot be only whitespace")
}
return nil
}
type CursorData struct {
CreatedAt time.Time
MessageID string
ChatID string
}
// EncodeCursor превращает время, message_id и chat_id в непрозрачную base64 строку
func EncodeCursor(createdAt time.Time, messageID, chatID string) string {
raw := fmt.Sprintf("%s|%s|%s", createdAt.Format(time.RFC3339Nano), messageID, chatID)
return base64.StdEncoding.EncodeToString([]byte(raw))
}
// DecodeCursor декодирует строку курсора и проверяет, что он принадлежит именно этому чату
func DecodeCursor(cursorStr string, expectedChatID string) (*CursorData, error) {
bytes, err := base64.StdEncoding.DecodeString(cursorStr)
if err != nil {
return nil, fmt.Errorf("invalid base64 cursor")
}
parts := strings.Split(string(bytes), "|")
if len(parts) != 3 {
return nil, fmt.Errorf("malformed cursor")
}
t, err := time.Parse(time.RFC3339Nano, parts[0])
if err != nil {
return nil, fmt.Errorf("invalid cursor timestamp")
}
chatID := parts[2]
//защита из контракта: курсор от другого чата должен давать 400
if chatID != expectedChatID {
return nil, fmt.Errorf("cursor belongs to another chat")
}
return &CursorData{
CreatedAt: t,
MessageID: parts[1],
ChatID: chatID,
}, nil
}
// страница со списком чатов пользователя
type ChatPage struct {
Items []Chat `json:"items"`
NextCursor *string `json:"next_cursor"`
}
+287
View File
@@ -0,0 +1,287 @@
package store
import (
"fmt"
"sort"
"sync"
"time"
"mtusi2026lab2/internal/domain"
"github.com/google/uuid"
)
var (
ErrNotFound = fmt.Errorf("not found")
ErrConflict = fmt.Errorf("conflict")
)
type MemoryStore struct {
mu sync.RWMutex
usersByID map[string]domain.User //key = user UUID
usersByUsername map[string]string //key = username для быстрой проверки уникальности
chatsByID map[string]domain.Chat //key = chat UUID
messagesByChatID map[string][]domain.Message // key = chat UUID, value = слайс сообщений
}
func NewMemoryStore() *MemoryStore {
return &MemoryStore{
usersByID: make(map[string]domain.User),
usersByUsername: make(map[string]string),
chatsByID: make(map[string]domain.Chat),
messagesByChatID: make(map[string][]domain.Message),
}
}
// ---пользователи---
func (s *MemoryStore) CreateUser(username, displayName string) (domain.User, error) {
s.mu.Lock()
defer s.mu.Unlock()
// дубликат username -> 409 Conflict
if _, exists := s.usersByUsername[username]; exists {
return domain.User{}, ErrConflict
}
user := domain.User{
ID: uuid.NewString(),
Username: username,
DisplayName: displayName,
CreatedAt: time.Now().UTC(),
}
s.usersByID[user.ID] = user
s.usersByUsername[user.Username] = user.ID
return user, nil
}
func (s *MemoryStore) GetUserByID(id string) (domain.User, error) {
s.mu.RLock()
defer s.mu.RUnlock()
user, exists := s.usersByID[id]
if !exists {
return domain.User{}, ErrNotFound
}
return user, nil
}
// ---чаты---
func (s *MemoryStore) CreateChat(title string, memberIDs []string) (domain.Chat, error) {
s.mu.Lock()
defer s.mu.Unlock()
//все участники рил существуют
for _, memberID := range memberIDs {
if _, exists := s.usersByID[memberID]; !exists {
return domain.Chat{}, fmt.Errorf("member not found: %s", memberID)
}
}
chat := domain.Chat{
ID: uuid.NewString(),
Title: title,
MemberIDs: append([]string(nil), memberIDs...), //копирую слайс для изоляции
CreatedAt: time.Now().UTC(),
}
s.chatsByID[chat.ID] = chat
s.messagesByChatID[chat.ID] = make([]domain.Message, 0)
return chat, nil
}
func (s *MemoryStore) GetChatByID(chatID, callerID string) (domain.Chat, error) {
s.mu.RLock()
defer s.mu.RUnlock()
chat, exists := s.chatsByID[chatID]
if !exists {
return domain.Chat{}, ErrNotFound
}
// Требование безопасности: посторонний получает 404, а не 403
isMember := false
for _, m := range chat.MemberIDs {
if m == callerID {
isMember = true
break
}
}
if !isMember {
return domain.Chat{}, ErrNotFound
}
return chat, nil
}
func (s *MemoryStore) GetChatsForUser(userID string, limit int) ([]domain.Chat, error) {
s.mu.RLock()
defer s.mu.RUnlock()
var result []domain.Chat
for _, chat := range s.chatsByID {
for _, m := range chat.MemberIDs {
if m == userID {
result = append(result, chat)
break
}
}
}
//по контракту: сортировка по created_at, id по возрастанию
sort.Slice(result, func(i, j int) bool {
if result[i].CreatedAt.Equal(result[j].CreatedAt) {
return result[i].ID < result[j].ID
}
return result[i].CreatedAt.Before(result[j].CreatedAt)
})
if limit > 0 && len(result) > limit {
result = result[:limit]
}
return result, nil
}
// ---Сообщения---
func (s *MemoryStore) CreateMessage(
chatID, senderID, text string,
) (domain.Message, error) {
messageID := uuid.NewString()
s.mu.Lock()
defer s.mu.Unlock()
chat, exists := s.chatsByID[chatID]
if !exists {
return domain.Message{}, ErrNotFound
}
isMember := false
for _, memberID := range chat.MemberIDs {
if memberID == senderID {
isMember = true
break
}
}
if !isMember {
return domain.Message{}, ErrNotFound
}
createdAt := time.Now().UTC()
messages := s.messagesByChatID[chatID]
if len(messages) > 0 {
lastCreatedAt := messages[len(messages)-1].CreatedAt
// Обеспечиваем строго возрастающее время внутри каждого чата.
if !createdAt.After(lastCreatedAt) {
createdAt = lastCreatedAt.Add(time.Nanosecond)
}
}
message := domain.Message{
ID: messageID,
ChatID: chatID,
SenderID: senderID,
Text: text,
CreatedAt: createdAt,
}
s.messagesByChatID[chatID] = append(messages, message)
return message, nil
}
func (s *MemoryStore) GetMessages(
chatID, callerID string,
limit int,
cursorStr string,
) (domain.MessagePage, error) {
s.mu.RLock()
defer s.mu.RUnlock()
chat, exists := s.chatsByID[chatID]
if !exists {
return domain.MessagePage{}, ErrNotFound
}
isMember := false
for _, memberID := range chat.MemberIDs {
if memberID == callerID {
isMember = true
break
}
}
if !isMember {
return domain.MessagePage{}, ErrNotFound
}
var cursorData *domain.CursorData
if cursorStr != "" {
decodedCursor, err := domain.DecodeCursor(cursorStr, chatID)
if err != nil {
return domain.MessagePage{},
fmt.Errorf("invalid cursor: %w", err)
}
cursorData = decodedCursor
}
messages := s.messagesByChatID[chatID]
start := 0
if cursorData != nil {
// Срез уже упорядочен во время записи, поэтому вместо
// полного прохода используем бинарный поиск.
start = sort.Search(len(messages), func(index int) bool {
message := messages[index]
if message.CreatedAt.After(cursorData.CreatedAt) {
return true
}
return message.CreatedAt.Equal(cursorData.CreatedAt) &&
message.ID > cursorData.MessageID
})
}
page := domain.MessagePage{
Items: make([]domain.Message, 0),
NextCursor: nil,
}
if start >= len(messages) {
return page, nil
}
end := len(messages)
if limit > 0 && end-start > limit {
end = start + limit
}
// копируем только возвращаемую страницу, а не всю историю, изменяя внутренний срез
page.Items = make([]domain.Message, end-start)
copy(page.Items, messages[start:end])
if end < len(messages) {
lastItem := page.Items[len(page.Items)-1]
nextCursor := domain.EncodeCursor(
lastItem.CreatedAt,
lastItem.ID,
chatID,
)
page.NextCursor = &nextCursor
}
return page, nil
}
+105
View File
@@ -0,0 +1,105 @@
package handlers
import (
"errors"
"net/http"
"strconv"
"mtusi2026lab2/internal/domain"
"mtusi2026lab2/internal/store"
"mtusi2026lab2/internal/transport/http/middleware"
"mtusi2026lab2/internal/transport/http/response"
"github.com/google/uuid"
)
type CreateChatRequest struct {
Title string `json:"title"`
MemberIDs []string `json:"member_ids"`
}
func (h *Handler) CreateChat(w http.ResponseWriter, r *http.Request) {
reqID := middleware.GetRequestID(r.Context())
currentUser := middleware.GetCurrentUser(r.Context())
var req CreateChatRequest
if err := decodeJSON(r, &req); err != nil {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, "invalid json: "+err.Error(), reqID)
return
}
//вызывающий есть в списке, нет дубликатов, валидные UUID
if err := domain.ValidateChatInput(req.Title, req.MemberIDs, currentUser.ID); err != nil {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, err.Error(), reqID)
return
}
chat, err := h.store.CreateChat(req.Title, req.MemberIDs)
if err != nil {
//участник не существует -> 400
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, err.Error(), reqID)
return
}
response.WriteJSON(w, http.StatusCreated, chat, reqID)
}
// инфа о чате
func (h *Handler) GetChat(w http.ResponseWriter, r *http.Request) {
reqID := middleware.GetRequestID(r.Context())
currentUser := middleware.GetCurrentUser(r.Context())
chatID := r.PathValue("chat_id")
if _, err := uuid.Parse(chatID); err != nil {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, "invalid chat_id uuid", reqID)
return
}
chat, err := h.store.GetChatByID(chatID, currentUser.ID)
if err != nil {
if errors.Is(err, store.ErrNotFound) {
//посторонний или несуществующий чат -> 404
response.WriteError(w, http.StatusNotFound, response.CodeNotFound, "chat not found", reqID)
return
}
response.WriteError(w, http.StatusInternalServerError, response.CodeInternalError, "internal error", reqID)
return
}
response.WriteJSON(w, http.StatusOK, chat, reqID)
}
// список всех чатов текущего пользователя
func (h *Handler) ListChats(w http.ResponseWriter, r *http.Request) {
reqID := middleware.GetRequestID(r.Context())
currentUser := middleware.GetCurrentUser(r.Context())
limit := 50
limitStr := r.URL.Query().Get("limit")
if limitStr != "" {
val, err := strconv.Atoi(limitStr)
if err != nil || val < 1 || val > 100 {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, "limit must be an integer between 1 and 100", reqID)
return
}
limit = val
}
chats, err := h.store.GetChatsForUser(currentUser.ID, limit)
if err != nil {
response.WriteError(w, http.StatusInternalServerError, response.CodeInternalError, "internal error", reqID)
return
}
//если чатов нет, сериализую в пустой массив [], а не null
if chats == nil {
chats = make([]domain.Chat, 0)
}
page := domain.ChatPage{
Items: chats,
NextCursor: nil,
}
response.WriteJSON(w, http.StatusOK, page, reqID)
}
@@ -0,0 +1,44 @@
package handlers
import (
"encoding/json"
"errors"
"io"
"net/http"
"mtusi2026lab2/internal/store"
)
type Handler struct {
store *store.MemoryStore
}
func NewHandler(st *store.MemoryStore) *Handler {
return &Handler{store: st}
}
// декодирует тело запроса:
// Запрещает неизвестные/лишние поля (DisallowUnknownFields) -> 400
// Ловит синтаксические ошибки JSON -> 400
// Проверяет, что после валидного JSON нет мусора
func decodeJSON(r *http.Request, dst any) error {
if r.Body == nil {
return errors.New("request body is empty")
}
defer r.Body.Close()
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
if err := dec.Decode(dst); err != nil {
return err
}
// два JSON подряд или мусор в конце — ошибка
var extra json.RawMessage
if err := dec.Decode(&extra); !errors.Is(err, io.EOF) {
return errors.New("extra data after JSON")
}
return nil
}
@@ -0,0 +1,20 @@
package handlers
import (
"net/http"
"mtusi2026lab2/internal/transport/http/middleware"
"mtusi2026lab2/internal/transport/http/response"
)
// HealthLive проверяет, что процесс сервера запущен
func (h *Handler) HealthLive(w http.ResponseWriter, r *http.Request) {
reqID := middleware.GetRequestID(r.Context())
response.WriteJSON(w, http.StatusOK, map[string]string{"status": "ok"}, reqID)
}
// HealthReady проверяет, что сервер готов принимать входящие запросы
func (h *Handler) HealthReady(w http.ResponseWriter, r *http.Request) {
reqID := middleware.GetRequestID(r.Context())
response.WriteJSON(w, http.StatusOK, map[string]string{"status": "ok"}, reqID)
}
@@ -0,0 +1,100 @@
package handlers
import (
"errors"
"net/http"
"strconv"
"mtusi2026lab2/internal/domain"
"mtusi2026lab2/internal/store"
"mtusi2026lab2/internal/transport/http/middleware"
"mtusi2026lab2/internal/transport/http/response"
"github.com/google/uuid"
)
type CreateMessageRequest struct {
Text string `json:"text"`
}
// CreateMessage отправляет сообщение в чат
func (h *Handler) CreateMessage(w http.ResponseWriter, r *http.Request) {
reqID := middleware.GetRequestID(r.Context())
currentUser := middleware.GetCurrentUser(r.Context())
chatID := r.PathValue("chat_id")
if _, err := uuid.Parse(chatID); err != nil {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, "invalid chat_id uuid", reqID)
return
}
var req CreateMessageRequest
if err := decodeJSON(r, &req); err != nil {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, "invalid json: "+err.Error(), reqID)
return
}
//не пустой, не только пробелы, до 4000 рун
if err := domain.ValidateMessageText(req.Text); err != nil {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, err.Error(), reqID)
return
}
//автор сообщения строго выводится из сессии (currentUser.ID)
msg, err := h.store.CreateMessage(chatID, currentUser.ID, req.Text)
if err != nil {
if errors.Is(err, store.ErrNotFound) {
// чата нет/пользователь не участник -> 404
response.WriteError(w, http.StatusNotFound, response.CodeNotFound, "chat not found", reqID)
return
}
response.WriteError(w, http.StatusInternalServerError, response.CodeInternalError, "internal error", reqID)
return
}
response.WriteJSON(w, http.StatusCreated, msg, reqID)
}
// GetMessages возвращает историю сообщений чата с пагинацией по курсору
func (h *Handler) GetMessages(w http.ResponseWriter, r *http.Request) {
reqID := middleware.GetRequestID(r.Context())
currentUser := middleware.GetCurrentUser(r.Context())
chatID := r.PathValue("chat_id")
if _, err := uuid.Parse(chatID); err != nil {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, "invalid chat_id uuid", reqID)
return
}
limit := 50
limitStr := r.URL.Query().Get("limit")
if limitStr != "" {
val, err := strconv.Atoi(limitStr)
// Если передан limit=0 или >100 -> 400 invalid_request
if err != nil || val < 1 || val > 100 {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, "limit must be an integer between 1 and 100", reqID)
return
}
limit = val
}
cursor := r.URL.Query().Get("cursor")
page, err := h.store.GetMessages(chatID, currentUser.ID, limit, cursor)
if err != nil {
if errors.Is(err, store.ErrNotFound) {
response.WriteError(w, http.StatusNotFound, response.CodeNotFound, "chat not found", reqID)
return
}
//если курсор кривой или от другого чата -> 400 invalid_request
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, err.Error(), reqID)
return
}
// сообщений нет, [] вместо null
if page.Items == nil {
page.Items = make([]domain.Message, 0)
}
response.WriteJSON(w, http.StatusOK, page, reqID)
}
+59
View File
@@ -0,0 +1,59 @@
package handlers
import (
"errors"
"net/http"
"mtusi2026lab2/internal/domain"
"mtusi2026lab2/internal/store"
"mtusi2026lab2/internal/transport/http/middleware"
"mtusi2026lab2/internal/transport/http/response"
)
type CreateUserRequest struct {
Username string `json:"username"`
DisplayName string `json:"display_name"`
}
// CreateUser создает нового пользователя
func (h *Handler) CreateUser(w http.ResponseWriter, r *http.Request) {
reqID := middleware.GetRequestID(r.Context())
var req CreateUserRequest
if err := decodeJSON(r, &req); err != nil {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, "malformed or invalid JSON: "+err.Error(), reqID)
return
}
userCandidate := domain.User{
Username: req.Username,
DisplayName: req.DisplayName,
}
//правила Unicode, длину и пробелы из domain
if err := userCandidate.Validate(); err != nil {
response.WriteError(w, http.StatusBadRequest, response.CodeInvalidRequest, err.Error(), reqID)
return
}
createdUser, err := h.store.CreateUser(userCandidate.Username, userCandidate.DisplayName)
if err != nil {
// юзернейм занят — 409
if errors.Is(err, store.ErrConflict) {
response.WriteError(w, http.StatusConflict, response.CodeConflict, "username already exists", reqID)
return
}
response.WriteError(w, http.StatusInternalServerError, response.CodeInternalError, "failed to create user", reqID)
return
}
response.WriteJSON(w, http.StatusCreated, createdUser, reqID)
}
// GetMe возвращает профиль текущего пользователя
func (h *Handler) GetMe(w http.ResponseWriter, r *http.Request) {
reqID := middleware.GetRequestID(r.Context())
currentUser := middleware.GetCurrentUser(r.Context())
response.WriteJSON(w, http.StatusOK, currentUser, reqID)
}
@@ -0,0 +1,43 @@
package middleware
import (
"context"
"net/http"
"mtusi2026lab2/internal/domain"
"mtusi2026lab2/internal/store"
"mtusi2026lab2/internal/transport/http/response"
)
const UserContextKey contextKey = "current_user"
// RequireAuth проверяет наличие и валидность X-User-Id
func RequireAuth(st *store.MemoryStore, next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
reqID := GetRequestID(r.Context())
userID := r.Header.Get("X-User-Id")
if userID == "" {
response.WriteError(w, http.StatusUnauthorized, response.CodeUnauthorized, "missing X-User-Id header", reqID)
return
}
//существует ли чел
user, err := st.GetUserByID(userID)
if err != nil {
response.WriteError(w, http.StatusUnauthorized, response.CodeUnauthorized, "user not found", reqID)
return
}
ctx := context.WithValue(r.Context(), UserContextKey, user)
next(w, r.WithContext(ctx))
}
}
// чисто чтоб зареганного получить из контекста
func GetCurrentUser(ctx context.Context) domain.User {
if val, ok := ctx.Value(UserContextKey).(domain.User); ok {
return val
}
return domain.User{}
}
@@ -0,0 +1,44 @@
package middleware
import (
"log"
"net/http"
"time"
)
// responseWriterInterceptor перехватывает статус-код ответа для логов
type responseWriterInterceptor struct {
http.ResponseWriter
statusCode int
}
func (w *responseWriterInterceptor) WriteHeader(code int) {
w.statusCode = code
w.ResponseWriter.WriteHeader(code)
}
func Logger(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
start := time.Now()
interceptor := &responseWriterInterceptor{
ResponseWriter: w,
statusCode: http.StatusOK, // дефолтный статус если WriteHeader не вызывался
}
next.ServeHTTP(interceptor, r)
reqID := GetRequestID(r.Context())
duration := time.Since(start)
// метаданные без r.Body
log.Printf(
"[HTTP] %s %s | status: %d | duration: %v | request_id: %s",
r.Method,
r.URL.Path,
interceptor.statusCode,
duration,
reqID,
)
})
}
@@ -0,0 +1,28 @@
package middleware
import (
"net/http"
"mtusi2026lab2/internal/transport/http/response"
)
// Recovery перехватывает панику и возвращает клиенту валидный JSON 500
func Recovery(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
defer func() {
if err := recover(); err != nil {
reqID := GetRequestID(r.Context())
//из контракта: не раскрывать stack trace и внутренности
response.WriteError(
w,
http.StatusInternalServerError,
response.CodeInternalError,
"internal server error",
reqID,
)
}
}()
next.ServeHTTP(w, r)
})
}
@@ -0,0 +1,35 @@
package middleware
import (
"context"
"net/http"
"github.com/google/uuid"
)
type contextKey string
const RequestIDKey contextKey = "request_id"
// RequestID извлекает или генерирует X-Request-Id и кладет его в контекст и заголовок ответа
func RequestID(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
reqID := r.Header.Get("X-Request-Id")
if reqID == "" {
reqID = uuid.NewString()
}
w.Header().Set("X-Request-Id", reqID)
ctx := context.WithValue(r.Context(), RequestIDKey, reqID)
next.ServeHTTP(w, r.WithContext(ctx))
})
}
// GetRequestID достает ID запроса из контекста
func GetRequestID(ctx context.Context) string {
if val, ok := ctx.Value(RequestIDKey).(string); ok {
return val
}
return uuid.NewString()
}
@@ -0,0 +1,60 @@
package response
import (
"encoding/json"
"net/http"
)
// коды ошибок по контракту
const (
CodeInvalidRequest = "invalid_request"
CodeUnauthorized = "unauthorized"
CodeNotFound = "not_found"
CodeConflict = "conflict"
CodeInternalError = "internal_error"
)
type ErrorPayload struct {
Code string `json:"code"`
Message string `json:"message"`
RequestID string `json:"request_id"`
}
// ErrorResponse — строгое тело ответа при любой ошибке
type ErrorResponse struct {
Error ErrorPayload `json:"error"`
}
// WriteJSON отправляет любой успешный ответ с правильными заголовками
func WriteJSON(w http.ResponseWriter, statusCode int, data any, requestID string) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
if requestID != "" {
w.Header().Set("X-Request-Id", requestID)
}
w.WriteHeader(statusCode)
if data != nil {
_ = json.NewEncoder(w).Encode(data)
}
}
// WriteError формирует стандартизированную ошибку с совпадением request_id в теле и заголовке
func WriteError(w http.ResponseWriter, statusCode int, code string, message string, requestID string) {
w.Header().Set("Content-Type", "application/json; charset=utf-8")
if requestID != "" {
w.Header().Set("X-Request-Id", requestID)
}
w.WriteHeader(statusCode)
resp := ErrorResponse{
Error: ErrorPayload{
Code: code,
Message: message,
RequestID: requestID,
},
}
_ = json.NewEncoder(w).Encode(resp)
}
+401
View File
@@ -0,0 +1,401 @@
package student_tests
import (
"encoding/json"
"fmt"
"io"
"net/http"
"net/url"
"runtime"
"sync"
"testing"
"time"
"mtusi2026lab2/internal/domain"
)
func fetchCursorPage(
t *testing.T,
baseURL, chatID, userID string,
limit int,
cursor string,
) domain.MessagePage {
t.Helper()
endpoint := fmt.Sprintf(
"%s/api/v1/chats/%s/messages?limit=%d",
baseURL,
chatID,
limit,
)
if cursor != "" {
endpoint += "&cursor=" + url.QueryEscape(cursor)
}
req, err := http.NewRequest(http.MethodGet, endpoint, nil)
if err != nil {
t.Fatal(err)
}
req.Header.Set("X-User-Id", userID)
res, err := http.DefaultClient.Do(req)
if err != nil {
t.Fatal(err)
}
defer res.Body.Close()
if res.StatusCode != http.StatusOK {
body, _ := io.ReadAll(res.Body)
t.Fatalf("expected 200, got %d: %s", res.StatusCode, body)
}
var page domain.MessagePage
if err := json.NewDecoder(res.Body).Decode(&page); err != nil {
t.Fatalf("decode message page: %v", err)
}
return page
}
func TestCursorTraversalAfterConcurrentWrites(t *testing.T) {
ts, st := setupTestServer()
defer ts.Close()
const (
clients = 10
messagesPerClient = 100
expectedMessages = clients * messagesPerClient
)
memberIDs := make([]string, 0, clients)
for client := 0; client < clients; client++ {
user, err := st.CreateUser(
fmt.Sprintf("cursor_client_%d", client),
fmt.Sprintf("Cursor client %d", client),
)
if err != nil {
t.Fatal(err)
}
memberIDs = append(memberIDs, user.ID)
}
chat, err := st.CreateChat("Concurrent cursor test", memberIDs)
if err != nil {
t.Fatal(err)
}
start := make(chan struct{})
var writers sync.WaitGroup
for client := 0; client < clients; client++ {
writers.Add(1)
go func(client int) {
defer writers.Done()
<-start
for message := 0; message < messagesPerClient; message++ {
_, err := st.CreateMessage(
chat.ID,
memberIDs[client],
fmt.Sprintf("client=%d message=%d", client, message),
)
if err != nil {
t.Errorf("create message: %v", err)
return
}
}
}(client)
}
close(start)
writers.Wait()
seen := make(map[string]struct{}, expectedMessages)
duplicateCount := 0
var previous *domain.Message
firstOrderingViolation := ""
cursor := ""
pageCount := 0
for {
pageCount++
if pageCount > expectedMessages {
t.Fatal("pagination did not terminate")
}
page := fetchCursorPage(t, ts.URL, chat.ID, memberIDs[0], 17, cursor)
for index := range page.Items {
message := page.Items[index]
if _, duplicate := seen[message.ID]; duplicate {
duplicateCount++
}
seen[message.ID] = struct{}{}
if previous != nil {
outOfOrder := message.CreatedAt.Before(previous.CreatedAt) ||
(message.CreatedAt.Equal(previous.CreatedAt) && message.ID <= previous.ID)
if outOfOrder && firstOrderingViolation == "" {
firstOrderingViolation = fmt.Sprintf(
"previous=(%s,%s), current=(%s,%s)",
previous.CreatedAt.Format("15:04:05.999999999"), previous.ID,
message.CreatedAt.Format("15:04:05.999999999"), message.ID,
)
}
}
messageCopy := message
previous = &messageCopy
}
if page.NextCursor == nil {
break
}
cursor = *page.NextCursor
}
if len(seen) != expectedMessages || duplicateCount != 0 {
t.Fatalf(
"cursor traversal returned %d unique messages of %d and %d duplicates; first ordering violation: %s",
len(seen), expectedMessages, duplicateCount, firstOrderingViolation,
)
}
if firstOrderingViolation != "" {
t.Fatalf("history is not ordered: %s", firstOrderingViolation)
}
}
func TestCursorTraversalDuringConcurrentWrites(t *testing.T) {
ts, st := setupTestServer()
defer ts.Close()
const (
clients = 16
messagesPerClient = 100
seedMessages = 100
pageLimit = 7
expectedTotal = seedMessages + clients*messagesPerClient
)
memberIDs := make([]string, 0, clients)
for client := 0; client < clients; client++ {
user, err := st.CreateUser(
fmt.Sprintf("live_cursor_client_%d", client),
fmt.Sprintf("Live cursor client %d", client),
)
if err != nil {
t.Fatalf("create user %d: %v", client, err)
}
memberIDs = append(memberIDs, user.ID)
}
chat, err := st.CreateChat("Live concurrent cursor test", memberIDs)
if err != nil {
t.Fatalf("create chat: %v", err)
}
// Начальные сообщения нужны, чтобы читатель сразу начал
// двигать курсор, пока остальные сообщения ещё записываются.
expectedIDs := make(map[string]struct{}, expectedTotal)
for index := 0; index < seedMessages; index++ {
message, err := st.CreateMessage(
chat.ID,
memberIDs[0],
fmt.Sprintf("seed message=%d", index),
)
if err != nil {
t.Fatalf("create seed message %d: %v", index, err)
}
expectedIDs[message.ID] = struct{}{}
}
var expectedMu sync.Mutex
var writers sync.WaitGroup
var ready sync.WaitGroup
start := make(chan struct{})
writerErrors := make(chan error, clients)
for client := 0; client < clients; client++ {
writers.Add(1)
ready.Add(1)
go func(client int) {
defer writers.Done()
ready.Done()
<-start
for index := 0; index < messagesPerClient; index++ {
// Отдаём планировщику возможность чаще переключать
// конкурентные горутины.
runtime.Gosched()
message, err := st.CreateMessage(
chat.ID,
memberIDs[client],
fmt.Sprintf("client=%d message=%d", client, index),
)
if err != nil {
writerErrors <- fmt.Errorf(
"client %d, message %d: %w",
client,
index,
err,
)
return
}
expectedMu.Lock()
expectedIDs[message.ID] = struct{}{}
expectedMu.Unlock()
// Не даём всем писателям завершиться до того,
// как читатель успеет продвинуть курсор.
time.Sleep(50 * time.Microsecond)
}
}(client)
}
// Сначала убеждаемся, что все горутины готовы,
// и только потом одновременно разрешаем запись.
ready.Wait()
writersDone := make(chan struct{})
go func() {
writers.Wait()
close(writersDone)
}()
close(start)
seen := make(map[string]struct{}, expectedTotal)
cursor := ""
var previous *domain.Message
const maxPageRequests = expectedTotal * 4
finished := false
for requestNumber := 0; requestNumber < maxPageRequests; requestNumber++ {
page := fetchCursorPage(
t,
ts.URL,
chat.ID,
memberIDs[0],
pageLimit,
cursor,
)
for index := range page.Items {
message := page.Items[index]
if _, duplicate := seen[message.ID]; duplicate {
t.Fatalf(
"message %s was returned more than once",
message.ID,
)
}
if previous != nil {
outOfOrder :=
message.CreatedAt.Before(previous.CreatedAt) ||
(message.CreatedAt.Equal(previous.CreatedAt) &&
message.ID <= previous.ID)
if outOfOrder {
t.Fatalf(
"messages are out of order: previous=(%s,%s), current=(%s,%s)",
previous.CreatedAt.Format(time.RFC3339Nano),
previous.ID,
message.CreatedAt.Format(time.RFC3339Nano),
message.ID,
)
}
}
seen[message.ID] = struct{}{}
messageCopy := message
previous = &messageCopy
}
// Для продолжающегося чтения строим курсор по последнему
// фактически полученному сообщению. Это позволяет опрашивать
// историю, даже если в промежуточный момент сервер вернул
// NextCursor=nil.
if len(page.Items) > 0 {
last := page.Items[len(page.Items)-1]
cursor = domain.EncodeCursor(
last.CreatedAt,
last.ID,
chat.ID,
)
}
select {
case <-writersDone:
finished = true
default:
}
// Все писатели завершились, а после текущего курсора
// больше ничего нет: обход закончен.
if finished && len(page.Items) == 0 {
break
}
if len(page.Items) == 0 {
runtime.Gosched()
}
if requestNumber == maxPageRequests-1 {
t.Fatalf(
"pagination did not terminate after %d requests",
maxPageRequests,
)
}
}
<-writersDone
close(writerErrors)
for writerErr := range writerErrors {
t.Errorf("create message: %v", writerErr)
}
expectedMu.Lock()
missingIDs := make([]string, 0)
for id := range expectedIDs {
if _, found := seen[id]; !found {
missingIDs = append(missingIDs, id)
}
}
expectedCount := len(expectedIDs)
expectedMu.Unlock()
if expectedCount != expectedTotal {
t.Fatalf(
"writers confirmed %d messages, expected %d",
expectedCount,
expectedTotal,
)
}
if len(missingIDs) != 0 {
const displayedMissingIDs = 5
if len(missingIDs) > displayedMissingIDs {
missingIDs = missingIDs[:displayedMissingIDs]
}
t.Fatalf(
"cursor traversal returned %d of %d confirmed messages; "+
"examples of missing IDs: %v",
len(seen),
expectedTotal,
missingIDs,
)
}
if len(seen) != expectedTotal {
t.Fatalf(
"cursor traversal returned %d messages, expected %d",
len(seen),
expectedTotal,
)
}
}
+367
View File
@@ -0,0 +1,367 @@
package student_tests
import (
"bytes"
"encoding/json"
"fmt"
"io"
"net/http"
"net/http/httptest"
"sync"
"testing"
"mtusi2026lab2/internal/domain"
"mtusi2026lab2/internal/store"
"mtusi2026lab2/internal/transport/http/handlers"
"mtusi2026lab2/internal/transport/http/middleware"
)
// изолированный серв для тестов
func setupTestServer() (*httptest.Server, *store.MemoryStore) {
st := store.NewMemoryStore()
h := handlers.NewHandler(st)
mux := http.NewServeMux()
mux.HandleFunc("POST /api/v1/users", h.CreateUser)
mux.HandleFunc("GET /api/v1/users/me", middleware.RequireAuth(st, h.GetMe))
mux.HandleFunc("POST /api/v1/chats", middleware.RequireAuth(st, h.CreateChat))
mux.HandleFunc("GET /api/v1/chats", middleware.RequireAuth(st, h.ListChats))
mux.HandleFunc("GET /api/v1/chats/{chat_id}", middleware.RequireAuth(st, h.GetChat))
mux.HandleFunc("POST /api/v1/chats/{chat_id}/messages", middleware.RequireAuth(st, h.CreateMessage))
mux.HandleFunc("GET /api/v1/chats/{chat_id}/messages", middleware.RequireAuth(st, h.GetMessages))
var root http.Handler = mux
root = middleware.Recovery(root)
root = middleware.RequestID(root)
return httptest.NewServer(root), st
}
// 1 тест на дубликат username -> 409 Conflict
func TestDuplicateUsername(t *testing.T) {
ts, _ := setupTestServer()
defer ts.Close()
body := `{"username":"bob_the_builder","display_name":"Боб"}`
// Первый раз — 201 Created
res1, _ := http.Post(ts.URL+"/api/v1/users", "application/json", bytes.NewBufferString(body))
if res1.StatusCode != http.StatusCreated {
t.Fatalf("expected 201, got %d", res1.StatusCode)
}
// Второй раз тот же username — 409 Conflict
res2, _ := http.Post(ts.URL+"/api/v1/users", "application/json", bytes.NewBufferString(body))
if res2.StatusCode != http.StatusConflict {
t.Fatalf("expected 409 Conflict for duplicate username, got %d", res2.StatusCode)
}
}
// 2 тест на неверный JSON и лишние поля -> 400 Invalid Request
func TestInvalidAndExtraJSON(t *testing.T) {
ts, _ := setupTestServer()
defer ts.Close()
// Кривой JSON (malformed)
res1, _ := http.Post(ts.URL+"/api/v1/users", "application/json", bytes.NewBufferString(`{"username": "bad"`))
if res1.StatusCode != http.StatusBadRequest {
t.Fatalf("expected 400 for malformed json, got %d", res1.StatusCode)
}
// Лишнее поле "age" (проверка DisallowUnknownFields)
res2, _ := http.Post(ts.URL+"/api/v1/users", "application/json", bytes.NewBufferString(`{"username":"valid_user","display_name":"User","age":25}`))
if res2.StatusCode != http.StatusBadRequest {
t.Fatalf("expected 400 for extra fields, got %d", res2.StatusCode)
}
}
// 3 тст на пустое сообщение и сообщение из одних пробелов -> 400 Invalid Request
func TestEmptyMessageValidation(t *testing.T) {
ts, st := setupTestServer()
defer ts.Close()
u, _ := st.CreateUser("user_msg_test", "Tester")
chat, _ := st.CreateChat("Test Chat", []string{u.ID})
// Пустой текст
req, _ := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/api/v1/chats/%s/messages", ts.URL, chat.ID), bytes.NewBufferString(`{"text":""}`))
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-User-Id", u.ID)
res, _ := http.DefaultClient.Do(req)
if res.StatusCode != http.StatusBadRequest {
t.Fatalf("expected 400 for empty text, got %d", res.StatusCode)
}
// Текст только из пробелов
reqSpaces, _ := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/api/v1/chats/%s/messages", ts.URL, chat.ID), bytes.NewBufferString(`{"text":" "}`))
reqSpaces.Header.Set("Content-Type", "application/json")
reqSpaces.Header.Set("X-User-Id", u.ID)
resSpaces, _ := http.DefaultClient.Do(reqSpaces)
if resSpaces.StatusCode != http.StatusBadRequest {
t.Fatalf("expected 400 for whitespace-only text, got %d", resSpaces.StatusCode)
}
}
// 4 тест: чужой чат для постороннего -> 404 Not Found (не 403!)
func TestOutsiderChatAccess(t *testing.T) {
ts, st := setupTestServer()
defer ts.Close()
alice, _ := st.CreateUser("alice_secret", "Алиса")
eve, _ := st.CreateUser("eve_eavesdropper", "Ева")
chat, _ := st.CreateChat("Секретный чат", []string{alice.ID})
// Ева пытается прочитать чат Алисы
req, _ := http.NewRequest(http.MethodGet, fmt.Sprintf("%s/api/v1/chats/%s", ts.URL, chat.ID), nil)
req.Header.Set("X-User-Id", eve.ID)
res, _ := http.DefaultClient.Do(req)
if res.StatusCode != http.StatusNotFound {
t.Fatalf("expected 404 Not Found (no leak via 403), got %d", res.StatusCode)
}
}
// 5 Тест: пагинация по нескольким страницам с курсором
func TestCursorPaginationMultiplePages(t *testing.T) {
ts, st := setupTestServer()
defer ts.Close()
u, _ := st.CreateUser("paging_user", "Пейджер")
chat, _ := st.CreateChat("Чат пагинации", []string{u.ID})
// Отправляем 5 сообщений
for i := 1; i <= 5; i++ {
st.CreateMessage(chat.ID, u.ID, fmt.Sprintf("Message %d", i))
}
// Запрашиваем порциями по limit=2
var allReceived []string
cursor := ""
for {
url := fmt.Sprintf("%s/api/v1/chats/%s/messages?limit=2", ts.URL, chat.ID)
if cursor != "" {
url += "&cursor=" + cursor
}
req, _ := http.NewRequest(http.MethodGet, url, nil)
req.Header.Set("X-User-Id", u.ID)
res, _ := http.DefaultClient.Do(req)
var page domain.MessagePage
body, _ := io.ReadAll(res.Body)
json.Unmarshal(body, &page)
res.Body.Close()
for _, m := range page.Items {
allReceived = append(allReceived, m.Text)
}
if page.NextCursor == nil {
break
}
cursor = *page.NextCursor
}
if len(allReceived) != 5 {
t.Fatalf("expected 5 messages total across pages, got %d", len(allReceived))
}
}
// 6 тест: 100 сообщений от 10 клиентов одновременно, защита от гонок
func TestConcurrent100MessagesFrom10Clients(t *testing.T) {
ts, st := setupTestServer()
defer ts.Close()
// Создаем 10 пользователей
var memberIDs []string
for i := 0; i < 10; i++ {
u, _ := st.CreateUser(fmt.Sprintf("client_%d", i), fmt.Sprintf("Client %d", i))
memberIDs = append(memberIDs, u.ID)
}
chat, err := st.CreateChat("Highload Chat", memberIDs)
if err != nil {
t.Fatalf("failed to create chat: %v", err)
}
var wg sync.WaitGroup
totalClients := 10
messagesPerClient := 10
for i := 0; i < totalClients; i++ {
wg.Add(1)
clientID := memberIDs[i]
go func(senderID string, clientIndex int) {
defer wg.Done()
for m := 0; m < messagesPerClient; m++ {
text := fmt.Sprintf("Client %d - Message %d", clientIndex, m)
payload := fmt.Sprintf(`{"text":"%s"}`, text)
req, _ := http.NewRequest(
http.MethodPost,
fmt.Sprintf("%s/api/v1/chats/%s/messages", ts.URL, chat.ID),
bytes.NewBufferString(payload),
)
req.Header.Set("Content-Type", "application/json")
req.Header.Set("X-User-Id", senderID)
res, err := http.DefaultClient.Do(req)
if err != nil || res.StatusCode != http.StatusCreated {
t.Errorf("failed to send concurrent message: %v", err)
}
if res != nil {
res.Body.Close()
}
}
}(clientID, i)
}
wg.Wait()
// должно быть 100 сообщений в чате
page, err := st.GetMessages(chat.ID, memberIDs[0], 200, "")
if err != nil {
t.Fatalf("failed to get messages: %v", err)
}
if len(page.Items) != 100 {
t.Fatalf("RACE CONDITION DETECTED: expected exactly 100 messages, got %d", len(page.Items))
}
// уникальность ID
seenIDs := make(map[string]bool)
for _, m := range page.Items {
if seenIDs[m.ID] {
t.Fatalf("duplicate message ID found: %s", m.ID)
}
seenIDs[m.ID] = true
}
}
// 7 тест: защита от подделки курсора (чужой чат или битый Base64) -> 400
func TestForeignAndMalformedCursor(t *testing.T) {
ts, st := setupTestServer()
defer ts.Close()
u, _ := st.CreateUser("cursor_tester", "Tester")
chatA, _ := st.CreateChat("Chat A", []string{u.ID})
chatB, _ := st.CreateChat("Chat B", []string{u.ID})
// В Чат А кладем несколько сообщений, чтобы при limit=1 появился NextCursor
st.CreateMessage(chatA.ID, u.ID, "Message 1 in A")
st.CreateMessage(chatA.ID, u.ID, "Message 2 in A")
st.CreateMessage(chatA.ID, u.ID, "Message 3 in A")
st.CreateMessage(chatA.ID, u.ID, "Message 4 in A")
st.CreateMessage(chatA.ID, u.ID, "Message 5 in A")
st.CreateMessage(chatB.ID, u.ID, "Message 1 in B")
st.CreateMessage(chatB.ID, u.ID, "Message 2 in B")
// Получаем валидный курсор из Чата А (запрашиваем 1 из 2)
pageA, err := st.GetMessages(chatA.ID, u.ID, 1, "")
if err != nil || pageA.NextCursor == nil {
t.Fatalf("expected next_cursor in Chat A, err: %v", err)
}
// 1. Пытаемся применить курсор от Чата А к Чату Б -> строго 400!
urlForeign := fmt.Sprintf("%s/api/v1/chats/%s/messages?cursor=%s", ts.URL, chatB.ID, *pageA.NextCursor)
reqForeign, _ := http.NewRequest(http.MethodGet, urlForeign, nil)
reqForeign.Header.Set("X-User-Id", u.ID)
resForeign, _ := http.DefaultClient.Do(reqForeign)
if resForeign.StatusCode != http.StatusBadRequest {
t.Fatalf("expected 400 for foreign chat cursor, got %d", resForeign.StatusCode)
}
// 2. Битый (невалидный) Base64 -> 400
urlBad := fmt.Sprintf("%s/api/v1/chats/%s/messages?cursor=not-a-valid-base64!@#", ts.URL, chatB.ID)
reqBad, _ := http.NewRequest(http.MethodGet, urlBad, nil)
reqBad.Header.Set("X-User-Id", u.ID)
resBad, _ := http.DefaultClient.Do(reqBad)
if resBad.StatusCode != http.StatusBadRequest {
t.Fatalf("expected 400 for malformed cursor, got %d", resBad.StatusCode)
}
}
// 8 тест валидации создания чата (создателя нет в списке / несуществующий юзер / дубликат) -> 400
func TestChatCreationValidation(t *testing.T) {
ts, st := setupTestServer()
defer ts.Close()
alice, _ := st.CreateUser("alice_chat_val", "Alice")
bob, _ := st.CreateUser("bob_chat_val", "Bob")
// 1. Создатель (Alice) забыла добавить себя в member_ids
bodyNoCaller := fmt.Sprintf(`{"title":"No Caller Chat","member_ids":["%s"]}`, bob.ID)
req1, _ := http.NewRequest(http.MethodPost, ts.URL+"/api/v1/chats", bytes.NewBufferString(bodyNoCaller))
req1.Header.Set("Content-Type", "application/json")
req1.Header.Set("X-User-Id", alice.ID)
res1, _ := http.DefaultClient.Do(req1)
if res1.StatusCode != http.StatusBadRequest {
t.Fatalf("expected 400 when caller is not in member_ids, got %d", res1.StatusCode)
}
// 2. В участниках передан несуществующий UUID
bodyFakeUser := fmt.Sprintf(`{"title":"Fake User Chat","member_ids":["%s","00000000-0000-0000-0000-000000000000"]}`, alice.ID)
req2, _ := http.NewRequest(http.MethodPost, ts.URL+"/api/v1/chats", bytes.NewBufferString(bodyFakeUser))
req2.Header.Set("Content-Type", "application/json")
req2.Header.Set("X-User-Id", alice.ID)
res2, _ := http.DefaultClient.Do(req2)
if res2.StatusCode != http.StatusBadRequest {
t.Fatalf("expected 400 for non-existent member_id, got %d", res2.StatusCode)
}
// 3. Дубликат участника в списке
bodyDuplicate := fmt.Sprintf(`{"title":"Duplicate Member","member_ids":["%s","%s"]}`, alice.ID, alice.ID)
req3, _ := http.NewRequest(http.MethodPost, ts.URL+"/api/v1/chats", bytes.NewBufferString(bodyDuplicate))
req3.Header.Set("Content-Type", "application/json")
req3.Header.Set("X-User-Id", alice.ID)
res3, _ := http.DefaultClient.Do(req3)
if res3.StatusCode != http.StatusBadRequest {
t.Fatalf("expected 400 for duplicate member_ids, got %d", res3.StatusCode)
}
}
// 9 тест лимитов символов Unicode (длина до 4000 рун и отказ при >4000)
func TestUnicodeLimits(t *testing.T) {
ts, st := setupTestServer()
defer ts.Close()
u, _ := st.CreateUser("unicode_master", "Иван 🚀")
chat, _ := st.CreateChat("Unicode Chat", []string{u.ID})
// Ровно 4000 смайликов (в байтах это 16000 байт, но в рунах — ровно 4000!)
validRunes := make([]rune, 4000)
for i := range validRunes {
validRunes[i] = '🔥'
}
bodyValid := fmt.Sprintf(`{"text":"%s"}`, string(validRunes))
req1, _ := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/api/v1/chats/%s/messages", ts.URL, chat.ID), bytes.NewBufferString(bodyValid))
req1.Header.Set("Content-Type", "application/json")
req1.Header.Set("X-User-Id", u.ID)
res1, _ := http.DefaultClient.Do(req1)
if res1.StatusCode != http.StatusCreated {
t.Fatalf("expected 201 for 4000 unicode runes, got %d", res1.StatusCode)
}
// 4001 символ -> строго 400 Invalid Request!
tooLongRunes := make([]rune, 4001)
for i := range tooLongRunes {
tooLongRunes[i] = 'a'
}
bodyTooLong := fmt.Sprintf(`{"text":"%s"}`, string(tooLongRunes))
req2, _ := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/api/v1/chats/%s/messages", ts.URL, chat.ID), bytes.NewBufferString(bodyTooLong))
req2.Header.Set("Content-Type", "application/json")
req2.Header.Set("X-User-Id", u.ID)
res2, _ := http.DefaultClient.Do(req2)
if res2.StatusCode != http.StatusBadRequest {
t.Fatalf("expected 400 for 4001 runes, got %d", res2.StatusCode)
}
}