From 6b1daad71822b86a4e977ac34aba95633d122893 Mon Sep 17 00:00:00 2001
From: "claude[bot]" <41898282+claude[bot]@users.noreply.github.com>
Date: Fri, 3 Apr 2026 16:22:20 +0000
Subject: [PATCH 1/2] test(auth): add comprehensive unit tests for AuthService

Cover register, login, getCurrentUser, and logout methods including
success paths, error handling, localStorage interactions, and signal state.

Co-authored-by: thivernale <thivernale@users.noreply.github.com>
---
 src/app/auth/services/auth.service.spec.ts | 294 ++++++++++++++++++++-
 1 file changed, 292 insertions(+), 2 deletions(-)

diff --git a/src/app/auth/services/auth.service.spec.ts b/src/app/auth/services/auth.service.spec.ts
index f1251ca..fc553cd 100644
--- a/src/app/auth/services/auth.service.spec.ts
+++ b/src/app/auth/services/auth.service.spec.ts
@@ -1,16 +1,306 @@
+import { provideHttpClient } from '@angular/common/http';
+import { HttpTestingController, provideHttpClientTesting } from '@angular/common/http/testing';
 import { TestBed } from '@angular/core/testing';
-
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { environment } from '../../../environments/environment';
+import { User, UserResponse } from '../types/user.interface';
 import { AuthService } from './auth.service';
 
