@unipin/angular-applet 18.9.2 → 18.9.4

package/projects/unipin-angular/src/lib/modules/micro-frontend/utils/mf-bootstrap.util.ts

@@ -0,0 +1,74 @@
+import { ApplicationConfig, enableProdMode, Injector, NgZone, Type } from '@angular/core';
+import { Location } from '@angular/common';
+import { Router } from '@angular/router';
+import { bootstrapApplication, createApplication } from '@angular/platform-browser';
+import { getGlobalStateSlice, setGlobalStateSlice } from './mf-global-state.util';
+import { createCustomElement } from '@angular/elements';
+
+export type AppType = 'shell' | 'microfrontend';
+
+export type Options = {
+  production: boolean;
+  appType: AppType;
+  elementName?: string;
+};
+
+function getNgZone(): NgZone{
+  return (getGlobalStateSlice((state: { ngZone: NgZone }) => state.ngZone));
+}
+
+export function shareNgZone(zone: NgZone): void{
+  setGlobalStateSlice({ ngZone: zone });
+}
+
+export function bootstrap<M>(component: Type<M>, options: Options, config: ApplicationConfig): void{
+  options.production && enableProdMode();
+
+  if (options.appType === 'shell') {
+    bootstrapApplication(component, config).then((ref) => {
+      shareShellZone(ref.injector);
+    });
+    return;
+  }
+
+  if (!getNgZone() && isLocalhost()) {
+    bootstrapApplication(component, config).then((ref) => {
+      connectMicroFrontendRouter(ref.injector);
+    });
+    return;
+  }
+  
+  (async () => {
+    config.providers.push({ provide: NgZone, useValue: getNgZone() });
+
+    const app = await createApplication(config);
+    customElements.define(<string> options.elementName, createCustomElement(component, { injector: app.injector }));
+
+    connectMicroFrontendRouter(app.injector);
+  })();
+}
+
+function shareShellZone(injector: Injector): void{
+  const ngZone = injector.get(NgZone, null);
+  if (!ngZone) {
+    console.warn('No NgZone to share found');
+    return;
+  }
+  shareNgZone(ngZone);
+}
+
+function connectMicroFrontendRouter(injector: Injector): void{
+  const router = injector.get(Router);
+  const location = injector.get(Location);
+
+  if (!router) {
+    console.warn('No router to connect found');
+    return;
+  }
+  router.navigateByUrl(location.path() + window.location.hash);
+}
+
+function isLocalhost(): boolean{
+  const hostname = window.location.hostname;
+  return hostname === 'localhost' || hostname === '127.0.0.1';
+}

package/projects/unipin-angular/src/lib/modules/micro-frontend/utils/mf-global-state.util.ts

@@ -0,0 +1,20 @@
+export const packageNamespace = '@angular-architects/module-federation-tools';
+
+function getGlobalState<T>(): T {
+  const globalState = window as unknown as { [packageNamespace]: T };
+  globalState[packageNamespace] = globalState[packageNamespace] || ({} as unknown as T);
+  
+  return globalState[packageNamespace];
+}
+
+export function getGlobalStateSlice<T>(): T;
+export function getGlobalStateSlice<T, R>(selector: (globalState: T) => R): R;
+
+export function getGlobalStateSlice<T, R>(selector?: (globalState: T) => R): R | T {
+  const globalState = getGlobalState<T>();
+  return selector? selector(globalState) : globalState;
+}
+
+export function setGlobalStateSlice<T extends object>(slice: T): T {
+  return Object.assign(getGlobalState<T>(), slice);
+}

package/projects/unipin-angular/src/lib/modules/permission/directive/permission.directive.spec.ts

