@azure/msal-angular 4.0.12 → 4.0.13

package/src/msal.broadcast.service.ts

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { Inject, Injectable, Optional } from "@angular/core";
+import {
+  EventMessage,
+  EventMessageUtils,
+  IPublicClientApplication,
+  InteractionStatus,
+} from "@azure/msal-browser";
+import { BehaviorSubject, Observable, ReplaySubject, Subject } from "rxjs";
+import { MsalBroadcastConfiguration } from "./msal.broadcast.config";
+import { MSAL_BROADCAST_CONFIG, MSAL_INSTANCE } from "./constants";
+import { name, version } from "./packageMetadata";
+
+@Injectable()
+export class MsalBroadcastService {
+  private _msalSubject: Subject<EventMessage>;
+  public msalSubject$: Observable<EventMessage>;
+  private _inProgress: BehaviorSubject<InteractionStatus>;
+  public inProgress$: Observable<InteractionStatus>;
+
+  constructor(
+    @Inject(MSAL_INSTANCE) private msalInstance: IPublicClientApplication,
+    @Optional()
+    @Inject(MSAL_BROADCAST_CONFIG)
+    private msalBroadcastConfig?: MsalBroadcastConfiguration
+  ) {
+    // Make _msalSubject a ReplaySubject if configured to replay past events
+    if (
+      this.msalBroadcastConfig &&
+      this.msalBroadcastConfig.eventsToReplay > 0
+    ) {
+      this.msalInstance
+        .getLogger()
+        .clone(name, version)
+        .verbose(
+          `BroadcastService - eventsToReplay set on BroadcastConfig, replaying the last ${this.msalBroadcastConfig.eventsToReplay} events`
+        );
+      this._msalSubject = new ReplaySubject<EventMessage>(
+        this.msalBroadcastConfig.eventsToReplay
+      );
+    } else {
+      // Defaults to _msalSubject being a Subject
+      this._msalSubject = new Subject<EventMessage>();
+    }
+
+    this.msalSubject$ = this._msalSubject.asObservable();
+
+    // InProgress as BehaviorSubject so most recent inProgress state will be available upon subscription
+    this._inProgress = new BehaviorSubject<InteractionStatus>(
+      InteractionStatus.Startup
+    );
+    this.inProgress$ = this._inProgress.asObservable();
+
+    this.msalInstance.addEventCallback((message: EventMessage) => {
+      this._msalSubject.next(message);
+      const status = EventMessageUtils.getInteractionStatusFromEvent(
+        message,
+        this._inProgress.value
+      );
+      if (status !== null) {
+        this.msalInstance
+          .getLogger()
+          .clone(name, version)
+          .verbose(
+            `BroadcastService - ${message.eventType} results in setting inProgress from ${this._inProgress.value} to ${status}`
+          );
+        this._inProgress.next(status);
+      }
+    });
+  }
+
+  /**
+   * Resets inProgress state to None
+   */
+  resetInProgressEvent(): void {
+    if (this._inProgress.value === InteractionStatus.Startup) {
+      this._inProgress.next(InteractionStatus.None);
+    }
+  }
+}

package/src/msal.guard.config.ts

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { RouterStateSnapshot } from "@angular/router";
+import {
+  PopupRequest,
+  RedirectRequest,
+  InteractionType,
+} from "@azure/msal-browser";
+import { MsalService } from "./msal.service";
+
+export declare type MsalGuardAuthRequest =
+  | Partial<PopupRequest>
+  | Partial<Omit<RedirectRequest, "redirectStartPage">>;
+
+export type MsalGuardConfiguration = {
+  interactionType: InteractionType.Popup | InteractionType.Redirect;
+  authRequest?:
+    | MsalGuardAuthRequest
+    | ((
+        authService: MsalService,
+        state: RouterStateSnapshot
+      ) => MsalGuardAuthRequest);
+  loginFailedRoute?: string;
+};

package/src/msal.guard.spec.ts