+const mockUser: User = {
+  email: 'test@example.com',
+  token: 'mock-token-123',
+  username: 'testuser',
+};
+
+const mockUserResponse: UserResponse = { user: mockUser };
+
 describe('AuthService', () => {
   let service: AuthService;
+  let httpTesting: HttpTestingController;
 
   beforeEach(() => {
-    TestBed.configureTestingModule({});
+    TestBed.configureTestingModule({
+      providers: [
+        provideHttpClient(),
+        provideHttpClientTesting(),
+      ],
+    });
     service = TestBed.inject(AuthService);
+    httpTesting = TestBed.inject(HttpTestingController);
+    localStorage.clear();
+  });
+
+  afterEach(() => {
+    httpTesting.verify();
+    localStorage.clear();
+    vi.restoreAllMocks();
   });
 
   it('should be created', () => {
     expect(service).toBeTruthy();
   });
+
+  it('should initialize currentUserSignal as undefined', () => {
+    expect(service.currentUserSignal()).toBeUndefined();
+  });
+
+  describe('register()', () => {
+    const registerModel = { email: 'test@example.com', password: 'password123', username: 'testuser' };
+
+    it('should POST to the correct URL', () => {
+      service.register(registerModel).subscribe();
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/users`);
+      expect(req.request.method).toBe('POST');
+      req.flush(mockUserResponse);
+    });
+
+    it('should send the user in the request body', () => {
+      service.register(registerModel).subscribe();
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/users`);
+      expect(req.request.body).toEqual({ user: registerModel });
+      req.flush(mockUserResponse);
+    });
+
+    it('should set Content-Type header', () => {
+      service.register(registerModel).subscribe();
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/users`);
+      expect(req.request.headers.get('Content-Type')).toBe('application/json; charset=utf-8');
+      req.flush(mockUserResponse);
+    });
+
+    it('should store token in localStorage on success', () => {
+      service.register(registerModel).subscribe();
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/users`);
+      req.flush(mockUserResponse);
+
+      expect(localStorage.getItem('token')).toBe(mockUser.token);
+    });
+
+    it('should set currentUserSignal on success', () => {
+      service.register(registerModel).subscribe();
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/users`);
+      req.flush(mockUserResponse);
+
+      expect(service.currentUserSignal()).toEqual(mockUser);
+    });
+
+    it('should emit the user on success', () => {
+      let emittedUser: User | undefined;
+      service.register(registerModel).subscribe(user => (emittedUser = user));
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/users`);
+      req.flush(mockUserResponse);
+
+      expect(emittedUser).toEqual(mockUser);
+    });
+
+    it('should throw formatted error on HTTP error', () => {
+      const errorResponse = { errors: { email: ['is already taken'] } };
+      let thrownError: Error | undefined;
+
+      service.register(registerModel).subscribe({
+        error: (err: Error) => (thrownError = err),
+      });
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/users`);
+      req.flush(errorResponse, { status: 422, statusText: 'Unprocessable Entity' });
+
+      expect(thrownError).toBeInstanceOf(Error);
+      expect(thrownError!.message).toContain('<ul>');
+      expect(thrownError!.message).toContain('email');
+      expect(thrownError!.message).toContain('is already taken');
+    });
+
+    it('should format multiple error fields', () => {
+      const errorResponse = { errors: { email: ['is invalid'], username: ['is taken'] } };
+      let thrownError: Error | undefined;
+
+      service.register(registerModel).subscribe({
+        error: (err: Error) => (thrownError = err),
+      });
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/users`);
+      req.flush(errorResponse, { status: 422, statusText: 'Unprocessable Entity' });
+
+      expect(thrownError!.message).toContain('email');
+      expect(thrownError!.message).toContain('username');
+    });
+  });
+
+  describe('login()', () => {
+    const loginModel = { email: 'test@example.com', password: 'password123' };
+
+    it('should POST to the correct URL', () => {
+      service.login(loginModel).subscribe();
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/users/login`);
+      expect(req.request.method).toBe('POST');
+      req.flush(mockUserResponse);
+    });
+
+    it('should send the user in the request body', () => {
+      service.login(loginModel).subscribe();
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/users/login`);
+      expect(req.request.body).toEqual({ user: loginModel });
+      req.flush(mockUserResponse);
+    });
+
+    it('should set Content-Type header', () => {
+      service.login(loginModel).subscribe();
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/users/login`);
+      expect(req.request.headers.get('Content-Type')).toBe('application/json; charset=utf-8');
+      req.flush(mockUserResponse);
+    });
+
+    it('should store token in localStorage on success', () => {
+      service.login(loginModel).subscribe();
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/users/login`);
+      req.flush(mockUserResponse);
+
+      expect(localStorage.getItem('token')).toBe(mockUser.token);
+    });
+
+    it('should set currentUserSignal on success', () => {
+      service.login(loginModel).subscribe();
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/users/login`);
+      req.flush(mockUserResponse);
+
+      expect(service.currentUserSignal()).toEqual(mockUser);
+    });
+
+    it('should emit the user on success', () => {
+      let emittedUser: User | undefined;
+      service.login(loginModel).subscribe(user => (emittedUser = user));
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/users/login`);
+      req.flush(mockUserResponse);
+
+      expect(emittedUser).toEqual(mockUser);
+    });
+
+    it('should throw formatted error on HTTP error', () => {
+      const errorResponse = { errors: { 'email or password': ['is invalid'] } };
+      let thrownError: Error | undefined;
+
+      service.login(loginModel).subscribe({
+        error: (err: Error) => (thrownError = err),
+      });
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/users/login`);
+      req.flush(errorResponse, { status: 401, statusText: 'Unauthorized' });
+
+      expect(thrownError).toBeInstanceOf(Error);
+      expect(thrownError!.message).toContain('email or password');
+      expect(thrownError!.message).toContain('is invalid');
+    });
+  });
+
+  describe('getCurrentUser()', () => {
+    it('should return null and set signal to null when no token in localStorage', () => {
+      localStorage.removeItem('token');
+      let result: User | null | undefined;
+
+      service.getCurrentUser().subscribe(user => (result = user));
+
+      expect(result).toBeNull();
+      expect(service.currentUserSignal()).toBeNull();
+      httpTesting.expectNone(`${environment.authUrl}/api/user`);
+    });
+
+    it('should GET from correct URL when token exists', () => {
+      localStorage.setItem('token', 'existing-token');
+
+      service.getCurrentUser().subscribe();
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/user`);
+      expect(req.request.method).toBe('GET');
+      req.flush(mockUserResponse);
+    });
+
+    it('should set currentUserSignal on successful response', () => {
+      localStorage.setItem('token', 'existing-token');
+
+      service.getCurrentUser().subscribe();
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/user`);
+      req.flush(mockUserResponse);
+
+      expect(service.currentUserSignal()).toEqual(mockUser);
+    });
+
+    it('should emit the user on success', () => {
+      localStorage.setItem('token', 'existing-token');
+      let emittedUser: User | null | undefined;
+
+      service.getCurrentUser().subscribe(user => (emittedUser = user));
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/user`);
+      req.flush(mockUserResponse);
+
+      expect(emittedUser).toEqual(mockUser);
+    });
+
+    it('should call logout and return null on HTTP error', () => {
+      localStorage.setItem('token', 'existing-token');
+      const logoutSpy = vi.spyOn(service, 'logout');
+      let result: User | null | undefined;
+
+      service.getCurrentUser().subscribe(user => (result = user));
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/user`);
+      req.flush('Unauthorized', { status: 401, statusText: 'Unauthorized' });
+
+      expect(logoutSpy).toHaveBeenCalled();
+      expect(result).toBeNull();
+    });
+
+    it('should clear token from localStorage on HTTP error', () => {
+      localStorage.setItem('token', 'existing-token');
+
+      service.getCurrentUser().subscribe();
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/user`);
+      req.flush('Unauthorized', { status: 401, statusText: 'Unauthorized' });
+
+      expect(localStorage.getItem('token')).toBeNull();
+    });
+
+    it('should set currentUserSignal to null on HTTP error', () => {
+      localStorage.setItem('token', 'existing-token');
+
+      service.getCurrentUser().subscribe();
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/user`);
+      req.flush('Unauthorized', { status: 401, statusText: 'Unauthorized' });
+
+      expect(service.currentUserSignal()).toBeNull();
+    });
+  });
+
+  describe('logout()', () => {
+    it('should remove token from localStorage', () => {
+      localStorage.setItem('token', 'some-token');
+
+      service.logout();
+
+      expect(localStorage.getItem('token')).toBeNull();
+    });
+
+    it('should set currentUserSignal to null', () => {
+      service.currentUserSignal.set(mockUser);
+
+      service.logout();
+
+      expect(service.currentUserSignal()).toBeNull();
+    });
+  });
 });

From 76cb4506d6ea8db00f14f35684bfeaa4167dc30d Mon Sep 17 00:00:00 2001
From: thivernale <thivernale@gmail.com>
Date: Sat, 4 Apr 2026 12:47:06 +0300
Subject: [PATCH 2/2] Refactor `AuthService` to improve signal encapsulation
 and error formatting, update related tests

---
 src/app/auth/guards/auth-guard.spec.ts     | 35 ++++++++++++++--------
 src/app/auth/services/auth.service.spec.ts | 33 ++++++++++++++++++--
 src/app/auth/services/auth.service.ts      | 30 +++++++++++--------
 3 files changed, 72 insertions(+), 26 deletions(-)

diff --git a/src/app/auth/guards/auth-guard.spec.ts b/src/app/auth/guards/auth-guard.spec.ts
index f195d16..513c8fa 100644
--- a/src/app/auth/guards/auth-guard.spec.ts
+++ b/src/app/auth/guards/auth-guard.spec.ts
@@ -1,8 +1,10 @@
-import { signal } from '@angular/core';
+import { inject, signal } from '@angular/core';
 import { TestBed } from '@angular/core/testing';
 import { CanActivateFn } from '@angular/router';
-import { Mocked, vi } from 'vitest';
+import { of } from 'rxjs';
+import { vi } from 'vitest';
 import { AuthService } from '../services/auth.service';
+import { User } from '../types/user.interface';
 
 import { authGuard } from './auth-guard';
 
@@ -10,16 +12,23 @@ describe('authGuard', () => {
   const executeGuard: CanActivateFn = (...guardParameters) =>
     TestBed.runInInjectionContext(() => authGuard(...guardParameters));
 
-  // Vitest's `Mocked` utility type ensures the stub is type-safe
-  const authServiceStub: Mocked<AuthService> = {
-    //  Create a real signal to use as the mock value
-    currentUserSignal: signal(undefined),
-  } as unknown as Mocked<AuthService>;
+  const AuthServiceStub = vi.fn(class {
+    _currentUserSignal = signal<User | null | undefined>(undefined);
+    currentUserSignal = this._currentUserSignal.asReadonly();
+    getCurrentUser = vi.fn(() => {
+      let currentUser = { username: 'testuser' } as User;
+      this._currentUserSignal.set(currentUser);
+      return of(currentUser);
+    });
+    logout = vi.fn(() => {
+      this._currentUserSignal.set(null);
+    });
+  }) as unknown as { new(): AuthService };
 
   beforeEach(() => {
     TestBed.configureTestingModule({
       providers: [
-        { provide: AuthService, useValue: authServiceStub },
+        { provide: AuthService, useClass: AuthServiceStub },
       ],
     });
 
@@ -32,8 +41,9 @@ describe('authGuard', () => {
 
   it('should return true when currentUserSignal is null', () => {
     TestBed.runInInjectionContext(() => {
-      // Update the signal value directly
-      authServiceStub.currentUserSignal.set(null);
+      const authServiceStub = inject(AuthService);
+
+      authServiceStub.logout();
 
       const result = authGuard({} as any, {} as any);
       expect(result).toBe(true);
@@ -42,8 +52,9 @@ describe('authGuard', () => {
 
   it('should return false when currentUserSignal is not null', () => {
     TestBed.runInInjectionContext(() => {
-      // Update the signal value directly
-      authServiceStub.currentUserSignal.set({ username: 'testUser', email: '', token: '' });
+      const authServiceStub = inject(AuthService);
+
+      authServiceStub.getCurrentUser().subscribe();
 
       const result = authGuard({} as any, {} as any);
       expect(result).toBe(false);
diff --git a/src/app/auth/services/auth.service.spec.ts b/src/app/auth/services/auth.service.spec.ts
index fc553cd..0d724c0 100644
--- a/src/app/auth/services/auth.service.spec.ts
+++ b/src/app/auth/services/auth.service.spec.ts
@@ -130,6 +130,29 @@ describe('AuthService', () => {
       expect(thrownError!.message).toContain('email');
       expect(thrownError!.message).toContain('username');
     });
+
+    it('should format multiple messages for the same field', () => {
+      const errorResponse = { errors: { password: ['is too short', 'must include a number'] } };
+      let thrownError: Error | undefined;
+
+      service.register(registerModel).subscribe({ error: (err: Error) => (thrownError = err) });
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/users`);
+      req.flush(errorResponse, { status: 422, statusText: 'Unprocessable Entity' });
+
+      expect(thrownError!.message).toBe('<ul><li>password is too short, password must include a number</li></ul>');
+    });
+
+    it('should handle HTTP error without errors body gracefully', () => {
+      let thrownError: unknown;
+      service.register(registerModel).subscribe({ error: (err) => (thrownError = err) });
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/users`);
+      req.flush('Internal Server Error', { status: 500, statusText: 'Internal Server Error' });
+
+      expect(thrownError).toBeInstanceOf(Error);
+      expect((thrownError as Error).message).toContain('Internal Server Error');
+    });
   });
 
   describe('login()', () => {
@@ -206,7 +229,6 @@ describe('AuthService', () => {
 
   describe('getCurrentUser()', () => {
     it('should return null and set signal to null when no token in localStorage', () => {
-      localStorage.removeItem('token');
       let result: User | null | undefined;
 
       service.getCurrentUser().subscribe(user => (result = user));
@@ -296,7 +318,14 @@ describe('AuthService', () => {
     });
 
     it('should set currentUserSignal to null', () => {
-      service.currentUserSignal.set(mockUser);
+      // service.currentUserSignal.set(mockUser);
+      // set up current user
+      localStorage.setItem('token', 'existing-token');
+
+      service.getCurrentUser().subscribe();
+
+      const req = httpTesting.expectOne(`${environment.authUrl}/api/user`);
+      req.flush(mockUserResponse);
 
       service.logout();
 
diff --git a/src/app/auth/services/auth.service.ts b/src/app/auth/services/auth.service.ts
index 6ea0a02..7305192 100644
--- a/src/app/auth/services/auth.service.ts
+++ b/src/app/auth/services/auth.service.ts
@@ -8,7 +8,8 @@ import { ErrorResponse, LoginModel, RegisterModel, User, UserResponse } from '..
   providedIn: 'root',
 })
 export class AuthService {
-  currentUserSignal = signal<User | null | undefined>(undefined);
+  private readonly _currentUserSignal = signal<User | null | undefined>(undefined);
+  currentUserSignal = this._currentUserSignal.asReadonly();
   private readonly baseUrl = environment.authUrl;
   private readonly http = inject(HttpClient);
 
@@ -24,9 +25,8 @@ export class AuthService {
     ).pipe(
       map(response => response.user),
       tap(user => {
-        console.log('User registered successfully:', user);
         localStorage.setItem('token', user.token);
-        this.currentUserSignal.set(user);
+        this._currentUserSignal.set(user);
       }),
       catchError(this.handleError)
     );
@@ -41,22 +41,22 @@ export class AuthService {
       map(response => response.user),
       tap(user => {
         localStorage.setItem('token', user.token);
-        this.currentUserSignal.set(user);
+        this._currentUserSignal.set(user);
       }),
       catchError(this.handleError)
     );
   }
 
   getCurrentUser() {
-    if (localStorage.getItem('token') == null) {
-      this.currentUserSignal.set(null);
+    if (localStorage.getItem('token') === null) {
+      this._currentUserSignal.set(null);
       return of(null);
     }
 
     return this.http.get<UserResponse>(`${this.baseUrl}/api/user`).pipe(
       map(response => response.user),
       tap(user => {
-        this.currentUserSignal.set(user);
+        this._currentUserSignal.set(user);
       }),
       catchError(() => {
         this.logout();
@@ -67,16 +67,22 @@ export class AuthService {
 
   logout() {
     localStorage.removeItem('token');
-    this.currentUserSignal.set(null);
+    this._currentUserSignal.set(null);
   }
 
   private readonly handleError = (response: HttpErrorResponse) => {
     throw new Error(this.formatError(response));
-  }
+  };
 
   private formatError(response: HttpErrorResponse): string {
-    return '<ul>' + Object.entries((<ErrorResponse>response.error).errors)
-      .map(([key, messages]) => `<li>${key} ${messages.join(', ' + key + ' ')}</li>`)
-      .join("") + '</ul>';
+    const errors = (<ErrorResponse>response.error)?.errors;
+
+    if (errors && typeof errors === 'object' && !Array.isArray(errors) && Object.entries(errors).length) {
+      return '<ul>' + Object.entries(errors)
+        .map(([key, messages]) => `<li>${key} ${messages.join(', ' + key + ' ')}</li>`)
+        .join('') + '</ul>';
+    } else {
+      return response.message ?? 'An unknown error occurred';
+    }
   }
 }