@@ -0,0 +1,50 @@
+import { Component } from '@angular/core';
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { By } from '@angular/platform-browser';
+import { Apollo } from 'apollo-angular';
+import { PermissionDirective } from './permission.directive';
+import { PermissionService } from '../services/permission.service';
+
+@Component({
+  template: `
+    <div *hasPermission="'MEMBER'; scope: 'GLOBAL'; type: 'ADMIN'">Content</div>
+    <span *hasPermission="'JOB'; scope: 'GLOBAL'; type: 'ADMIN'">Content</span>
+  `,
+  imports: [PermissionDirective]
+})
+class TestComponent {}
+
+describe('PermissionDirective', () => {
+    let fixture: ComponentFixture<TestComponent>;
+    let component: TestComponent;
+    let permissionService: PermissionService; 
+
+    beforeEach(() => {
+      TestBed.configureTestingModule({
+        declarations: [PermissionDirective, TestComponent],
+        providers: [
+          PermissionService,
+          { provide: Apollo },
+        ],
+      });
+
+      permissionService = TestBed.inject(PermissionService);
+      fixture = TestBed.createComponent(TestComponent);
+      component = fixture.componentInstance;
+
+      permissionService.setPermission([ 'GLOBAL.MEMBER.ADMIN' ], [ 'MEMBER' ])
+      fixture.detectChanges();
+    });
+  
+    it('should create the component', () => expect(component).toBeTruthy());
+  
+    it('should display content when permission is granted', () => {
+      const dynamicViewElement =  fixture.debugElement.query(By.css('div'));
+      expect(dynamicViewElement).toBeDefined();
+    });
+  
+    it('should not display content when permission is denied', () => {
+      const dynamicViewElement =  fixture.debugElement.query(By.css('span'));
+      expect(dynamicViewElement).toBeNull();
+    });
+  });

package/projects/unipin-angular/src/lib/modules/permission/directive/permission.directive.ts

@@ -0,0 +1,68 @@
+import { Directive, Input, TemplateRef, ViewContainerRef } from '@angular/core';
+import { PermissionService } from '../services/permission.service';
+
+/**
+ * The `PermissionDirective` is a directive that conditionally renders content based on user permissions.
+ * `Scope` param is default to `GLOBAL`
+ * @selector '[hasPermission]'
+ * @example
+ * ```html
+ * <div *hasPermission="'POST_AUDIT'; type: 'READ'; scope: 'MERCHANT'"></div>
+ * ```
+ */
+@Directive({
+  standalone: true,
+  selector: '[hasPermission]'
+})
+export class PermissionDirective {
+  
+  /**
+   * The module name for which permissions are being checked.
+   * @type {string}
+   * @default {null}
+   */
+  protected module!: string;
+
+  /**
+   * The permission scope.
+   * @type {string}
+   * @default {'GLOBAL'}
+   */
+  protected scope: string = 'GLOBAL';
+
+  /**
+   * Sets the module name for which permissions are being checked.
+   * @example 'POST_AUDIT'.
+   * @param {string} m - The module name.
+   */
+  @Input() set hasPermission(m: string) {
+    this.module = m; 
+  }
+
+  /**
+   * Sets the permission scope. Default is 'GLOBAL'.
+   * @param {string} s - The permission scope.
+   */
+  @Input() set hasPermissionScope(s: string) { 
+    this.scope = s; 
+  }
+
+  /**
+   * Sets the permission type and conditionally renders content based on user permissions.
+   * @param {string} t - The permission type, e.g., 'READ', 'WRITE'.
+   */
+  @Input() set hasPermissionType(t: string) {;
+    if (this.permissionService.checkPermission(this.scope, this.module, t)) {
+      this.viewContainer.createEmbeddedView(this.templateRef);
+      return;
+    }
+
+    this.viewContainer.clear();
+  }
+
+  constructor(
+    protected readonly templateRef: TemplateRef<any>,
+    protected readonly viewContainer: ViewContainerRef,
+    protected readonly permissionService: PermissionService
+  ) { }
+}

package/projects/unipin-angular/src/lib/modules/permission/guards/permission.guard.spec.ts