@@ -0,0 +1,525 @@
+import { HttpClientTestingModule } from "@angular/common/http/testing";
+import { TestBed } from "@angular/core/testing";
+import { UrlTree } from "@angular/router";
+import { RouterTestingModule } from "@angular/router/testing";
+import { Location } from "@angular/common";
+import {
+  BrowserSystemOptions,
+  InteractionType,
+  IPublicClientApplication,
+  LogLevel,
+  PublicClientApplication,
+  UrlString,
+} from "@azure/msal-browser";
+import { of } from "rxjs";
+import {
+  MsalModule,
+  MsalGuard,
+  MsalService,
+  MsalBroadcastService,
+} from "./public-api";
+import { MsalGuardConfiguration } from "./msal.guard.config";
+
+let guard: MsalGuard;
+let authService: MsalService;
+let routeMock: any = { snapshot: {} };
+let routeStateMock: any = { snapshot: {}, url: "/" };
+let testInteractionType: InteractionType;
+let testLoginFailedRoute: string;
+let testConfiguration: Partial<MsalGuardConfiguration>;
+let browserSystemOptions: BrowserSystemOptions;
+
+function MSALInstanceFactory(): IPublicClientApplication {
+  return new PublicClientApplication({
+    auth: {
+      clientId: "b5c2e510-4a17-4feb-b219-e55aa5b74144",
+      redirectUri: "http://localhost:4200",
+    },
+    system: {
+      loggerOptions: {
+        loggerCallback: (level, message) => {
+          // console.log(message)
+        },
+        logLevel: LogLevel.Verbose,
+        piiLoggingEnabled: true,
+      },
+    },
+  });
+}
+
+function MSALGuardConfigFactory(): MsalGuardConfiguration {
+  return {
+    //@ts-ignore
+    interactionType: testInteractionType,
+    loginFailedRoute: testLoginFailedRoute,
+    authRequest: testConfiguration?.authRequest,
+  };
+}
+
+function initializeMsal(providers: any[] = []) {
+  TestBed.resetTestingModule();
+  TestBed.configureTestingModule({
+    imports: [
+      MsalModule.forRoot(MSALInstanceFactory(), MSALGuardConfigFactory(), {
+        interactionType: InteractionType.Popup,
+        protectedResourceMap: new Map(),
+      }),
+      HttpClientTestingModule,
+      RouterTestingModule.withRoutes([]),
+    ],
+    providers: [MsalGuard, MsalService, MsalBroadcastService, ...providers],
+    teardown: { destroyAfterEach: false },
+  });
+
+  authService = TestBed.inject(MsalService);
+  guard = TestBed.inject(MsalGuard);
+}
+
+describe("MsalGuard", () => {
+  beforeEach(() => {
+    testInteractionType = InteractionType.Popup;
+    testLoginFailedRoute = undefined;
+    testConfiguration = {};
+    browserSystemOptions = {};
+    routeStateMock = { snapshot: {}, url: "/" };
+    initializeMsal();
+  });
+
+  it("is created", () => {
+    expect(guard).toBeTruthy();
+  });
+
+  it("throws error for silent interaction type", (done) => {
+    testInteractionType = InteractionType.Silent;
+    initializeMsal();
+    try {
+      guard.canActivate(routeMock, routeStateMock).subscribe((result) => {});
+    } catch (err) {
+      expect(err.errorCode).toBe("invalid_interaction_type");
+      done();
+    }
+  });
+
+  it("returns false if page with MSAL Guard is set as redirectUri", (done) => {
+    spyOn(UrlString, "hashContainsKnownProperties").and.returnValue(true);
+    spyOnProperty(window, "parent", "get").and.returnValue({ ...window });
+
+    guard.canActivate(routeMock, routeStateMock).subscribe((result) => {
+      expect(result).toBeFalse();
+      done();
+    });
+  });
+
+  it("returns false if page contains known successful response (path routing)", (done) => {
+    initializeMsal([
+      {
+        provide: Location,
+        useValue: {
+          path: jasmine
+            .createSpy("path")
+            .and.callFake((hash: boolean) =>
+              hash ? "/path?code=123#code=456" : "/path"
+            ),
+          prepareExternalUrl: jasmine
+            .createSpy("prepareExternalUrl")
+            .and.callFake((url: string) => "/path"),
+        },
+      },
+    ]);
+
+    routeStateMock = {
+      snapshot: {},
+      url: "/path?code=123#code=456",
+      root: {
+        fragment: "code=456",
+      },
+    };
+
+    spyOn(MsalService.prototype, "handleRedirectObservable").and.returnValue(
+      //@ts-ignore
+      of("test")
+    );
+
+    spyOn(PublicClientApplication.prototype, "getAllAccounts").and.returnValue([
+      {
+        homeAccountId: "test",
+        localAccountId: "test",
+        environment: "test",
+        tenantId: "test",
+        username: "test",
+      },
+    ]);
+
+    guard
+      .canActivate(routeMock, routeStateMock)
+      .subscribe((result: UrlTree) => {
+        expect(result.toString()).toEqual("/path");
+        done();
+      });
+  });
+
+  it("returns true if page contains code= in query parameters only", (done) => {
+    initializeMsal([
+      {
+        provide: Location,
+        useValue: {
+          path: jasmine
+            .createSpy("path")
+            .and.callFake((hash: boolean) =>
+              hash ? "/path?code=123" : "/path"
+            ),
+          prepareExternalUrl: jasmine
+            .createSpy("prepareExternalUrl")
+            .and.callFake((url: string) => "/path"),
+        },
+      },
+    ]);
+
+    routeStateMock = {
+      snapshot: {},
+      url: "/path?code=123",
+      root: {
+        fragment: null,
+      },
+    };
+
+    spyOn(MsalService.prototype, "handleRedirectObservable").and.returnValue(
+      //@ts-ignore
+      of("test")
+    );
+
+    spyOn(PublicClientApplication.prototype, "getAllAccounts").and.returnValue([
+      {
+        homeAccountId: "test",
+        localAccountId: "test",
+        environment: "test",
+        tenantId: "test",
+        username: "test",
+      },
+    ]);
+
+    guard
+      .canActivate(routeMock, routeStateMock)
+      .subscribe((result: UrlTree) => {
+        expect(result).toBeTrue();
+        done();
+      });
+  });
+
+  it("returns true if page route doesnt end with /code", (done) => {
+    initializeMsal([
+      {
+        provide: Location,
+        useValue: {
+          path: jasmine
+            .createSpy("path")
+            .and.callFake((hash: boolean) => (hash ? "/codes" : "/")),
+          prepareExternalUrl: jasmine
+            .createSpy("prepareExternalUrl")
+            .and.callFake((url: string) => "#/codes"),
+        },
+      },
+    ]);
+
+    routeStateMock = {
+      snapshot: {},
+      url: "/codes",
+      root: {
+        fragment: null,
+      },
+    };
+
+    spyOn(MsalService.prototype, "handleRedirectObservable").and.returnValue(
+      //@ts-ignore
+      of("test")
+    );
+
+    spyOn(PublicClientApplication.prototype, "getAllAccounts").and.returnValue([
+      {
+        homeAccountId: "test",
+        localAccountId: "test",
+        environment: "test",
+        tenantId: "test",
+        username: "test",
+      },
+    ]);
+
+    guard
+      .canActivate(routeMock, routeStateMock)
+      .subscribe((result: UrlTree) => {
+        expect(result).toBeTrue();
+        done();
+      });
+  });
+
+  it("returns true if page route doesnt end with /code (short path)", (done) => {
+    initializeMsal([
+      {
+        provide: Location,
+        useValue: {
+          path: jasmine
+            .createSpy("path")
+            .and.callFake((hash: boolean) => (hash ? "/cod" : "/")),
+          prepareExternalUrl: jasmine
+            .createSpy("prepareExternalUrl")
+            .and.callFake((url: string) => "#/cod"),
+        },
+      },
+    ]);
+
+    routeStateMock = {
+      snapshot: {},
+      url: "/cod",
+      root: {
+        fragment: null,
+      },
+    };
+
+    spyOn(MsalService.prototype, "handleRedirectObservable").and.returnValue(
+      //@ts-ignore
+      of("test")
+    );
+
+    spyOn(PublicClientApplication.prototype, "getAllAccounts").and.returnValue([
+      {
+        homeAccountId: "test",
+        localAccountId: "test",
+        environment: "test",
+        tenantId: "test",
+        username: "test",
+      },
+    ]);
+
+    guard
+      .canActivate(routeMock, routeStateMock)
+      .subscribe((result: UrlTree) => {
+        expect(result).toBeTrue();
+        done();
+      });
+  });
+
+  it("returns false if page contains known successful response (hash routing)", (done) => {
+    initializeMsal([
+      {
+        provide: Location,
+        useValue: {
+          path: jasmine
+            .createSpy("path")
+            .and.callFake((hash: boolean) => (hash ? "/code=" : "/")),
+          prepareExternalUrl: jasmine
+            .createSpy("prepareExternalUrl")
+            .and.callFake((url: string) => "#/"),
+        },
+      },
+    ]);
+
+    routeStateMock = {
+      snapshot: {},
+      url: "/code",
+      root: {
+        fragment: null,
+      },
+    };
+
+    spyOn(MsalService.prototype, "handleRedirectObservable").and.returnValue(
+      //@ts-ignore
+      of("test")
+    );
+
+    spyOn(PublicClientApplication.prototype, "getAllAccounts").and.returnValue([
+      {
+        homeAccountId: "test",
+        localAccountId: "test",
+        environment: "test",
+        tenantId: "test",
+        username: "test",
+      },
+    ]);
+
+    guard
+      .canActivate(routeMock, routeStateMock)
+      .subscribe((result: UrlTree) => {
+        expect(result.toString()).toEqual("/");
+        done();
+      });
+  });
+
+  it("returns true for a logged in user", (done) => {
+    spyOn(MsalService.prototype, "handleRedirectObservable").and.returnValue(
+      //@ts-ignore
+      of("test")
+    );
+
+    spyOn(PublicClientApplication.prototype, "getAllAccounts").and.returnValue([
+      {
+        homeAccountId: "test",
+        localAccountId: "test",
+        environment: "test",
+        tenantId: "test",
+        username: "test",
+      },
+    ]);
+
+    guard.canActivate(routeMock, routeStateMock).subscribe((result) => {
+      expect(result).toBeTrue();
+      done();
+    });
+  });
+
+  it("should return true after logging in with popup", (done) => {
+    testConfiguration = {
+      authRequest: (authService, state) => {
+        expect(state).toBeDefined();
+        expect(authService).toBeDefined();
+        return {};
+      },
+    };
+    initializeMsal();
+    spyOn(MsalService.prototype, "handleRedirectObservable").and.returnValue(
+      //@ts-ignore
+      of("test")
+    );
+
+    spyOn(PublicClientApplication.prototype, "getAllAccounts").and.returnValue(
+      []
+    );
+
+    spyOn(MsalService.prototype, "loginPopup").and.returnValue(
+      //@ts-ignore
+      of(true)
+    );
+
+    guard.canActivate(routeMock, routeStateMock).subscribe((result) => {
+      expect(result).toBeTrue();
+      done();
+    });
+  });
+
+  it("should return false after login with popup fails and no loginFailedRoute set", (done) => {
+    spyOn(MsalService.prototype, "handleRedirectObservable").and.returnValue(
+      //@ts-ignore
+      of("test")
+    );
+
+    spyOn(PublicClientApplication.prototype, "getAllAccounts").and.returnValue(
+      []
+    );
+
+    spyOn(MsalService.prototype, "loginPopup").and.throwError("login error");
+
+    guard.canActivate(routeMock, routeStateMock).subscribe((result) => {
+      expect(result).toBeFalse();
+      done();
+    });
+  });
+
+  it("should return loginFailedRoute after login with popup fails and loginFailedRoute set", (done) => {
+    testLoginFailedRoute = "failed";
+    initializeMsal();
+
+    spyOn(guard, "parseUrl").and.returnValue(
+      testLoginFailedRoute as unknown as UrlTree
+    );
+
+    spyOn(MsalService.prototype, "handleRedirectObservable").and.returnValue(
+      //@ts-ignore
+      of("test")
+    );
+
+    spyOn(PublicClientApplication.prototype, "getAllAccounts").and.returnValue(
+      []
+    );
+
+    spyOn(MsalService.prototype, "loginPopup").and.throwError("login error");
+
+    guard.canActivate(routeMock, routeStateMock).subscribe((result) => {
+      expect(result).toBe("failed" as unknown as UrlTree);
+      done();
+    });
+  });
+
+  it("should return false after logging in with redirect", (done) => {
+    testInteractionType = InteractionType.Redirect;
+    initializeMsal();
+
+    spyOn(MsalService.prototype, "handleRedirectObservable").and.returnValue(
+      //@ts-ignore
+      of("test")
+    );
+
+    spyOn(PublicClientApplication.prototype, "getAllAccounts").and.returnValue(
+      []
+    );
+
+    spyOn(PublicClientApplication.prototype, "loginRedirect").and.returnValue(
+      new Promise((resolve) => {
+        resolve();
+      })
+    );
+
+    guard.canActivate(routeMock, routeStateMock).subscribe((result) => {
+      expect(result).toBeFalse();
+      done();
+    });
+  });
+
+  it("canActivateChild returns true with logged in user", (done) => {
+    spyOn(MsalService.prototype, "handleRedirectObservable").and.returnValue(
+      //@ts-ignore
+      of("test")
+    );
+
+    spyOn(PublicClientApplication.prototype, "getAllAccounts").and.returnValue([
+      {
+        homeAccountId: "test",
+        localAccountId: "test",
+        environment: "test",
+        tenantId: "test",
+        username: "test",
+      },
+    ]);
+
+    guard.canActivateChild(routeMock, routeStateMock).subscribe((result) => {
+      expect(result).toBeTrue();
+      done();
+    });
+  });
+
+  it("canLoad returns true with logged in user", (done) => {
+    spyOn(MsalService.prototype, "handleRedirectObservable").and.returnValue(
+      //@ts-ignore
+      of("test")
+    );
+
+    spyOn(PublicClientApplication.prototype, "getAllAccounts").and.returnValue([
+      {
+        homeAccountId: "test",
+        localAccountId: "test",
+        environment: "test",
+        tenantId: "test",
+        username: "test",
+      },
+    ]);
+
+    guard.canMatch().subscribe((result) => {
+      expect(result).toBeTrue();
+      done();
+    });
+  });
+
+  it("canLoad returns false with no users logged in", (done) => {
+    spyOn(MsalService.prototype, "handleRedirectObservable").and.returnValue(
+      //@ts-ignore
+      of("test")
+    );
+
+    spyOn(PublicClientApplication.prototype, "getAllAccounts").and.returnValue(
+      []
+    );
+
+    guard.canMatch().subscribe((result) => {
+      expect(result).toBeFalse();
+      done();
+    });
+  });
+});