@azure/msal-angular 4.0.11 → 4.0.13

package/src/msal.service.spec.ts

@@ -0,0 +1,468 @@
+import { TestBed } from "@angular/core/testing";
+import {
+  AuthenticationResult,
+  AuthError,
+  InteractionStatus,
+  InteractionType,
+  Logger,
+  PublicClientApplication,
+  SilentRequest,
+} from "@azure/msal-browser";
+import { MsalModule, MsalBroadcastService, MsalService } from "./public-api";
+import { takeLast } from "rxjs/operators";
+
+let authService: MsalService;
+let broadcastService: MsalBroadcastService;
+
+const msalInstance = new PublicClientApplication({
+  auth: {
+    clientId: "b5c2e510-4a17-4feb-b219-e55aa5b74144",
+    redirectUri: "http://localhost:4200",
+  },
+});
+
+function initializeMsal() {
+  TestBed.resetTestingModule();
+
+  TestBed.configureTestingModule({
+    imports: [
+      MsalModule.forRoot(msalInstance, null, {
+        interactionType: InteractionType.Popup,
+        protectedResourceMap: new Map(),
+      }),
+    ],
+    providers: [MsalService, MsalBroadcastService],
+    teardown: { destroyAfterEach: false },
+  });
+
+  authService = TestBed.inject(MsalService);
+  broadcastService = TestBed.inject(MsalBroadcastService);
+}
+
+describe("MsalService", () => {
+  beforeEach(initializeMsal);
+
+  describe("loginPopup", () => {
+    it("success", (done) => {
+      const sampleIdToken = {
+        idToken: "123abc",
+      };
+
+      spyOn(PublicClientApplication.prototype, "loginPopup").and.returnValue(
+        new Promise((resolve) => {
+          //@ts-ignore
+          resolve(sampleIdToken);
+        })
+      );
+
+      const request = {
+        scopes: ["user.read"],
+      };
+
+      authService
+        .loginPopup(request)
+        .subscribe((response: AuthenticationResult) => {
+          expect(response.idToken).toBe(sampleIdToken.idToken);
+          expect(
+            PublicClientApplication.prototype.loginPopup
+          ).toHaveBeenCalledWith(request);
+          done();
+        });
+    });
+
+    it("failure", (done) => {
+      const sampleError = new AuthError("123", "message");
+
+      spyOn(PublicClientApplication.prototype, "loginPopup").and.returnValue(
+        new Promise((resolve, reject) => {
+          reject(sampleError);
+        })
+      );
+
+      const request = {
+        scopes: ["wrong.scope"],
+      };
+
+      authService.loginPopup(request).subscribe({
+        error: (error: AuthError) => {
+          expect(error.message).toBe(sampleError.message);
+          expect(
+            PublicClientApplication.prototype.loginPopup
+          ).toHaveBeenCalledWith(request);
+          done();
+        },
+      });
+    });
+  });
+
+  describe("loginRedirect", () => {
+    it("success", async () => {
+      spyOn(PublicClientApplication.prototype, "loginRedirect").and.returnValue(
+        new Promise((resolve) => {
+          resolve();
+        })
+      );
+
+      const request = {
+        scopes: ["user.read"],
+      };
+
+      await authService.loginRedirect(request);
+
+      expect(
+        PublicClientApplication.prototype.loginRedirect
+      ).toHaveBeenCalled();
+    });
+  });
+
+  describe("logout", () => {
+    it("calls logout on msalService", async () => {
+      spyOn(PublicClientApplication.prototype, "logout").and.returnValue(
+        new Promise((resolve) => {
+          resolve();
+        })
+      );
+      await authService.logout();
+      expect(PublicClientApplication.prototype.logout).toHaveBeenCalled();
+    });
+  });
+
+  describe("logoutPopup", () => {
+    it("calls logoutPopup on msalService", async () => {
+      spyOn(PublicClientApplication.prototype, "logoutPopup").and.returnValue(
+        new Promise((resolve) => {
+          resolve();
+        })
+      );
+      await authService.logoutPopup();
+      expect(PublicClientApplication.prototype.logoutPopup).toHaveBeenCalled();
+    });
+  });
+
+  describe("logoutRedirect", () => {
+    it("calls logoutRedirect on msalService", async () => {
+      spyOn(
+        PublicClientApplication.prototype,
+        "logoutRedirect"
+      ).and.returnValue(
+        new Promise((resolve) => {
+          resolve();
+        })
+      );
+      await authService.logoutRedirect();
+      expect(
+        PublicClientApplication.prototype.logoutRedirect
+      ).toHaveBeenCalled();
+    });
+  });
+
+  describe("ssoSilent", () => {
+    it("success", (done) => {
+      const sampleIdToken = {
+        idToken: "id-token",
+      };
+
+      spyOn(PublicClientApplication.prototype, "ssoSilent").and.returnValue(
+        new Promise((resolve) => {
+          //@ts-ignore
+          resolve(sampleIdToken);
+        })
+      );
+
+      const request = {
+        scopes: ["user.read"],
+        loginHint: "name@example.com",
+      };
+
+      authService
+        .ssoSilent(request)
+        .subscribe((response: AuthenticationResult) => {
+          expect(response.idToken).toBe(sampleIdToken.idToken);
+          expect(
+            PublicClientApplication.prototype.ssoSilent
+          ).toHaveBeenCalledWith(request);
+          done();
+        });
+    });
+
+    it("failure", (done) => {
+      const sampleError = new AuthError("123", "message");
+
+      spyOn(PublicClientApplication.prototype, "ssoSilent").and.returnValue(
+        new Promise((resolve, reject) => {
+          reject(sampleError);
+        })
+      );
+
+      const request = {
+        scopes: ["user.read"],
+        loginHint: "name@example.com",
+      };
+
+      authService.ssoSilent(request).subscribe({
+        error: (error: AuthError) => {
+          expect(error.errorMessage).toBe(sampleError.errorMessage);
+          expect(
+            PublicClientApplication.prototype.ssoSilent
+          ).toHaveBeenCalledWith(request);
+          done();
+        },
+      });
+    });
+  });
+
+  describe("acquireTokenSilent", () => {
+    it("success", (done) => {
+      const sampleAccessToken = {
+        accessToken: "123abc",
+      };
+
+      spyOn(
+        PublicClientApplication.prototype,
+        "acquireTokenSilent"
+      ).and.returnValue(
+        new Promise((resolve) => {
+          //@ts-ignore
+          resolve(sampleAccessToken);
+        })
+      );
+
+      const request: SilentRequest = {
+        scopes: ["user.read"],
+        account: null,
+      };
+
+      authService
+        .acquireTokenSilent(request)
+        .subscribe((response: AuthenticationResult) => {
+          expect(response.accessToken).toBe(sampleAccessToken.accessToken);
+          expect(
+            PublicClientApplication.prototype.acquireTokenSilent
+          ).toHaveBeenCalledWith(request);
+          done();
+        });
+    });
+
+    it("failure", (done) => {
+      const sampleError = new AuthError("123", "message");
+
+      spyOn(
+        PublicClientApplication.prototype,
+        "acquireTokenSilent"
+      ).and.returnValue(
+        new Promise((resolve, reject) => {
+          reject(sampleError);
+        })
+      );
+
+      const request: SilentRequest = {
+        scopes: ["wrong.scope"],
+        account: null,
+      };
+
+      authService.acquireTokenSilent(request).subscribe({
+        error: (error: AuthError) => {
+          expect(error.errorMessage).toBe(sampleError.errorMessage);
+          expect(
+            PublicClientApplication.prototype.acquireTokenSilent
+          ).toHaveBeenCalledWith(request);
+          done();
+        },
+      });
+    });
+  });
+
+  describe("acquireTokenRedirect", () => {
+    it("success", async () => {
+      spyOn(
+        PublicClientApplication.prototype,
+        "acquireTokenRedirect"
+      ).and.returnValue(
+        new Promise((resolve) => {
+          resolve();
+        })
+      );
+
+      await authService.acquireTokenRedirect({
+        scopes: ["user.read"],
+      });
+
+      expect(
+        PublicClientApplication.prototype.acquireTokenRedirect
+      ).toHaveBeenCalled();
+    });
+  });
+
+  describe("acquireTokenPopup", () => {
+    it("success", (done) => {
+      const sampleAccessToken = {
+        accessToken: "123abc",
+      };
+
+      spyOn(
+        PublicClientApplication.prototype,
+        "acquireTokenPopup"
+      ).and.returnValue(
+        new Promise((resolve) => {
+          //@ts-ignore
+          resolve(sampleAccessToken);
+        })
+      );
+
+      const request = {
+        scopes: ["user.read"],
+      };
+
+      authService
+        .acquireTokenPopup(request)
+        .subscribe((response: AuthenticationResult) => {
+          expect(response.accessToken).toBe(sampleAccessToken.accessToken);
+          expect(
+            PublicClientApplication.prototype.acquireTokenPopup
+          ).toHaveBeenCalledWith(request);
+          done();
+        });
+    });
+
+    it("failure", (done) => {
+      const sampleError = new AuthError("123", "message");
+
+      spyOn(
+        PublicClientApplication.prototype,
+        "acquireTokenPopup"
+      ).and.returnValue(
+        new Promise((resolve, reject) => {
+          reject(sampleError);
+        })
+      );
+
+      const request = {
+        scopes: ["wrong.scope"],
+      };
+
+      authService.acquireTokenPopup(request).subscribe({
+        error: (error: AuthError) => {
+          expect(error.errorMessage).toBe(sampleError.errorMessage);
+          expect(
+            PublicClientApplication.prototype.acquireTokenPopup
+          ).toHaveBeenCalledWith(request);
+          done();
+        },
+      });
+    });
+  });
+
+  describe("handleRedirectObservable", () => {
+    it("success and resets inProgress event to none", (done) => {
+      const sampleAccessToken = {
+        accessToken: "123abc",
+      };
+
+      //@ts-ignore
+      broadcastService._inProgress.next(InteractionStatus.Startup);
+
+      spyOn(PublicClientApplication.prototype, "initialize").and.returnValue(
+        Promise.resolve()
+      );
+
+      spyOn(
+        PublicClientApplication.prototype,
+        "handleRedirectPromise"
+      ).and.returnValue(
+        new Promise((resolve) => {
+          //@ts-ignore
+          resolve(sampleAccessToken);
+        })
+      );
+
+      authService
+        .handleRedirectObservable()
+        .subscribe((response: AuthenticationResult) => {
+          expect(response.accessToken).toBe(sampleAccessToken.accessToken);
+          expect(
+            PublicClientApplication.prototype.initialize
+          ).toHaveBeenCalled();
+          expect(
+            PublicClientApplication.prototype.handleRedirectPromise
+          ).toHaveBeenCalled();
+          broadcastService.inProgress$.subscribe((result) => {
+            expect(result).toBe(InteractionStatus.None);
+          });
+          done();
+        });
+    });
+
+    it("failure and also resets inProgress event to none", (done) => {
+      const sampleError = new AuthError("123", "message");
+
+      //@ts-ignore
+      broadcastService._inProgress.next(InteractionStatus.Startup);
+
+      spyOn(PublicClientApplication.prototype, "initialize").and.returnValue(
+        Promise.resolve()
+      );
+
+      spyOn(
+        PublicClientApplication.prototype,
+        "handleRedirectPromise"
+      ).and.returnValue(
+        new Promise((resolve, reject) => {
+          reject(sampleError);
+        })
+      );
+
+      authService.handleRedirectObservable().subscribe({
+        error: (error: AuthError) => {
+          expect(error.message).toBe(sampleError.message);
+          expect(
+            PublicClientApplication.prototype.initialize
+          ).toHaveBeenCalled();
+          expect(
+            PublicClientApplication.prototype.handleRedirectPromise
+          ).toHaveBeenCalled();
+          broadcastService.inProgress$.pipe(takeLast(1)).subscribe((result) => {
+            console.log("failure result", result);
+            expect(result).toBe(InteractionStatus.None);
+          });
+          done();
+        },
+      });
+    });
+
+    it("called with hash", (done) => {
+      const sampleAccessToken = {
+        accessToken: "123abc",
+      };
+
+      const hash = "#/test";
+
+      spyOn(
+        PublicClientApplication.prototype,
+        "handleRedirectPromise"
+      ).and.returnValue(
+        new Promise((resolve) => {
+          //@ts-ignore
+          resolve(sampleAccessToken);
+        })
+      );
+
+      authService
+        .handleRedirectObservable(hash)
+        .subscribe((response: AuthenticationResult) => {
+          expect(response.accessToken).toBe(sampleAccessToken.accessToken);
+          expect(
+            PublicClientApplication.prototype.handleRedirectPromise
+          ).toHaveBeenCalledWith(hash);
+          done();
+        });
+    });
+  });
+
+  describe("setLogger", () => {
+    it("works", () => {
+      spyOn(PublicClientApplication.prototype, "setLogger");
+      authService.setLogger(new Logger({}));
+      expect(PublicClientApplication.prototype.setLogger).toHaveBeenCalled();
+    });
+  });
+});