@@ -0,0 +1,76 @@
+// import { ActivatedRouteSnapshot, Router } from '@angular/router';
+// import { Location } from '@angular/common';
+// import { PermissionService } from '../services/permission.service';
+// import { canActivate } from './permission.guard';
+
+describe('PermissionGuard', () => {
+//   let routerSpy: jasmine.SpyObj<Router>;
+//   let locationSpy: jasmine.SpyObj<Location>;
+//   let permissionServiceSpy: jasmine.SpyObj<PermissionService>;
+
+//   beforeEach(() => {
+//     routerSpy = jasmine.createSpyObj('Router', ['navigate']);
+//     locationSpy = jasmine.createSpyObj('Location', ['path']);
+//     permissionServiceSpy = jasmine.createSpyObj('PermissionService', ['isInitiated', 'checkPermission']);
+//   });
+
+//   it('should return true when permission is granted', () => {
+//     permissionServiceSpy.isInitiated = true;
+//     permissionServiceSpy.checkPermission.and.returnValue(true);
+  
+//     const result = canActivate(createActivatedRouteSnapshot('s', 'm', 't'), routerSpy, locationSpy, permissionServiceSpy);
+  
+//     expect(result).toBe(true);
+//     expect(routerSpy.navigate).not.toHaveBeenCalled();
+//   });
+  
+
+//   it('should return false and navigate to loading when not initiated', () => {
+//     permissionServiceSpy.isInitiated = false;
+  
+//     const result = canActivate(createActivatedRouteSnapshot('s', 'm', 't'), routerSpy, locationSpy, permissionServiceSpy);
+  
+//     expect(result).toBe(false);
+//     expect(routerSpy.navigate).toHaveBeenCalledWith(['loading'], { queryParams: { url: jasmine.any(String) } });
+//   });
+  
+//   it('should return false and navigate to 401 when permission is not granted', () => {
+//     permissionServiceSpy.isInitiated = true;
+//     permissionServiceSpy.checkPermission.and.returnValue(false);
+  
+//     const result = canActivate(createActivatedRouteSnapshot('s', 'm', 't'), routerSpy, locationSpy, permissionServiceSpy);
+  
+//     expect(result).toBe(false);
+//     expect(routerSpy.navigate).toHaveBeenCalledWith(['401']);
+//   });
+  
+//   function createActivatedRouteSnapshot(scope: string, module: string, type: string): ActivatedRouteSnapshot {
+//     return {
+//       data: { requiredPermission: { scope, module, type } },
+//       url: [],
+//       params: {},
+//       queryParams: {},
+//       fragment: null,
+//       outlet: '',
+//       component: null,
+//       routeConfig: null,
+//       title: undefined,
+//       root: new ActivatedRouteSnapshot,
+//       parent: null,
+//       firstChild: null,
+//       children: [],
+//       pathFromRoot: [],
+//       paramMap: createParamMap(),
+//       queryParamMap: createParamMap()
+//     } as ActivatedRouteSnapshot;
+//   }
+  
+//   function createParamMap(): any {
+//     return {
+//       has: () => false,
+//       get: () => null,
+//       getAll: () => [],
+//       keys: []
+//     };
+//   }
+});

package/projects/unipin-angular/src/lib/modules/permission/guards/permission.guard.ts

@@ -0,0 +1,30 @@
+import { inject } from '@angular/core';
+import { Location } from '@angular/common';
+import { ActivatedRouteSnapshot, CanActivateFn, Router } from '@angular/router';
+import { PermissionService } from '../services/permission.service';
+
+export const PermissionGuard: CanActivateFn = (route: ActivatedRouteSnapshot): boolean => {
+  
+  const router: Router = inject(Router);
+  const location: Location = inject(Location);
+  const permissionService: PermissionService = inject(PermissionService);
+
+  const permissions: { scope: string, module: string, type: string }[] = route.data['requiredPermissions'];
+  
+  if (!permissions || permissions.length === 0) throw new Error('Invalid config: requiredPermissions is a required parameter in route data for PermissionGuard');
+
+  if (!permissionService.isInitiated) {
+    router.navigate([ 'loading' ], { queryParams: { url: `${ location.path() + window.location.hash }` } });
+    return false;
+  }
+
+  if (permissions) {
+    for (let i = 0; i < permissions.length; i++) {
+      const { scope, module, type } = permissions[i];
+      if (permissionService.checkPermission(scope, module, type)) return true;
+    }
+  }
+
+  router.navigate([ '401' ]);
+  return false;
+};

package/{lib/modules/permission/index.d.ts → projects/unipin-angular/src/lib/modules/permission/index.ts}

