commit

Author: crisnicandrei

src/app/auth/guards/auth.guard.spec.ts

@@ -0,0 +1,111 @@
+import { TestBed } from '@angular/core/testing';
+import { AuthGuard } from './auth.guard';
+import { Router, UrlTree } from '@angular/router';
+import { AccountService } from '@shared/services/account/account.service';
+import { ActivatedRouteSnapshot, RouterStateSnapshot } from '@angular/router';
+import { AccountVO } from '@models/account-vo';
+import { ArchiveVO } from '@models/index';
+
+describe('AuthGuard', () => {
+  let guard: AuthGuard;
+  let accountServiceSpy: jasmine.SpyObj<AccountService>;
+  let routerSpy: jasmine.SpyObj<Router>;
+
+  beforeEach(() => {
+    accountServiceSpy = jasmine.createSpyObj('AccountService', [
+      'getAccount',
+      'hasOwnArchives',
+    ]);
+
+    routerSpy = jasmine.createSpyObj('Router', ['createUrlTree', 'parseUrl']);
+
+    TestBed.configureTestingModule({
+      providers: [
+        AuthGuard,
+        { provide: AccountService, useValue: accountServiceSpy },
+        { provide: Router, useValue: routerSpy },
+      ],
+    });
+
+    guard = TestBed.inject(AuthGuard);
+  });
+
+  function createMockRouteSnapshot(
+    query: Record<string, string> = {},
+  ): ActivatedRouteSnapshot {
+    return {
+      queryParamMap: {
+        get: (key: string) => query[key] ?? null,
+      },
+    } as any;
+  }
+
+  it('should allow access if no account is found', () => {
+    accountServiceSpy.getAccount.and.returnValue(null);
+    const result = guard.canActivate(createMockRouteSnapshot(), {
+      url: '/signup',
+    } as RouterStateSnapshot);
+    expect(result).toBeTrue();
+  });
+
+  it('should redirect to /app/dialog:archives/pending if on /signup with invite params', () => {
+    accountServiceSpy.getAccount.and.returnValue(
+      new AccountVO({ accountId: 1 }),
+    );
+
+    const query = {
+      inviteCode: 'xyz',
+      fullName: 'Test User',
+      primaryEmail: '[email protected]',
+    };
+
+    const expectedTree = {} as UrlTree;
+    routerSpy.createUrlTree.and.returnValue(expectedTree);
+
+    const result = guard.canActivate(createMockRouteSnapshot(query), {
+      url: '/signup',
+    } as RouterStateSnapshot);
+
+    expect(routerSpy.createUrlTree).toHaveBeenCalledWith([
+      '/app',
+      { outlets: { primary: 'private', dialog: 'archives/pending' } },
+    ]);
+    expect(result).toBe(expectedTree);
+  });
+
+  it('should redirect to /app/private if account has own archives', async () => {
+    accountServiceSpy.getAccount.and.returnValue(
+      new AccountVO({ accountId: 1 }),
+    );
+    accountServiceSpy.hasOwnArchives.and.returnValue(Promise.resolve(true));
+
+    const expectedUrl = {} as UrlTree;
+    routerSpy.parseUrl.and.returnValue(expectedUrl);
+
+    const result = await guard.canActivate(createMockRouteSnapshot(), {
+      url: '/app/anything',
+    } as RouterStateSnapshot);
+
+    expect(accountServiceSpy.hasOwnArchives).toHaveBeenCalled();
+    expect(result).toBe(expectedUrl);
+    expect(routerSpy.parseUrl).toHaveBeenCalledWith('/app/private');
+  });
+
+  it('should redirect to /app/onboarding if account has no own archives', async () => {
+    accountServiceSpy.getAccount.and.returnValue(
+      new AccountVO({ accountId: 1 }),
+    );
+    accountServiceSpy.hasOwnArchives.and.returnValue(Promise.resolve(false));
+
+    const expectedUrl = {} as UrlTree;
+    routerSpy.parseUrl.and.returnValue(expectedUrl);
+
+    const result = await guard.canActivate(createMockRouteSnapshot(), {
+      url: '/app/anything',
+    } as RouterStateSnapshot);
+
+    expect(accountServiceSpy.hasOwnArchives).toHaveBeenCalled();
+    expect(result).toBe(expectedUrl);
+    expect(routerSpy.parseUrl).toHaveBeenCalledWith('/app/onboarding');
+  });
+});

src/app/core/components/my-archives-dialog/my-archives-dialog.component.spec.ts

@@ -109,7 +109,40 @@ describe('MyArchivesDialogComponent', () => {
 
   it('should close dialog onDoneClick', () => {
     component.onDoneClick();
-    
+
     expect(dialogRefSpy.close).toHaveBeenCalled();
   });
+
+  it('should initialize and separate pending/regular archives correctly', async () => {
+    const mockAccount = new AccountVO({ defaultArchiveId: '111' });
+    const mockCurrentArchive = new ArchiveVO({ archiveId: '111', fullName: 'Current Archive' });
+  
+    const pending = new ArchiveVO({
+      archiveId: '222',
+      fullName: 'Pending Archive',
+      status: 'status.generic.pending',
+    });
+  
+    const active = new ArchiveVO({
+      archiveId: '333',
+      fullName: 'Active Archive',
+      status: 'status.generic.ok',
+    });
+  
+    accountServiceSpy.refreshArchives.and.returnValue(Promise.resolve([new ArchiveVO({})]));
+    accountServiceSpy.getAccount.and.returnValue(mockAccount);
+    accountServiceSpy.getArchive.and.returnValue(mockCurrentArchive);
+    accountServiceSpy.getArchives.and.returnValue([pending, active]);
+  
+    await component.ngOnInit();
+  
+    expect(accountServiceSpy.refreshArchives).toHaveBeenCalled();
+    expect(component.account).toEqual(mockAccount);
+    expect(component.currentArchive).toEqual(mockCurrentArchive);
+    expect(component.pendingArchives.length).toBe(1);
+    expect(component.archives.length).toBe(1);
+    expect(component.pendingArchives[0].archiveId).toBe('222');
+    expect(component.archives[0].archiveId).toBe('333');
+  });
+  
 });