package/src/msal.service.ts

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { Inject, Injectable, Injector } from "@angular/core";
+import { Location } from "@angular/common";
+import {
+  IPublicClientApplication,
+  EndSessionRequest,
+  EndSessionPopupRequest,
+  AuthenticationResult,
+  RedirectRequest,
+  SilentRequest,
+  PopupRequest,
+  SsoSilentRequest,
+  Logger,
+  WrapperSKU,
+} from "@azure/msal-browser";
+import { Observable, from } from "rxjs";
+import { IMsalService } from "./IMsalService";
+import { name, version } from "./packageMetadata";
+import { MSAL_INSTANCE } from "./constants";
+import { MsalBroadcastService } from "./msal.broadcast.service";
+
+@Injectable()
+export class MsalService implements IMsalService {
+  private redirectHash: string;
+  private logger: Logger;
+
+  constructor(
+    @Inject(MSAL_INSTANCE) public instance: IPublicClientApplication,
+    private location: Location,
+    private injector: Injector
+  ) {
+    const hash = this.location.path(true).split("#").pop();
+    if (hash) {
+      this.redirectHash = `#${hash}`;
+    }
+    this.instance.initializeWrapperLibrary(WrapperSKU.Angular, version);
+  }
+
+  initialize(): Observable<void> {
+    return from(this.instance.initialize());
+  }
+  acquireTokenPopup(request: PopupRequest): Observable<AuthenticationResult> {
+    return from(this.instance.acquireTokenPopup(request));
+  }
+  acquireTokenRedirect(request: RedirectRequest): Observable<void> {
+    return from(this.instance.acquireTokenRedirect(request));
+  }
+  acquireTokenSilent(
+    silentRequest: SilentRequest
+  ): Observable<AuthenticationResult> {
+    return from(this.instance.acquireTokenSilent(silentRequest));
+  }
+  handleRedirectObservable(hash?: string): Observable<AuthenticationResult> {
+    return from(
+      this.instance
+        .initialize()
+        .then(() =>
+          this.instance.handleRedirectPromise(hash || this.redirectHash)
+        )
+        .finally(() => {
+          // update inProgress state to none
+          this.injector.get(MsalBroadcastService).resetInProgressEvent();
+        })
+    );
+  }
+  loginPopup(request?: PopupRequest): Observable<AuthenticationResult> {
+    return from(this.instance.loginPopup(request));
+  }
+  loginRedirect(request?: RedirectRequest): Observable<void> {
+    return from(this.instance.loginRedirect(request));
+  }
+  // @deprecated: Use logoutRedirect or logoutPopup
+  logout(logoutRequest?: EndSessionRequest): Observable<void> {
+    return from(this.instance.logout(logoutRequest));
+  }
+  logoutRedirect(logoutRequest?: EndSessionRequest): Observable<void> {
+    return from(this.instance.logoutRedirect(logoutRequest));
+  }
+  logoutPopup(logoutRequest?: EndSessionPopupRequest): Observable<void> {
+    return from(this.instance.logoutPopup(logoutRequest));
+  }
+  ssoSilent(request: SsoSilentRequest): Observable<AuthenticationResult> {
+    return from(this.instance.ssoSilent(request));
+  }
+  /**
+   * Gets logger for msal-angular.
+   * If no logger set, returns logger instance created with same options as msal-browser
+   */
+  getLogger(): Logger {
+    if (!this.logger) {
+      this.logger = this.instance.getLogger().clone(name, version);
+    }
+    return this.logger;
+  }
+  // Create a logger instance for msal-angular with the same options as msal-browser
+  setLogger(logger: Logger): void {
+    this.logger = logger.clone(name, version);
+    this.instance.setLogger(logger);
+  }
+}