@@ -1,5 +1,6 @@
 export { provideLoadingConfig, LoadingConfig } from './pages/loading/provide-loading-config.util';
 export { LoadingPage } from './pages/loading/loading.page';
+
 export { PermissionDirective } from './directive/permission.directive';
 export { PermissionGuard } from './guards/permission.guard';
 export { PermissionService } from './services/permission.service';

package/projects/unipin-angular/src/lib/modules/permission/pages/401/unauthorized.page.html

@@ -0,0 +1,3 @@
+<ion-icon name="lock-closed" class="mb-4" />
+<h3 class="text-center">Oops! You're not authorized to access this page.</h3>
+<p class="text-center">Please log in or re-check your permissions.</p>

package/projects/unipin-angular/src/lib/modules/permission/pages/401/unauthorized.page.scss

@@ -0,0 +1,3 @@
+ion-icon {
+  font-size: 5rem;
+}

package/projects/unipin-angular/src/lib/modules/permission/pages/401/unauthorized.page.ts

@@ -0,0 +1,14 @@
+import { Component } from '@angular/core';
+import { IonicModule } from '@ionic/angular';
+
+@Component({
+  standalone: true,
+  selector: 'up-unauthorized',
+  templateUrl: './unauthorized.page.html',
+  styleUrls: ['./unauthorized.page.scss'],
+  host: {
+    class: 'd-flex flex-column align-items-center justify-content-center h-100 w-75 mx-auto'
+  },
+  imports: [ IonicModule ]
+})
+export class UnauthorizedPage { }

package/projects/unipin-angular/src/lib/modules/permission/pages/loading/loading.page.html

@@ -0,0 +1,2 @@
+<ion-spinner class="mb-4" />
+<h3 class="text-center">Please wait, we're preparing the applet. Drink water or coffee while waiting.</h3>

package/projects/unipin-angular/src/lib/modules/permission/pages/loading/loading.page.scss

@@ -0,0 +1,4 @@
+ion-spinner {
+    height: 50px;
+    width: 50px;
+}

package/projects/unipin-angular/src/lib/modules/permission/pages/loading/loading.page.ts

@@ -0,0 +1,76 @@
+import { ChangeDetectionStrategy, Component, Inject, OnDestroy, OnInit } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { Subscription } from 'rxjs';
+import { IonicModule } from '@ionic/angular';
+import { PermissionService } from '../../services/permission.service';
+import { LOADING_CONFIG, LoadingConfig } from './provide-loading-config.util';
+
+@Component({
+  standalone: true,
+  selector: 'up-loading',
+  styleUrl: './loading.page.scss',
+  templateUrl: './loading.page.html',
+  changeDetection: ChangeDetectionStrategy.OnPush,
+  host: {
+    class: 'd-flex flex-column align-items-center justify-content-center h-100 w-75 mx-auto'
+  },
+  imports: [
+    IonicModule
+  ]
+})
+export class LoadingPage implements OnInit, OnDestroy {
+
+  protected sub?: Subscription;
+
+  constructor(
+    @Inject(LOADING_CONFIG) public readonly config: LoadingConfig,
+    protected readonly router: Router,
+    protected readonly route: ActivatedRoute,
+    protected readonly permissionService: PermissionService
+  ) { }
+
+  public ngOnInit(): void{
+    const subjectGuid = localStorage.getItem(this.config.subjectGuidStorageKey || 'userGuid');
+    if (!subjectGuid) {
+      this.router.navigate([ '401' ]);
+      return;
+    }
+
+    const permCodeList: string[] = [];
+		const permModuleList: Map<string, boolean> = new Map();;
+    
+    this.sub = this.permissionService.getPermissions({ 
+      subjectGuid, 
+      pageSize: 1000,
+      permType: this.config.permTypes,
+      permModule: this.config.permModules, 
+    }, this.config.fetchPolicy).subscribe({
+      error: () => {
+        this.router.navigate([ '401' ]);
+      },
+      next: ({ data: { authMsPermission: { data }}}) => {
+        data.forEach(({ permCode, permModule }) => {
+          if (!permCode || !permModule) return;
+
+          permCodeList.push(permCode);
+					if (!permModuleList.has(permModule)) {
+						permModuleList.set(permModule, true);
+					}
+        });
+
+        this.permissionService.isInitiated = true;
+        this.permissionService.setPermission(
+          permCodeList, 
+          Array.from(
+            permModuleList.keys()
+          )
+        );
+        this.router.navigateByUrl(this.route.snapshot.queryParamMap.get('url')?? '');
+      }
+    });
+  }
+
+  public ngOnDestroy(): void{
+    this.sub?.unsubscribe();
+  }
+}

