@igniteui/angular-templates 21.1.1491 → 21.1.1500-rc.0

package/igx-ts/projects/side-nav-auth/files/src/app/authentication/services/services.spec.ts

@@ -5,66 +5,69 @@ import { take } from 'rxjs/operators';
 import { FacebookProvider } from '../providers/facebook-provider';
 import { GoogleProvider } from '../providers/google-provider';
 import { MicrosoftProvider } from '../providers/microsoft-provider';
-import { AuthenticationService } from './authentication.service';
-import { ExternalAuthProvider } from './external-auth-configs';
-import { ExternalAuthRedirectUrl, ExternalAuthService } from './external-auth.service';
-import { BackendInterceptor } from './fake-backend.service';
+import { Authentication } from './authentication';
+import { ExternalAuthProvider, AUTH_BASE_PATH } from './external-auth-configs';
+import { ExternalAuthRedirectUrl, ExternalAuth } from './external-auth';
+import { BackendInterceptor } from './fake-backend';
 import * as JWTUtil from './jwt-util';
 import { LocalStorageService } from './local-storage';
 import msKeys from './microsoft-keys';
-import { UserService } from './user.service';
+import { UserStore } from './user-store';
 
 describe('Services', () => {
 
+  afterEach(() => { vi.restoreAllMocks(); });
+
   describe('Authentication Service', () => {
     const MOCK_HTTP_CLIENT = {
       post: () => { }
     } as any;
 
-    const authServ = new AuthenticationService(MOCK_HTTP_CLIENT);
+    const authServ = new Authentication(MOCK_HTTP_CLIENT);
     it('Should properly initialize', async () => {
       expect(authServ).toBeDefined();
     });
     it(`Should properly call 'login'`, async () => {
-      const loginPostSpy = spyOn<any>(authServ, 'loginPost').and.returnValue(Promise.resolve());
+      const loginPostSpy = vi.spyOn(authServ as any, 'loginPost').mockResolvedValue(undefined);
       const dummyData = { email: 'Dummy', password: 'Data' };
       await authServ.login(dummyData);
       expect(loginPostSpy).toHaveBeenCalled();
       expect(loginPostSpy).toHaveBeenCalledWith('/login', dummyData);
     });
     it(`Should properly call 'register'`, async () => {
-      const loginPostSpy = spyOn<any>(authServ, 'loginPost').and.returnValue(Promise.resolve());
+      const loginPostSpy = vi.spyOn(authServ as any, 'loginPost').mockResolvedValue(undefined);
       const dummyData = { given_name: 'Testy', family_name: 'Testington', email: 'Dummy', password: 'Data' };
       await authServ.register(dummyData);
       expect(loginPostSpy).toHaveBeenCalled();
       expect(loginPostSpy).toHaveBeenCalledWith('/register', dummyData);
     });
     it(`Should properly call 'loginWith'`, async () => {
-      const loginPostSpy = spyOn<any>(authServ, 'loginPost').and.returnValue(Promise.resolve());
+      const loginPostSpy = vi.spyOn(authServ as any, 'loginPost').mockResolvedValue(undefined);
       const dummyData = { id: 'Test', name: 'Testy', email: 'Dummy', externalToken: 'Data' };
       await authServ.loginWith(dummyData);
       expect(loginPostSpy).toHaveBeenCalled();
       expect(loginPostSpy).toHaveBeenCalledWith('/extlogin', dummyData);
     });
     it(`Should properly call 'loginPost'`, async () => {
-      const loginPostSpy = spyOn<any>(authServ, 'loginPost').and.callThrough();
+      const loginPostSpy = vi.spyOn(authServ as any, 'loginPost');
       const dummyData = { email: 'Dummy', password: 'Data' };
+      const mockUser = { name: 'Test User', email: 'Dummy' };
+      const mockToken = `${JWTUtil.encodeBase64Url({ alg: 'Mock', typ: 'JWT' })}.${JWTUtil.encodeBase64Url(mockUser)}.mockSignature`;
       const mockObs = { toPromise: () => { } };
-      spyOn(mockObs, 'toPromise').and.returnValue('TEST DATA' as any);
-      spyOn(MOCK_HTTP_CLIENT, 'post').and.returnValue(mockObs);
-      const parseSpy = spyOn(JWTUtil, 'parseUser').and.returnValue({ user: 'Test' } as any);
-      await authServ.login(dummyData);
+      vi.spyOn(mockObs, 'toPromise').mockReturnValue(mockToken as any);
+      vi.spyOn(MOCK_HTTP_CLIENT, 'post').mockReturnValue(mockObs);
+      const result = await authServ.login(dummyData);
       expect(loginPostSpy).toHaveBeenCalledWith('/login', dummyData);
       expect(MOCK_HTTP_CLIENT.post).toHaveBeenCalledWith('/login', dummyData);
-      expect(parseSpy).toHaveBeenCalledWith('TEST DATA');
+      expect(result).toEqual({ user: { ...mockUser, token: mockToken } });
     });
     it(`Should properly call 'loginPost' and throw error`, async () => {
       const dummyData = { email: 'Dummy', password: 'Data' };
       const mockObs = { toPromise: () => { } };
-      spyOn(mockObs, 'toPromise').and.callFake(() => {
+      vi.spyOn(mockObs, 'toPromise').mockImplementation(() => {
         throw new Error('Test Error');
       });
-      spyOn(MOCK_HTTP_CLIENT, 'post').and.returnValue(mockObs);
+      vi.spyOn(MOCK_HTTP_CLIENT, 'post').mockReturnValue(mockObs);
       expect(await (authServ as any).loginPost(dummyData)).toEqual({ error: 'Test Error' });
       expect(MOCK_HTTP_CLIENT.post).toHaveBeenCalled();
     });
@@ -72,24 +75,23 @@ describe('Services', () => {
 
   describe('External Authentication Service', () => {
     const MOCK_OIDC_SECURITY = {} as any;
-    const MOCK_OIDC_CONFIG = {} as any;
     const MOCK_ROUTER = {} as any;
     const MOCK_LOCATION = {
       prepareExternalUrl: () => { }
     } as any;
 
     const localStorage = new LocalStorageService(PLATFORM_ID);
-    const extAuthServ = new ExternalAuthService(MOCK_ROUTER, MOCK_OIDC_SECURITY, MOCK_OIDC_CONFIG, MOCK_LOCATION, localStorage);
+    const extAuthServ = new ExternalAuth(MOCK_ROUTER, MOCK_OIDC_SECURITY, MOCK_LOCATION, localStorage);
     it(`Should properly initialize`, () => {
       expect(extAuthServ).toBeDefined();
     });
     it(`Should properly get/set 'activeProvider'`, () => {
-      spyOn(localStorage, 'getItem').and.returnValue('test');
+      vi.spyOn(localStorage, 'getItem').mockReturnValue('test');
       const testProvider = extAuthServ.activeProvider;
       expect(localStorage.getItem).toHaveBeenCalled();
       expect(localStorage.getItem).toHaveBeenCalledWith('extActiveProvider');
       expect(testProvider).toEqual('test');
-      spyOn(localStorage, 'setItem');
+      vi.spyOn(localStorage, 'setItem');
       extAuthServ.activeProvider = 'ccc' as any;
       expect(localStorage.setItem).toHaveBeenCalled();
       expect(localStorage.setItem).toHaveBeenCalledWith('extActiveProvider', 'ccc');
@@ -106,31 +108,18 @@ describe('Services', () => {
     });
 
     it(`Should properly call 'addGoogle'`, () => {
-      const providersSpy = spyOn<any>((extAuthServ as any).providers, 'set');
-      spyOn<any>(extAuthServ, 'getAbsoluteUrl').and.returnValue('testUrl');
-      const configParams = {
-        provider: ExternalAuthProvider.Google,
-        stsServer: 'https://accounts.google.com',
-        client_id: 'test',
-        scope: 'openid email profile',
-        redirect_url: 'testUrl',
-        response_type: 'id_token token',
-        post_logout_redirect_uri: '/',
-        post_login_route: 'redirect',
-        auto_userinfo: false,
-        max_id_token_iat_offset_allowed_in_seconds: 30
-      };
-      extAuthServ.addGoogle('test');
+      const providersSpy = vi.spyOn((extAuthServ as any).providers, 'set');
+      extAuthServ.addGoogle();
       expect(providersSpy).toHaveBeenCalled();
       expect(providersSpy).toHaveBeenCalledWith('Google',
-        new GoogleProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, configParams));
+        new GoogleProvider(MOCK_OIDC_SECURITY, ExternalAuthProvider.Google));
     });
 
     it(`Should properly call 'addFacebook'`, () => {
-      const providersSpy = spyOn<any>((extAuthServ as any).providers, 'set');
+      const providersSpy = vi.spyOn((extAuthServ as any).providers, 'set');
       const configParams = {
         client_id: 'test',
-        redirect_url: ExternalAuthRedirectUrl.Facebook
+        redirect_url: `/${AUTH_BASE_PATH}/${ExternalAuthRedirectUrl.Facebook}`
       } as any;
       extAuthServ.addFacebook('test');
       expect(providersSpy).toHaveBeenCalled();
@@ -139,24 +128,11 @@ describe('Services', () => {
     });
 
     it(`Should properly call 'addMicrosoft'`, () => {
-      const providersSpy = spyOn<any>((extAuthServ as any).providers, 'set');
-      spyOn<any>(extAuthServ, 'getAbsoluteUrl').and.returnValue('testUrl');
-      const configParams = {
-        provider: ExternalAuthProvider.Microsoft,
-        stsServer: 'https://login.microsoftonline.com/consumers/v2.0/',
-        client_id: 'test',
-        scope: 'openid email profile',
-        redirect_url: 'testUrl',
-        response_type: 'id_token token',
-        post_logout_redirect_uri: '/',
-        post_login_route: '',
-        auto_userinfo: false,
-        max_id_token_iat_offset_allowed_in_seconds: 1000
-      } as any;
-      extAuthServ.addMicrosoft('test');
+      const providersSpy = vi.spyOn((extAuthServ as any).providers, 'set');
+      extAuthServ.addMicrosoft();
       expect(providersSpy).toHaveBeenCalled();
       expect(providersSpy).toHaveBeenCalledWith('Microsoft',
-        new MicrosoftProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, configParams));
+        new MicrosoftProvider(MOCK_OIDC_SECURITY, ExternalAuthProvider.Microsoft));
     });
 
     it(`Should properly call 'getUserInfo'`, async () => {
@@ -166,14 +142,13 @@ describe('Services', () => {
           return { name: 'test' };
         }
       };
-      spyOn(mockObj, 'getUserInfo').and.callThrough();
-      const providersGetSpy = spyOn(providersMap, 'get').and.returnValue(false);
+      vi.spyOn(mockObj, 'getUserInfo');
+      const providersGetSpy = vi.spyOn(providersMap, 'get').mockReturnValue(false as any);
       providersMap.set(ExternalAuthProvider.Facebook, mockObj);
       (extAuthServ as any).providers = providersMap;
-      spyOn(Promise, 'reject').and.returnValue(Promise.resolve(null));
-      expect(await extAuthServ.getUserInfo(ExternalAuthProvider.Facebook)).toBeNull();
+      await expect(extAuthServ.getUserInfo(ExternalAuthProvider.Facebook)).rejects.toBeNull();
       expect(providersGetSpy).toHaveBeenCalledTimes(1);
-      providersGetSpy.and.returnValue(mockObj);
+      providersGetSpy.mockReturnValue(mockObj as any);
       expect(await extAuthServ.getUserInfo(ExternalAuthProvider.Facebook)).toEqual({
         name: 'test',
         externalProvider: ExternalAuthProvider.Facebook
@@ -186,15 +161,15 @@ describe('Services', () => {
       const mockObj = {
         login: () => { }
       } as any;
-      spyOn(mockObj, 'login');
-      const providersGetSpy = spyOn(providersMap, 'get').and.returnValue(false);
+      vi.spyOn(mockObj, 'login');
+      const providersGetSpy = vi.spyOn(providersMap, 'get').mockReturnValue(false as any);
       providersMap.set(ExternalAuthProvider.Facebook, mockObj);
       (extAuthServ as any).providers = providersMap;
-      const setActiveProvider = spyOnProperty(extAuthServ, 'activeProvider', 'set');
+      const setActiveProvider = vi.spyOn(extAuthServ, 'activeProvider', 'set');
       extAuthServ.login(ExternalAuthProvider.Facebook);
       expect(mockObj.login).not.toHaveBeenCalled();
       expect(setActiveProvider).not.toHaveBeenCalled();
-      providersGetSpy.and.returnValue(mockObj);
+      providersGetSpy.mockReturnValue(mockObj);
       extAuthServ.login(ExternalAuthProvider.Facebook);
       expect(mockObj.login).toHaveBeenCalled();
       expect(setActiveProvider).toHaveBeenCalledWith(ExternalAuthProvider.Facebook);
@@ -205,16 +180,16 @@ describe('Services', () => {
       const mockObj = {
         logout: () => { }
       } as any;
-      spyOn(mockObj, 'logout');
+      vi.spyOn(mockObj, 'logout');
       providersMap.set(ExternalAuthProvider.Facebook, mockObj);
-      spyOn(providersMap, 'get').and.returnValue(mockObj);
+      vi.spyOn(providersMap, 'get').mockReturnValue(mockObj);
       (extAuthServ as any).providers = providersMap;
-      const setActiveProviderSpy = spyOnProperty(extAuthServ, 'activeProvider', 'get').and.returnValue(false);
+      const setActiveProviderSpy = vi.spyOn(extAuthServ, 'activeProvider', 'get').mockReturnValue(false as any);
       extAuthServ.logout();
       expect(mockObj.logout).not.toHaveBeenCalled();
       expect(providersMap.get).not.toHaveBeenCalled();
       expect(setActiveProviderSpy).toHaveBeenCalledTimes(1);
-      setActiveProviderSpy.and.returnValue('MOCK TOKEN');
+      setActiveProviderSpy.mockReturnValue('MOCK TOKEN' as any);
       extAuthServ.logout();
       expect(mockObj.logout).toHaveBeenCalled();
       expect(providersMap.get).toHaveBeenCalled();
@@ -224,7 +199,7 @@ describe('Services', () => {
 
     it(`Should properly call 'getAbsoluteUrl'`, () => {
       const currentOrigin = window.location.origin;
-      spyOn(MOCK_LOCATION, 'prepareExternalUrl').and.returnValue('test_href_2');
+      vi.spyOn(MOCK_LOCATION, 'prepareExternalUrl').mockReturnValue('test_href_2');
       expect((extAuthServ as any).getAbsoluteUrl('mock_path')).toEqual(`${currentOrigin}test_href_2`);
       expect(MOCK_LOCATION.prepareExternalUrl).toHaveBeenCalledWith('mock_path');
     });
@@ -247,9 +222,9 @@ describe('Services', () => {
         // endpoint /login
 
         // mocked method in intercept still need to return observable, otherwise rxjs pipe throws
-        spyOn(provider, 'loginHandle').and.returnValue(new Observable());
-        spyOn(JSON, 'parse').and.returnValue(mockUsers);
-        spyOn(mockLocalStorage, 'getItem').and.returnValue('[]');
+        vi.spyOn(provider, 'loginHandle').mockReturnValue(new Observable());
+        vi.spyOn(JSON, 'parse').mockReturnValue(mockUsers);
+        vi.spyOn(mockLocalStorage, 'getItem').mockReturnValue('[]');
         provider.intercept(mockRequest, mockNext).pipe(take(1)).subscribe(() => { });
         expect(JSON.parse).toHaveBeenCalledWith('[]');
         expect(JSON.parse).toHaveBeenCalledTimes(1);
@@ -257,8 +232,8 @@ describe('Services', () => {
         expect(provider.loginHandle).toHaveBeenCalledTimes(1);
         // endpoint /register
         mockRequest.url = '/register';
-        const getStorageUserSpy = spyOn<any>(provider, 'getStorageUser').and.returnValue({ name: 'Mock user' });
-        spyOn(provider, 'registerHandle').and.returnValue(new Observable());
+        const getStorageUserSpy = vi.spyOn(provider as any, 'getStorageUser').mockReturnValue({ name: 'Mock user' });
+        vi.spyOn(provider, 'registerHandle').mockReturnValue(new Observable());
         provider.intercept(mockRequest, mockNext).pipe(take(1)).subscribe(() => { });
         expect(JSON.parse).toHaveBeenCalledTimes(2);
         expect(getStorageUserSpy).toHaveBeenCalledWith(mockRequest);
@@ -267,7 +242,7 @@ describe('Services', () => {
         expect(provider.registerHandle).toHaveBeenCalledTimes(1);
         // endpoint /register
         mockRequest.url = '/extlogin';
-        const getStorageExtUserSpy = spyOn<any>(provider, 'getStorageExtUser').and.returnValue({ name: 'Mock user' });
+        const getStorageExtUserSpy = vi.spyOn(provider as any, 'getStorageExtUser').mockReturnValue({ name: 'Mock user' });
         provider.intercept(mockRequest, mockNext).pipe(take(1)).subscribe(() => { });
         expect(JSON.parse).toHaveBeenCalledTimes(3);
         expect(getStorageExtUserSpy).toHaveBeenCalledWith(mockRequest);
@@ -289,7 +264,7 @@ describe('Services', () => {
         // no intercept scenario
         mockRequest.method = 'POST';
         mockRequest.url = '/test';
-        spyOn(mockNext, 'handle').and.callThrough();
+        vi.spyOn(mockNext, 'handle');
         provider.intercept(mockRequest, mockNext).pipe(take(1)).subscribe(() => { });
         expect(mockNext.handle).toHaveBeenCalledWith(mockRequest);
         expect(mockNext.handle).toHaveBeenCalledTimes(1);
@@ -323,10 +298,10 @@ describe('Services', () => {
         provider.registerHandle(mockUser, false).pipe(take(1)).subscribe(() => { }, (e) => { output = e; });
         expect(output).toEqual(expectedOutput);
 
-        spyOn(localStorage, 'setItem');
-        spyOn(JSON, 'stringify').and.returnValue('MOCK OBJ');
-        const generateBodySpy = spyOn<any>(provider, 'getUserJWT').and.returnValue('MOCK BODY');
-        const tokenSpy = spyOn<any>(provider, 'generateToken').and.returnValue('MOCK TOKEN');
+        vi.spyOn(localStorage, 'setItem');
+        vi.spyOn(JSON, 'stringify').mockReturnValue('MOCK OBJ');
+        const generateBodySpy = vi.spyOn(provider as any, 'getUserJWT').mockReturnValue('MOCK BODY');
+        const tokenSpy = vi.spyOn(provider as any, 'generateToken').mockReturnValue('MOCK TOKEN');
         expectedOutput = new HttpResponse({ status: 200, body: 'MOCK TOKEN' });
         provider.registerHandle({ email: 'test_user', customProp: 'very_custom ' } as any, true)
           .pipe(take(1)).subscribe((e) => { output = e; });
@@ -369,9 +344,9 @@ describe('Services', () => {
             email: 'test_email'
           }
         } as any;
-        spyOn(Array.prototype, 'find').and.callThrough();
-        const jwtSpy = spyOn<any>(provider, 'getUserJWT').and.returnValue('MOCK BODY');
-        const tokenSpy = spyOn<any>(provider, 'generateToken').and.returnValue('MOCK TOKEN');
+        vi.spyOn(Array.prototype, 'find');
+        const jwtSpy = vi.spyOn(provider as any, 'getUserJWT').mockReturnValue('MOCK BODY');
+        const tokenSpy = vi.spyOn(provider as any, 'generateToken').mockReturnValue('MOCK TOKEN');
         const expectedOutput = new HttpResponse({ status: 200, body: 'MOCK TOKEN' });
         provider.loginHandle(mockRequest).pipe(take(1)).subscribe((e) => {
           expect(e).toEqual(expectedOutput);
@@ -444,8 +419,8 @@ describe('Services', () => {
           email: 'test_email',
           picture: 'test_picture'
         };
-        spyOn(Math, 'floor').and.returnValue(1000);
-        spyOn(Date.prototype, 'getTime').and.returnValue(1000);
+        vi.spyOn(Math, 'floor').mockReturnValue(1000);
+        vi.spyOn(Date.prototype, 'getTime').mockReturnValue(1000);
         const expectedExp = 1000 + (7 * 24 * 60 * 60);
         expect((provider as any).getUserJWT(mockInput)).toEqual({
           exp: expectedExp,
@@ -462,8 +437,7 @@ describe('Services', () => {
       it(`Should properly call 'generateToken'`, () => {
         const provider = new BackendInterceptor(new LocalStorageService({}));
         const inputString = 'testString1';
-        const expectedOutput = 'g.g.mockSignature';
-        spyOn(JWTUtil, 'encodeBase64Url').and.returnValue('g');
+        const expectedOutput = `${JWTUtil.encodeBase64Url({ alg: 'Mock', typ: 'JWT' })}.${JWTUtil.encodeBase64Url(inputString)}.mockSignature`;
         expect((provider as any).generateToken(inputString)).toEqual(expectedOutput);
       });
     });
@@ -483,12 +457,12 @@ describe('Services', () => {
     const localStorage = new LocalStorageService(PLATFORM_ID);
 
     beforeEach(() => {
-      spyOn(JSON, 'parse').and.returnValue(mockUser);
-      spyOn(localStorage, 'getItem').and.returnValue('MOCK JSON');
+      vi.spyOn(JSON, 'parse').mockReturnValue(mockUser);
+      vi.spyOn(localStorage, 'getItem').mockReturnValue('MOCK JSON');
     });
 
     it(`Should properly initialize`, () => {
-      const userServ = new UserService(localStorage);
+      const userServ = new UserStore(localStorage);
       expect(userServ).toBeDefined();
       expect(localStorage.getItem).toHaveBeenCalledWith('currentUser');
       expect(JSON.parse).toHaveBeenCalledWith('MOCK JSON');
@@ -497,25 +471,25 @@ describe('Services', () => {
     });
 
     it(`Should properly get 'initials'`, () => {
-      const userServ = new UserService(localStorage);
-      const currentUserSpy = spyOnProperty(userServ, 'currentUser', 'get').and.returnValue(null);
+      const userServ = new UserStore(localStorage);
+      const currentUserSpy = vi.spyOn(userServ, 'currentUser', 'get').mockReturnValue(null as any);
       expect(userServ.initials).toEqual(null);
-      currentUserSpy.and.returnValue({ given_name: '' });
+      currentUserSpy.mockReturnValue({ given_name: '' } as any);
       expect(userServ.initials).toEqual('');
-      currentUserSpy.and.returnValue({ given_name: '', family_name: '' });
+      currentUserSpy.mockReturnValue({ given_name: '', family_name: '' } as any);
       expect(userServ.initials).toEqual('');
-      currentUserSpy.and.returnValue({ given_name: '', family_name: 'g' });
+      currentUserSpy.mockReturnValue({ given_name: '', family_name: 'g' } as any);
       expect(userServ.initials).toEqual('g');
-      currentUserSpy.and.returnValue({ given_name: 'h3ll0' });
+      currentUserSpy.mockReturnValue({ given_name: 'h3ll0' } as any);
       expect(userServ.initials).toEqual('h');
-      currentUserSpy.and.returnValue({ given_name: 'h3ll0', family_name: 'g' });
+      currentUserSpy.mockReturnValue({ given_name: 'h3ll0', family_name: 'g' } as any);
       expect(userServ.initials).toEqual('hg');
-      currentUserSpy.and.returnValue({ given_name: 'h3ll0', family_name: '' });
+      currentUserSpy.mockReturnValue({ given_name: 'h3ll0', family_name: '' } as any);
       expect(userServ.initials).toEqual('h');
     });
 
     it(`Should properly 'setCurrentUser'`, () => {
-      const userServ = new UserService(localStorage);
+      const userServ = new UserStore(localStorage);
       const mockUser2 = {
         exp: 111,
         name: 'Qually T',
@@ -526,8 +500,8 @@ describe('Services', () => {
         token: `mock token`,
         externalToken: `mock token 2`
       };
-      spyOn(JSON, 'stringify').and.returnValue('MOCK STRING');
-      spyOn(localStorage, 'setItem');
+      vi.spyOn(JSON, 'stringify').mockReturnValue('MOCK STRING');
+      vi.spyOn(localStorage, 'setItem');
       userServ.setCurrentUser(mockUser2);
       expect(userServ.currentUser).toEqual(mockUser2);
       expect(JSON.stringify).toHaveBeenCalledWith(mockUser2);
@@ -537,8 +511,8 @@ describe('Services', () => {
     });
 
     it(`Should properly call 'clearCurrentUser'`, () => {
-      const userServ = new UserService(localStorage);
-      spyOn(localStorage, 'removeItem');
+      const userServ = new UserStore(localStorage);
+      vi.spyOn(localStorage, 'removeItem');
       expect(userServ.currentUser).toBeTruthy();
       userServ.clearCurrentUser();
       expect(localStorage.removeItem).toHaveBeenCalledWith('currentUser');

package/igx-ts/projects/side-nav-auth/files/src/app/authentication/services/user-store.ts

@@ -0,0 +1,63 @@
+import { Injectable, isDevMode } from '@angular/core';
+import { User } from '../models/user';
+import { LocalStorageService } from './local-storage';
+
+const USER_TOKEN = 'currentUser';
+
+/**
+ * Service used to store and provide the current logged in user in the app.
+ *
+ * **NOTE**: Keep in mind using local storage can be susceptible to XSS attacks.
+ * Consider not storing the User on the client storage if the app requirements allow,
+ * adding a fingerprint to the JWT claims that is sent with a secure cookie,
+ * or other security measures.
+ */
+@Injectable({
+  providedIn: 'root'
+})
+export class UserStore {
+  private _currentUser: User | null;
+  /** Current logged in user, if any */
+  public get currentUser() { return this._currentUser; }
+
+  /** Initials of the current user, if any */
+  public get initials(): string | null {
+    if (!this.currentUser) {
+      return null;
+    }
+    let initials = this.currentUser.given_name.substr(0, 1);
+    if (this.currentUser.family_name) {
+      initials += this.currentUser.family_name.substr(0, 1);
+    }
+    return initials;
+  }
+
+  constructor(private localStorage: LocalStorageService) {
+    const storedUser = this.localStorage.getItem(USER_TOKEN);
+    if (storedUser && storedUser !== 'undefined') {
+      try {
+        this._currentUser = JSON.parse(storedUser);
+      } catch {
+        // Malformed JSON in storage; clear it and fall back to no current user.
+        this._currentUser = null;
+        this.localStorage.removeItem(USER_TOKEN);
+      }
+    } else {
+      this._currentUser = null;
+    }
+  }
+
+  /** Save new login as current user */
+  public setCurrentUser(user: User) {
+    if (isDevMode()) {
+      this.localStorage.setItem(USER_TOKEN, JSON.stringify(user));
+    }
+    this._currentUser = user;
+  }
+
+  /** Clear current user */
+  public clearCurrentUser() {
+    this._currentUser = null;
+    this.localStorage.removeItem(USER_TOKEN);
+  }
+}

package/igx-ts/projects/side-nav-auth/files/src/index.html

@@ -1,22 +1,16 @@
 <!doctype html>
 <html lang="en">
-
-<head>
-  <meta charset="utf-8">
-  <title>Ignite UI for Angular</title>
-  <base href="/" />
-
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <link rel="icon" type="image/x-icon" href="favicon.ico">
-
-  <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
-  <link href="https://fonts.googleapis.com/css?family=Titillium+Web:300,400,600,700" rel="stylesheet">
-
-  <script src="https://connect.facebook.net/en_US/sdk.js"></script>
-</head>
-
-<body class="ig-typography ig-scrollbar">
-  <app-root></app-root>
-</body>
-
+  <head>
+    <meta charset="utf-8">
+    <title>Ignite UI for Angular</title>
+    <base href="/" />
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <link rel="icon" type="image/x-icon" href="favicon.ico">
+    <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
+    <link href="https://fonts.googleapis.com/css?family=Titillium+Web:300,400,600,700" rel="stylesheet">
+    <script src="https://connect.facebook.net/en_US/sdk.js"></script>
+  </head>
+  <body class="ig-typography ig-scrollbar">
+    <app-root></app-root>
+  </body>
 </html>

package/igx-ts/projects/side-nav-auth/files/tsconfig.app.json

@@ -1,4 +1,5 @@
-/* To learn more about this file see: https://angular.io/config/tsconfig. */
+/* To learn more about Typescript configuration file: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html. */
+/* To learn more about Angular compiler options: https://angular.dev/reference/configs/angular-compiler-options. */
 {
   "extends": "./tsconfig.json",
   "compilerOptions": {
@@ -12,10 +13,12 @@
     ]
   },
   "files": [
-    "src/main.ts",
-    "src/polyfills.ts"
+    "src/main.ts"
   ],
   "include": [
     "src/**/*.d.ts"
+  ],
+  "exclude": [
+    "src/**/*.spec.ts"
   ]
 }

package/igx-ts/projects/side-nav-auth/files/tsconfig.spec.json

@@ -1,20 +1,18 @@
-/* To learn more about this file see: https://angular.io/config/tsconfig. */
+/* To learn more about Typescript configuration file: https://www.typescriptlang.org/docs/handbook/tsconfig-json.html. */
+/* To learn more about Angular compiler options: https://angular.dev/reference/configs/angular-compiler-options. */
 {
   "extends": "./tsconfig.json",
   "compilerOptions": {
     "outDir": "./out-tsc/spec",
     "types": [
-      "jasmine",
+      "vitest/globals",
       "node",
       "facebook-js-sdk"
     ],
-    "module": "commonjs"
+    "module": "esnext"
   },
-  "files": [
-    "src/polyfills.ts"
-  ],
   "include": [
-    "src/**/*.spec.ts",
-    "src/**/*.d.ts"
+    "src/**/*.d.ts",
+    "src/**/*.spec.ts"
   ]
 }

package/igx-ts/radial-gauge/default/files/src/app/__path__/__filePrefix__.spec.ts

@@ -0,0 +1,27 @@
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { IgxRadialGaugeModule } from 'igniteui-angular-gauges';
+import { <%=ClassName%> } from './<%=filePrefix%>';
+
+describe('<%=ClassName%>', () => {
+  let component: <%=ClassName%>;
+  let fixture: ComponentFixture<<%=ClassName%>>;
+
+  beforeEach(async () => {
+    await TestBed.configureTestingModule({
+	  imports: [IgxRadialGaugeModule, <%=ClassName%>]
+    })
+      .compileComponents();
+  });
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(<%=ClassName%>);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+    // disable animation
+    component.radialGauge.transitionDuration = 0;
+  });
+});