package/src/packageMetadata.ts

@@ -0,0 +1,3 @@
+/* eslint-disable header/header */
+export const name = "@azure/msal-angular";
+export const version = "4.0.13";

package/{public-api.d.ts → src/public-api.ts}

@@ -1,17 +1,35 @@
-/**
- * @packageDocumentation
- * @module @azure/msal-angular
- */
-export { MsalService } from "./msal.service";
-export { IMsalService } from "./IMsalService";
-export { MsalGuard } from "./msal.guard";
-export { MsalGuardConfiguration, MsalGuardAuthRequest, } from "./msal.guard.config";
-export { MsalInterceptor } from "./msal.interceptor";
-export { MsalInterceptorConfiguration, MsalInterceptorAuthRequest, ProtectedResourceScopes, } from "./msal.interceptor.config";
-export { MSAL_INSTANCE, MSAL_GUARD_CONFIG, MSAL_INTERCEPTOR_CONFIG, MSAL_BROADCAST_CONFIG, } from "./constants";
-export { MsalBroadcastService } from "./msal.broadcast.service";
-export { MsalBroadcastConfiguration } from "./msal.broadcast.config";
-export { MsalModule } from "./msal.module";
-export { MsalRedirectComponent } from "./msal.redirect.component";
-export { MsalCustomNavigationClient } from "./msal.navigation.client";
-export { version } from "./packageMetadata";
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+/**
+ * @packageDocumentation
+ * @module @azure/msal-angular
+ */
+
+export { MsalService } from "./msal.service";
+export { IMsalService } from "./IMsalService";
+export { MsalGuard } from "./msal.guard";
+export {
+  MsalGuardConfiguration,
+  MsalGuardAuthRequest,
+} from "./msal.guard.config";
+export { MsalInterceptor } from "./msal.interceptor";
+export {
+  MsalInterceptorConfiguration,
+  MsalInterceptorAuthRequest,
+  ProtectedResourceScopes,
+} from "./msal.interceptor.config";
+export {
+  MSAL_INSTANCE,
+  MSAL_GUARD_CONFIG,
+  MSAL_INTERCEPTOR_CONFIG,
+  MSAL_BROADCAST_CONFIG,
+} from "./constants";
+export { MsalBroadcastService } from "./msal.broadcast.service";
+export { MsalBroadcastConfiguration } from "./msal.broadcast.config";
+export { MsalModule } from "./msal.module";
+export { MsalRedirectComponent } from "./msal.redirect.component";
+export { MsalCustomNavigationClient } from "./msal.navigation.client";
+export { version } from "./packageMetadata";