package/projects/unipin-angular/src/lib/modules/permission/pages/loading/provide-loading-config.util.ts

@@ -0,0 +1,18 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { FetchPolicy } from '@apollo/client/core';
+
+export const LOADING_CONFIG = new InjectionToken<LoadingConfig>('LOADING_CONFIG');
+
+export interface LoadingConfig {
+	permTypes: string[];
+  permModules: string[];
+	fetchPolicy?: FetchPolicy;
+	subjectGuidStorageKey?: string;
+}
+
+export function provideLoadingConfig(config: LoadingConfig): Provider{
+  return {
+    provide: LOADING_CONFIG,
+    useValue: config
+  };
+}

package/projects/unipin-angular/src/lib/modules/permission/services/permission.service.spec.ts

@@ -0,0 +1,62 @@
+import { TestBed, inject } from '@angular/core/testing';
+import { ApolloQueryResult } from '@apollo/client/core';
+import { ApolloTestingModule, ApolloTestingController } from 'apollo-angular/testing';
+import { AppPermDfn } from '../../../../graphql/generated';
+import { PermissionService } from './permission.service';
+
+describe('PermissionService', () => {
+  let service: PermissionService;
+  let apolloController: ApolloTestingController;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      imports: [
+        ApolloTestingModule
+      ],
+      providers: [PermissionService],
+    });
+
+    service = TestBed.inject(PermissionService);
+    apolloController = TestBed.inject(ApolloTestingController);
+  });
+
+  it('should be created', () => expect(service).toBeTruthy());
+
+  it('should set permissions correctly', () => {
+    const permCodes =  ['SCOPE1.MODULE1.ADMIN', 'SCOPE1.MODULE2.READ'];
+    const permModules = ['MODULE1', 'MODULE2'];
+    
+    service.setPermission(permCodes, permModules);
+    expect(service.checkPermission('SCOPE1', 'MODULE1', 'ADMIN')).toBe(true);
+  });
+
+  it('should check permission correctly', () => {
+    const permCodes = ['SCOPE1.MODULE1.ADMIN', 'SCOPE1.MODULE2.READ'];
+    service.setPermission(permCodes);
+
+    expect(service.checkPermission('SCOPE1', 'MODULE1', 'ADMIN')).toBe(true);
+    expect(service.checkPermission('SCOPE1', 'MODULE2', 'READ')).toBe(true);
+    expect(service.checkPermission('SCOPE1', 'MODULE3', 'WRITE')).toBe(false);
+  });
+
+  it('should get permissions from Apollo', inject([PermissionService], (permissionService: PermissionService) => {
+    const mockPermissions = {
+      data: {
+        authMsPermission: {
+          data: [{ permCode: 'PERM1' }, { permCode: 'PERM2' }]
+        }
+      }
+    };
+
+    permissionService.getPermissions({ page: 0, pageSize: 2 }).subscribe((result) => {
+      expect(result).toEqual(mockPermissions as ApolloQueryResult<{ authMsPermission: { data: AppPermDfn[] } }>);
+    });
+
+    const op = apolloController.expectOne((operation) => operation.operationName === 'QueryPermission');
+    op.flush({ data: mockPermissions });
+
+    apolloController.verify();
+  }));
+
+  afterEach(() => apolloController.verify());
+});

package/projects/unipin-angular/src/lib/modules/permission/services/permission.service.ts

