forked from mtusi2026/mtusi2026lab4
356 lines
9.5 KiB
Go
356 lines
9.5 KiB
Go
package student_tests
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/base64"
|
|
"encoding/json"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
"time"
|
|
|
|
store "mtusi2026lab4/internal/adapter/memory"
|
|
"mtusi2026lab4/internal/security"
|
|
"mtusi2026lab4/internal/transport/http/dto"
|
|
"mtusi2026lab4/internal/transport/http/handlers"
|
|
"mtusi2026lab4/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(¤tUser); 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)
|
|
}
|
|
}
|