package/src/test.ts

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import "zone.js/dist/zone";
+import "zone.js/dist/zone-testing";
+// eslint-disable-next-line import/no-unresolved
+import { getTestBed } from "@angular/core/testing";
+import {
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting,
+} from "@angular/platform-browser-dynamic/testing"; // eslint-disable-line import/no-unresolved
+
+// First, initialize the Angular testing environment.
+getTestBed().initTestEnvironment(
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting()
+);

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "baseUrl": "./",
+    "outDir": "./dist/out-tsc",
+    "sourceMap": true,
+    "declaration": false,
+    "downlevelIteration": true,
+    "experimentalDecorators": true,
+    "moduleResolution": "node",
+    "importHelpers": true,
+    "target": "es2020",
+    "module": "es2020",
+    "lib": [
+      "ES2020",
+      "dom"
+    ],
+    "paths": {
+      "msal-angular": [
+        "dist/msal-angular"
+      ]
+    },
+    "useDefineForClassFields": false
+  }
+}

package/tsconfig.lib.json

@@ -0,0 +1,27 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./out-tsc/lib",
+    "declarationMap": true,
+    "declaration": true,
+    "inlineSources": true,
+    "types": [],
+    "lib": [
+      "dom",
+      "ES2020"
+    ]
+  },
+  "angularCompilerOptions": {
+    "enableResourceInlining": true,
+    "genDir": "dist",
+    "debug": false,
+    "skipTemplateCodegen": true,
+    "skipMetadataEmit": false,
+    "strictMetadataEmit": true
+  },
+  "exclude": [
+    "src/test.ts",
+    "**/*.spec.ts"
+  ]
+}