@@ -0,0 +1,78 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ApolloQueryResult, FetchPolicy } from '@apollo/client/core';
+import { Apollo, gql } from 'apollo-angular';
+import { AppPermDfn, PermissionFilter } from '../../../../graphql/generated';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class PermissionService {
+
+  /**
+   * A readonly variable that used to store permission modules in an applet then check if the user
+   * has the permission or not. This variable controls menu's icon visibility on the sidebar. The
+   * icon will appear if the user has the permission that menu's needed and it will disappear if
+   * the user don't have the permission.
+   * @type {BehaviorSubject<string[]>}
+   */
+  public readonly permModules: BehaviorSubject<string[]> = new BehaviorSubject<string[]>([]);
+
+  /**
+   * A flag variable that used to know if the applet already initiated or not. Default value is
+   * false.
+   * @type {boolean}
+   */
+  public isInitiated: boolean = false;
+  protected permissions: Map<string, boolean> = new Map();
+
+  constructor(
+    protected readonly apollo: Apollo
+  ) { }
+
+  /**
+   * A method that set the permissions and permission modules.
+   * @param {string[]} permCodes - Contain list of permission codes.
+   * @param {string[]} permModules - Contain list of permission modules. Default value [].
+   */
+  public setPermission(permCodes: string[], permModules: string[] = []): void{
+    for (let i = 0; i < permCodes.length; i++) this.permissions.set(permCodes[i], true);
+    this.permModules.next(permModules);
+  }
+
+  /**
+   * A method that checking if the user has the permission or not based on the params value.
+   * @param {string} scope - Contain scope of the user's permission.
+   * @param {string} module - Contain module of the user's permission.
+   * @param {string} type - Contain type of the user's permission.
+   * @returns {boolean} Contain boolean value that tells the user has the permission or not.
+   */
+  public checkPermission(scope: string, module: string, type: string): boolean{
+    if (this.permissions.has(`${ scope }.${ module }.ADMIN`)) return true;
+    if (this.permissions.has(`${ scope }.${ module }.${ type }`)) return true;
+
+    return false;
+  }
+
+  /**
+   * A method that get the query value with authMsPermission as the object.
+   * @param {PermissionFilter} filter - Contain filter as a conditions for the query.
+   * @returns {Observable<ApolloQueryResult<{ authMsPermission: { data: AppPermDfn[] }}>>} Contain query value.
+   */
+  public getPermissions(filter: PermissionFilter, fetchPolicy?: FetchPolicy): Observable<ApolloQueryResult<{ authMsPermission: { data: AppPermDfn[] }}>>{
+    return this.apollo.query({
+      fetchPolicy,
+      variables: { filter },
+      query: gql`
+        query QueryPermission($filter: PermissionFilter!) {
+          authMsPermission(filter: $filter) {
+            data {
+							permCode
+							permModule
+						}
+          }
+        }
+      `
+    });
+  }
+}

package/projects/unipin-angular/src/lib/resolvers/auth/auth.resolver.spec.ts

