Files
mtusi2026lab2/student-tests/auth_tests/errors_test.go
OlegRood 834876c938 ЛР 2: закрыть уровень 4
Завершить PostgreSQL, Redis-сессии, миграции, таймауты и диагностику. Зафиксировать собственные тесты и доказательства финального прогона: 43 PASS, 0 FAIL, 0 SKIP; 768 HTTP-запросов без ошибок. Добавить официальный отчёт с запуском, архитектурой, SQL-планами и ограничениями. PR отложен до завершения уровня 5.
2026-10-28 13:30:26 +03:00

274 lines
10 KiB
Go

package auth_tests
import (
"bytes"
"context"
"encoding/json"
"errors"
"fmt"
"io"
"log/slog"
"net"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
"highload/internal/database/sqlc"
repository "highload/internal/repository/postgres"
"highload/internal/service"
"highload/internal/transport/http/handler"
"highload/internal/transport/http/httputils"
"highload/internal/transport/http/middleware"
"github.com/google/uuid"
"github.com/jackc/pgx/v5"
"github.com/jackc/pgx/v5/pgconn"
"github.com/jackc/pgx/v5/pgtype"
)
func TestErrorDiagnosticsRecordedOnceAndPublicResponseIsSafe(t *testing.T) {
var output bytes.Buffer
original := slog.Default()
slog.SetDefault(slog.New(slog.NewJSONHandler(&output, nil)))
defer slog.SetDefault(original)
users := service.NewUserService(repository.NewUserRepository(sqlc.New(faultDB{cause: errors.New("synthetic-storage-diagnostic")})))
_, cause := users.GetUser(context.Background(), uuid.NewString())
request := httptest.NewRequest(http.MethodGet, "/api/v1/users/me", nil)
request.Header.Set("Authorization", "Bearer synthetic-secret-not-for-logs")
recorder := httptest.NewRecorder()
mid := middleware.NewMiddleware(nil)
mid.RequestID(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
_ = httputils.WriteServiceError(w, cause, middleware.RequestIDFromContext(r.Context()))
})).ServeHTTP(recorder, request)
assertContractError(t, recorder, 500, "internal_error")
if strings.Contains(recorder.Body.String(), "synthetic-storage-diagnostic") {
t.Error("public response exposed internal cause")
}
if strings.Contains(output.String(), "synthetic-secret-not-for-logs") {
t.Error("server log exposed a Bearer credential")
}
var records []map[string]any
for _, line := range strings.Split(strings.TrimSpace(output.String()), "\n") {
if line == "" {
continue
}
var record map[string]any
if json.Unmarshal([]byte(line), &record) != nil {
t.Error("diagnostic log is not structured JSON")
continue
}
// Access records are not detailed duplicate error records.
if record["msg"] != "http request" {
records = append(records, record)
}
}
if len(records) != 1 {
t.Errorf("want exactly one detailed error at response boundary, got %d", len(records))
return
}
record := records[0]
if _, malformed := record["!BADKEY"]; malformed {
t.Error("structured error log contains !BADKEY: slog arguments are not valid key/value pairs")
}
if record["request_id"] != recorder.Header().Get("X-Request-Id") || record["status"] != float64(500) ||
(record["code"] != "internal_error" && record["error_code"] != "internal_error") {
t.Error("diagnostic is missing matching request_id/status/error code")
}
encoded, _ := json.Marshal(record)
if !bytes.Contains(encoded, []byte("synthetic-storage-diagnostic")) {
t.Error("diagnostic lost storage cause")
}
}
// Faults enter through sqlc's database interface, then pass through the real
// repository, service and HTTP error mapper. Driver causes are deliberately
// not required to survive: the public category and response are the contract.
type errorCase struct {
name string
cause error
want error
status int
code string
}
func databaseErrorCases() []errorCase {
cases := []errorCase{
{"no_rows", pgx.ErrNoRows, service.ErrNotFound, 404, "not_found"},
{"duplicate", &pgconn.PgError{Code: "23505"}, service.ErrAlreadyExists, 409, "conflict"},
{"eof", io.EOF, service.ErrServiceUnavailable, 503, "unavailable"},
{"deadline", context.DeadlineExceeded, service.ErrServiceUnavailable, 503, "unavailable"},
{"unexpected_eof", io.ErrUnexpectedEOF, service.ErrServiceUnavailable, 503, "unavailable"},
{"closed_connection", pgconn.ErrConnClosed, service.ErrServiceUnavailable, 503, "unavailable"},
{"connection_refused", unavailableRow{}.Scan(), service.ErrServiceUnavailable, 503, "unavailable"},
// Docker removes the stopped service from DNS. The real outage probe
// returned a ConnectError containing this error, without a net.OpError.
{"database_dns_missing", &net.DNSError{Err: "no such host", Name: "postgres", IsNotFound: true}, service.ErrServiceUnavailable, 503, "unavailable"},
{"sql_syntax", &pgconn.PgError{Code: "42601", Message: "private SQL diagnostic"}, service.ErrServerError, 500, "internal_error"},
{"unexpected", errors.New("private database diagnostic"), service.ErrServerError, 500, "internal_error"},
}
for _, code := range []string{"53300", "57P03", "08006", "08001", "57P01", "57P02"} {
cases = append(cases, errorCase{"sqlstate_" + code, &pgconn.PgError{Code: code}, service.ErrServiceUnavailable, 503, "unavailable"})
}
// Wrapping must not change how an existing error category is recognized.
originals := append([]errorCase(nil), cases...)
for _, tc := range originals {
tc.name = "wrapped_" + tc.name
tc.cause = fmt.Errorf("database operation: %w", tc.cause)
cases = append(cases, tc)
}
return cases
}
type faultRow struct{ cause error }
func (r faultRow) Scan(...any) error { return r.cause }
type faultDB struct {
unavailableDB
cause error
}
func (d faultDB) QueryRow(context.Context, string, ...any) pgx.Row {
return faultRow{d.cause}
}
func assertContractError(t *testing.T, recorder *httptest.ResponseRecorder, status int, code string) {
t.Helper()
if recorder.Code != status {
t.Fatalf("want HTTP %d, got %d", status, recorder.Code)
}
if recorder.Header().Get("Content-Type") != "application/json" {
t.Fatal("error response must have application/json content type")
}
var payload struct {
Error struct {
Code string `json:"code"`
Message string `json:"message"`
RequestID string `json:"request_id"`
} `json:"error"`
}
decoder := json.NewDecoder(recorder.Body)
if err := decoder.Decode(&payload); err != nil {
t.Fatal("error response is not valid JSON")
}
if decoder.Decode(new(any)) != io.EOF {
t.Fatal("error response contains more than one JSON value")
}
if payload.Error.Code != code || payload.Error.RequestID == "" ||
payload.Error.RequestID != recorder.Header().Get("X-Request-Id") {
t.Fatal("error category or request ID violates the API contract")
}
if payload.Error.Message == "" || strings.Contains(payload.Error.Message, "private") {
t.Fatal("error message is empty or discloses internal diagnostics")
}
}
func TestErrorDatabaseCategoryReachesHTTP(t *testing.T) {
for _, tc := range databaseErrorCases() {
t.Run(tc.name, func(t *testing.T) {
users := service.NewUserService(repository.NewUserRepository(sqlc.New(faultDB{cause: tc.cause})))
_, err := users.GetUser(context.Background(), uuid.NewString())
if !errors.Is(err, tc.want) {
t.Fatalf("want category %v, got %v", tc.want, err)
}
if errors.Is(tc.cause, context.DeadlineExceeded) && !strings.Contains(err.Error(), context.DeadlineExceeded.Error()) {
t.Error("deadline diagnostic context lost between repository and service")
}
recorder := httptest.NewRecorder()
mid := middleware.NewMiddleware(nil)
mid.RequestID(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
_ = httputils.WriteServiceError(w, err, middleware.RequestIDFromContext(r.Context()))
})).ServeHTTP(recorder, httptest.NewRequest(http.MethodGet, "/api/v1/users/me", nil))
assertContractError(t, recorder, tc.status, tc.code)
})
}
}
func TestErrorUnavailableSQLLoginKeepsCategory(t *testing.T) {
for _, tc := range databaseErrorCases() {
if tc.status != 503 {
continue
}
t.Run(tc.name, func(t *testing.T) {
queries := sqlc.New(faultDB{cause: tc.cause})
auth := service.NewAuthService(repository.NewUserRepository(queries), nil, time.Hour)
mid := middleware.NewMiddleware(auth)
request := httptest.NewRequest(http.MethodPost, "/api/v1/auth/sessions", nil)
request.SetBasicAuth("synthetic_user", "Synthetic:password")
recorder := httptest.NewRecorder()
mid.RequestID(http.HandlerFunc(handler.NewAuthHandler(auth).CreateSession)).ServeHTTP(recorder, request)
assertContractError(t, recorder, 503, "unavailable")
})
}
}
// The caller exists; the other member lookup fails. This isolates the service
// branch that used to replace the received err with ErrServerError.
type memberFaultDB struct {
unavailableDB
caller uuid.UUID
cause error
}
func (d memberFaultDB) QueryRow(_ context.Context, _ string, args ...any) pgx.Row {
id := uuid.UUID(args[0].(pgtype.UUID).Bytes)
if id == d.caller {
return memberUserRow{id}
}
return faultRow{d.cause}
}
type memberUserRow struct{ id uuid.UUID }
func (r memberUserRow) Scan(dst ...any) error {
*dst[0].(*pgtype.UUID) = pgtype.UUID{Bytes: [16]byte(r.id), Valid: true}
*dst[1].(*string) = "error_test_caller"
*dst[2].(*string) = "Error test caller"
*dst[3].(*string) = "unused password hash"
*dst[4].(*pgtype.Timestamptz) = pgtype.Timestamptz{Time: time.Unix(1, 0), Valid: true}
return nil
}
func TestErrorChatMemberLookupKeepsOperationMeaning(t *testing.T) {
for _, tc := range databaseErrorCases() {
if tc.status != 503 && tc.status != 404 && tc.status != 500 {
continue
}
t.Run(tc.name, func(t *testing.T) {
caller := uuid.New()
queries := sqlc.New(memberFaultDB{caller: caller, cause: tc.cause})
users := repository.NewUserRepository(queries)
// No writable repository: an invalid member list must never reach
// chat insertion. Accidentally continuing is a test failure.
chats := service.NewChatService(nil, users, service.NewUserService(users))
_, err := chats.Create(context.Background(), "Error regression", []string{caller.String(), uuid.NewString()}, caller.String())
want, status, code := tc.want, tc.status, tc.code
if tc.status == 404 {
// contracts/README.md:17: unknown members make POST /chats invalid.
want, status, code = service.ErrInvalidInput, 400, "invalid_request"
}
if !errors.Is(err, want) {
t.Fatalf("want category %v, got %v", want, err)
}
gotStatus, gotCode := httputils.ErrorFromService(err)
if gotStatus != status || gotCode != code {
t.Fatalf("want %d/%s, got %d/%s", status, code, gotStatus, gotCode)
}
})
}
}
func TestErrorMissingBasicPrecedesForbiddenBody(t *testing.T) {
mid := middleware.NewMiddleware(nil)
auth := handler.NewAuthHandler(nil)
request := httptest.NewRequest(http.MethodPost, "/api/v1/auth/sessions", strings.NewReader("{}"))
recorder := httptest.NewRecorder()
mid.RequestID(http.HandlerFunc(auth.CreateSession)).ServeHTTP(recorder, request)
assertContractError(t, recorder, 401, "unauthorized")
if recorder.Header().Get("WWW-Authenticate") != `Basic realm="messenger", charset="UTF-8"` {
t.Fatal("missing Basic challenge")
}
}