@azure/msal-angular 3.0.0-beta.1 → 3.0.0

package/src/msal.service.spec.ts

@@ -0,0 +1,452 @@
+import { TestBed } from '@angular/core/testing';
+import {
+  AuthenticationResult,
+  AuthError,
+  InteractionType,
+  Logger,
+  PublicClientApplication,
+  SilentRequest,
+} from '@azure/msal-browser';
+import { MsalModule, MsalBroadcastService, MsalService } from './public-api';
+
+let authService: MsalService;
+let broadcastService: MsalBroadcastService;
+
+const msalInstance = new PublicClientApplication({
+  auth: {
+    clientId: '6226576d-37e9-49eb-b201-ec1eeb0029b6',
+    redirectUri: 'http://localhost:4200',
+  },
+});
+
+function initializeMsal() {
+  TestBed.resetTestingModule();
+
+  TestBed.configureTestingModule({
+    imports: [
+      MsalModule.forRoot(msalInstance, null, {
+        interactionType: InteractionType.Popup,
+        protectedResourceMap: new Map(),
+      }),
+    ],
+    providers: [MsalService, MsalBroadcastService],
+  });
+
+  authService = TestBed.inject(MsalService);
+  broadcastService = TestBed.inject(MsalBroadcastService);
+}
+
+describe('MsalService', () => {
+  beforeAll(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.message).toBe(sampleError.message);
+          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.message).toBe(sampleError.message);
+          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.message).toBe(sampleError.message);
+          expect(
+            PublicClientApplication.prototype.acquireTokenPopup
+          ).toHaveBeenCalledWith(request);
+          done();
+        },
+      });
+    });
+  });
+
+  describe('handleRedirectObservable', () => {
+    it('success', (done) => {
+      const sampleAccessToken = {
+        accessToken: '123abc',
+      };
+
+      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();
+          done();
+        });
+    });
+
+    it('failure', (done) => {
+      const sampleError = new AuthError('123', 'message');
+
+      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();
+          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,97 @@
+/*
+ * Copyright (c) Microsoft Corporation. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { Inject, Injectable } 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';
+
+@Injectable()
+export class MsalService implements IMsalService {
+  private redirectHash: string;
+  private logger: Logger;
+
+  constructor(
+    @Inject(MSAL_INSTANCE) public instance: IPublicClientApplication,
+    private location: Location
+  ) {
+    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)
+        )
+    );
+  }
+  loginPopup(request?: PopupRequest): Observable<AuthenticationResult> {
+    return from(this.instance.loginPopup(request));
+  }
+  loginRedirect(request?: RedirectRequest): Observable<void> {
+    return from(this.instance.loginRedirect(request));
+  }
+  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 = "3.0.0";

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"
+  ]
+}

package/tsconfig.lib.prod.json

@@ -0,0 +1,10 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false,
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}