@@ -0,0 +1,46 @@
+import { TestBed } from '@angular/core/testing';
+import { AuthResolver } from './auth.resolver';
+import { AuthService } from '../../services';
+
+describe('AuthResolver', () => {
+  let authResolver: AuthResolver;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({
+      providers: [AuthResolver]
+    });
+
+    authResolver = TestBed.inject(AuthResolver);
+  });
+
+  it('should be created', () => expect(authResolver).toBeTruthy());
+
+  it('should return false if the user is not logged in', () => {
+    AuthService.authToken = '';
+    expect(authResolver.isUserLoggedIn()).toBe(false);
+  });
+
+  it('should return true if the user is logged in', () => {
+    AuthService.authToken = 'fakeAuthToken';
+    expect(authResolver.isUserLoggedIn()).toBe(true);
+  });
+
+  it('should return null if the user is not have token', () => {
+    AuthService.authToken = '';
+    expect(authResolver.getAuthToken()).toBeNull();
+  });
+
+  it('should return the auth token if the user is logged in and the token is not expired', () => {
+    spyOn(authResolver, 'isUserLoggedIn').and.returnValue(true);
+    AuthService.authToken = 'eyJhbGciOiJSUzI1NiJ9.eyJzdWIiOiIxZmU5NTJkYS1kZjViLTQxZDQtOTgxYy1kNmQ1YzAxZDAxNDIiLCJleHAiOjE3MDgzMDE0MTgsImlhdCI6MTcwODI5NzgxOH0.g_STuNb-GRlawePsUqAKFoJ2yTwqiUGpd_5ldiII0T2OiIuPAHFjIWuIuErD7_pCHK9bwx0ZHGx2QtbFdavP4u2sZcNVItGq6fHaAp5PF1DQX1WkpRl9gihSVFvJfgrnr0AgnJm6DtL3PnDqSAETDQOSq7kPH-ZVuV6hU5otz6IrdLExj5Iv3BqxE8gRxpIGfTc-a58soloDDA_LWf7BfRNELUljpo73dHG2-kGhVs7nYR_8CIIOl0Vs6fqRctYX8ZGkGpL4ZY3oXvJfbFhflcN-0ux-xAhKDjzTHshTS1Tt6ihfJOPfwONBIhpNsvaifAlcacuk5LjlgrQ7S-ePla0tIIasTEJGNXJD48BEfX--_s2t_F4Y9PqAwqSYyoCk8Gy48aKvNZy2QGHRCs_4ftU_3JIU0c3adxNsFGaufJrUXp2Cso5_zaul0UYYyvVgJ4Whu4UFIKKrF_E4ypsDjUBr9QvNLPpjzafyeLrNF9QHWHBMnUCw5EN60MJy04cVpVi36dwjuk5w_uOMu-3-M_SK_nsvJWgNaUHMK9aexrGusdGfDx6w6s0nF3Z8WXAbP7BCqMbXYvzbxYenvTS6BGPzArhYPU-Lc2pJLAIFHuVv84Eaett-ca8O5us4rdYSep5LOogQe3LREwuyKZKE_lQkLHiwgVu3kdv430MSobE';
+    
+    expect(authResolver.getAuthToken()).toBe('eyJhbGciOiJSUzI1NiJ9.eyJzdWIiOiIxZmU5NTJkYS1kZjViLTQxZDQtOTgxYy1kNmQ1YzAxZDAxNDIiLCJleHAiOjE3MDgzMDE0MTgsImlhdCI6MTcwODI5NzgxOH0.g_STuNb-GRlawePsUqAKFoJ2yTwqiUGpd_5ldiII0T2OiIuPAHFjIWuIuErD7_pCHK9bwx0ZHGx2QtbFdavP4u2sZcNVItGq6fHaAp5PF1DQX1WkpRl9gihSVFvJfgrnr0AgnJm6DtL3PnDqSAETDQOSq7kPH-ZVuV6hU5otz6IrdLExj5Iv3BqxE8gRxpIGfTc-a58soloDDA_LWf7BfRNELUljpo73dHG2-kGhVs7nYR_8CIIOl0Vs6fqRctYX8ZGkGpL4ZY3oXvJfbFhflcN-0ux-xAhKDjzTHshTS1Tt6ihfJOPfwONBIhpNsvaifAlcacuk5LjlgrQ7S-ePla0tIIasTEJGNXJD48BEfX--_s2t_F4Y9PqAwqSYyoCk8Gy48aKvNZy2QGHRCs_4ftU_3JIU0c3adxNsFGaufJrUXp2Cso5_zaul0UYYyvVgJ4Whu4UFIKKrF_E4ypsDjUBr9QvNLPpjzafyeLrNF9QHWHBMnUCw5EN60MJy04cVpVi36dwjuk5w_uOMu-3-M_SK_nsvJWgNaUHMK9aexrGusdGfDx6w6s0nF3Z8WXAbP7BCqMbXYvzbxYenvTS6BGPzArhYPU-Lc2pJLAIFHuVv84Eaett-ca8O5us4rdYSep5LOogQe3LREwuyKZKE_lQkLHiwgVu3kdv430MSobE');
+  });
+
+  it('should return null if the user is logged in but the token is expired', () => {
+    spyOn(authResolver, 'isUserLoggedIn').and.returnValue(false);
+    AuthService.authToken = '';
+
+    expect(authResolver.getAuthToken()).toBeNull();
+  });
+});