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: "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) } }