Files
mtusi2026lab3/student_tests/auth_test.go
T
2026-10-25 21:46:21 +03:00

356 lines
9.5 KiB
Go

package student_tests
import (
"bytes"
"encoding/base64"
"encoding/json"
"io"
"net/http"
"net/http/httptest"
"testing"
"time"
store "mtusi2026lab3/internal/adapter/memory"
"mtusi2026lab3/internal/security"
"mtusi2026lab3/internal/transport/http/dto"
"mtusi2026lab3/internal/transport/http/handlers"
"mtusi2026lab3/internal/transport/http/middleware"
)
const testPassword = "Test-password-123"
func setupSessionTestServer(
t *testing.T,
sessionTTL time.Duration,
) (*httptest.Server, *store.MemoryRepository) {
t.Helper()
repository := store.NewMemoryRepository(store.NewMemoryStore())
service := newTestService(repository, sessionTTL)
handler := handlers.NewHandler(service)
mux := http.NewServeMux()
mux.HandleFunc("POST /api/v1/users", handler.CreateUser)
mux.HandleFunc("POST /api/v1/auth/sessions", handler.CreateSession)
mux.HandleFunc(
"GET /api/v1/users/me",
middleware.RequireAuth(service, handler.GetMe),
)
mux.HandleFunc(
"DELETE /api/v1/auth/sessions/current",
middleware.RequireAuth(service, handler.DeleteCurrentSession),
)
var root http.Handler = mux
root = middleware.Recovery(root)
root = middleware.RequestID(root)
return httptest.NewServer(root), repository
}
func registerSessionTestUser(
t *testing.T,
baseURL string,
username string,
) dto.UserResponse {
t.Helper()
payload, err := json.Marshal(map[string]string{
"username": username,
"display_name": "Session test user",
"password": testPassword,
})
if err != nil {
t.Fatalf("marshal registration request: %v", err)
}
response, err := http.Post(
baseURL+"/api/v1/users",
"application/json",
bytes.NewReader(payload),
)
if err != nil {
t.Fatalf("register user: %v", err)
}
defer response.Body.Close()
if response.StatusCode != http.StatusCreated {
body, _ := io.ReadAll(response.Body)
t.Fatalf("expected registration status 201, got %d: %s", response.StatusCode, body)
}
var user dto.UserResponse
if err := json.NewDecoder(response.Body).Decode(&user); err != nil {
t.Fatalf("decode registered user: %v", err)
}
return user
}
func createSessionRequest(
t *testing.T,
baseURL string,
username string,
password string,
) *http.Response {
t.Helper()
credentials := base64.StdEncoding.EncodeToString(
[]byte(username + ":" + password),
)
request, err := http.NewRequest(
http.MethodPost,
baseURL+"/api/v1/auth/sessions",
nil,
)
if err != nil {
t.Fatalf("create login request: %v", err)
}
request.Header.Set("Authorization", "Basic "+credentials)
response, err := http.DefaultClient.Do(request)
if err != nil {
t.Fatalf("send login request: %v", err)
}
return response
}
func TestSessionAuthenticationLifecycle(t *testing.T) {
testServer, repository := setupSessionTestServer(t, time.Hour)
defer testServer.Close()
alice := registerSessionTestUser(t, testServer.URL, "session_alice")
eve := registerSessionTestUser(t, testServer.URL, "session_eve")
_, passwordHash, err := repository.GetUserByUsername(
t.Context(),
alice.Username,
)
if err != nil {
t.Fatalf("read registered user credentials: %v", err)
}
if passwordHash == testPassword || bytes.Contains(
[]byte(passwordHash),
[]byte(testPassword),
) {
t.Fatal("repository contains plaintext password")
}
passwordMatches, err := security.VerifyPassword(testPassword, passwordHash)
if err != nil || !passwordMatches {
t.Fatalf("stored password hash does not verify: matches=%v err=%v", passwordMatches, err)
}
wrongPasswordResponse := createSessionRequest(
t,
testServer.URL,
alice.Username,
"Wrong-password-123",
)
wrongPasswordResponse.Body.Close()
if wrongPasswordResponse.StatusCode != http.StatusUnauthorized {
t.Fatalf("expected 401 for wrong password, got %d", wrongPasswordResponse.StatusCode)
}
if got := wrongPasswordResponse.Header.Get("WWW-Authenticate"); got != `Basic realm="messenger", charset="UTF-8"` {
t.Fatalf("unexpected Basic challenge: %q", got)
}
unknownUserResponse := createSessionRequest(
t,
testServer.URL,
"unknown_session_user",
"Wrong-password-123",
)
unknownUserResponse.Body.Close()
if unknownUserResponse.StatusCode != http.StatusUnauthorized {
t.Fatalf("expected 401 for unknown username, got %d", unknownUserResponse.StatusCode)
}
if got := unknownUserResponse.Header.Get("WWW-Authenticate"); got != `Basic realm="messenger", charset="UTF-8"` {
t.Fatalf("unexpected Basic challenge for unknown username: %q", got)
}
loginResponse := createSessionRequest(
t,
testServer.URL,
alice.Username,
testPassword,
)
defer loginResponse.Body.Close()
if loginResponse.StatusCode != http.StatusCreated {
body, _ := io.ReadAll(loginResponse.Body)
t.Fatalf("expected login status 201, got %d: %s", loginResponse.StatusCode, body)
}
var session dto.SessionResponse
if err := json.NewDecoder(loginResponse.Body).Decode(&session); err != nil {
t.Fatalf("decode session: %v", err)
}
if session.Token == "" || session.TokenType != "Bearer" {
t.Fatalf("unexpected session token response: type=%q empty=%v", session.TokenType, session.Token == "")
}
if session.User != alice {
t.Fatalf("session belongs to another user: got %s, want %s", session.User.ID, alice.ID)
}
testCases := []struct {
name string
authorization string
userIDHeader string
wantStatus int
}{
{
name: "X-User-Id alone is rejected",
userIDHeader: alice.ID,
wantStatus: http.StatusUnauthorized,
},
{
name: "Basic is rejected on business endpoint",
authorization: "Basic " + base64.StdEncoding.EncodeToString([]byte(alice.Username+":"+testPassword)),
wantStatus: http.StatusUnauthorized,
},
{
name: "non-ASCII Bearer is rejected without panic",
authorization: "Bearer é",
wantStatus: http.StatusUnauthorized,
},
{
name: "Bearer identity wins over X-User-Id",
authorization: "Bearer " + session.Token,
userIDHeader: eve.ID,
wantStatus: http.StatusOK,
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
request, err := http.NewRequest(
http.MethodGet,
testServer.URL+"/api/v1/users/me",
nil,
)
if err != nil {
t.Fatalf("create authenticated request: %v", err)
}
if testCase.authorization != "" {
request.Header.Set("Authorization", testCase.authorization)
}
if testCase.userIDHeader != "" {
request.Header.Set("X-User-Id", testCase.userIDHeader)
}
response, err := http.DefaultClient.Do(request)
if err != nil {
t.Fatalf("send authenticated request: %v", err)
}
defer response.Body.Close()
if response.StatusCode != testCase.wantStatus {
t.Fatalf("expected status %d, got %d", testCase.wantStatus, response.StatusCode)
}
if testCase.wantStatus == http.StatusUnauthorized {
if got := response.Header.Get("WWW-Authenticate"); got != `Bearer realm="messenger"` {
t.Fatalf("unexpected Bearer challenge: %q", got)
}
return
}
var currentUser dto.UserResponse
if err := json.NewDecoder(response.Body).Decode(&currentUser); err != nil {
t.Fatalf("decode current user: %v", err)
}
if currentUser.ID != alice.ID {
t.Fatalf("X-User-Id overrode Bearer identity: got %s, want %s", currentUser.ID, alice.ID)
}
})
}
logoutRequest, err := http.NewRequest(
http.MethodDelete,
testServer.URL+"/api/v1/auth/sessions/current",
nil,
)
if err != nil {
t.Fatalf("create logout request: %v", err)
}
logoutRequest.Header.Set("Authorization", "Bearer "+session.Token)
logoutResponse, err := http.DefaultClient.Do(logoutRequest)
if err != nil {
t.Fatalf("send logout request: %v", err)
}
logoutBody, err := io.ReadAll(logoutResponse.Body)
logoutResponse.Body.Close()
if err != nil {
t.Fatalf("read logout response: %v", err)
}
if logoutResponse.StatusCode != http.StatusNoContent {
t.Fatalf("expected logout status 204, got %d", logoutResponse.StatusCode)
}
if len(logoutBody) != 0 {
t.Fatalf("logout response contains a body: %q", logoutBody)
}
revokedRequest, err := http.NewRequest(
http.MethodGet,
testServer.URL+"/api/v1/users/me",
nil,
)
if err != nil {
t.Fatalf("create revoked-token request: %v", err)
}
revokedRequest.Header.Set("Authorization", "Bearer "+session.Token)
revokedResponse, err := http.DefaultClient.Do(revokedRequest)
if err != nil {
t.Fatalf("send revoked-token request: %v", err)
}
revokedResponse.Body.Close()
if revokedResponse.StatusCode != http.StatusUnauthorized {
t.Fatalf("expected 401 for revoked token, got %d", revokedResponse.StatusCode)
}
}
func TestSessionExpiry(t *testing.T) {
testServer, _ := setupSessionTestServer(t, 25*time.Millisecond)
defer testServer.Close()
user := registerSessionTestUser(t, testServer.URL, "session_expiry")
loginResponse := createSessionRequest(
t,
testServer.URL,
user.Username,
testPassword,
)
var session dto.SessionResponse
if err := json.NewDecoder(loginResponse.Body).Decode(&session); err != nil {
loginResponse.Body.Close()
t.Fatalf("decode session: %v", err)
}
loginResponse.Body.Close()
time.Sleep(75 * time.Millisecond)
request, err := http.NewRequest(
http.MethodGet,
testServer.URL+"/api/v1/users/me",
nil,
)
if err != nil {
t.Fatalf("create expired-token request: %v", err)
}
request.Header.Set("Authorization", "Bearer "+session.Token)
response, err := http.DefaultClient.Do(request)
if err != nil {
t.Fatalf("send expired-token request: %v", err)
}
response.Body.Close()
if response.StatusCode != http.StatusUnauthorized {
t.Fatalf("expected 401 for expired token, got %d", response.StatusCode)
}
}