@igniteui/angular-templates 17.0.1302 → 17.0.1310-beta.2

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/login-dialog/login-dialog.component.ts

@@ -0,0 +1,30 @@
+import { Component, ViewChild } from '@angular/core';
+import { IgxDialogComponent } from 'igniteui-angular';
+
+@Component({
+  selector: 'app-login-dialog',
+  templateUrl: './login-dialog.component.html',
+  styleUrls: ['./login-dialog.component.scss']
+})
+export class LoginDialogComponent {
+  public showLogin = true;
+  public get title() { return this.showLogin ? 'Login' : 'Register'; }
+  @ViewChild(IgxDialogComponent, { static: true })
+  public loginDialog!: IgxDialogComponent;
+
+  open() {
+    this.loginDialog.open();
+  }
+
+  close() {
+    this.loginDialog.close();
+  }
+
+  onOpen() {
+    this.showLogin = true;
+  }
+
+  toggleView() {
+    this.showLogin = !this.showLogin;
+  }
+}

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/models/login.ts

@@ -0,0 +1,16 @@
+export interface Login {
+  email: string;
+  password: string;
+}
+
+/** Used to send sign in info provided by an external login */
+export interface ExternalLogin {
+  id: string;
+  name: string;
+  given_name?: string;
+  family_name?: string;
+  email: string;
+  picture?: string;
+  externalToken: string;
+  externalProvider?: string;
+}

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/models/register.ts

@@ -0,0 +1,6 @@
+export interface Register {
+  given_name: string;
+  family_name: string;
+  email: string;
+  password: string;
+}

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/models/user.ts

@@ -0,0 +1,20 @@
+/** Data transfer model expected from backend API JWT-s */
+export interface UserJWT {
+  // using registered/public claims per https://www.iana.org/assignments/jwt/jwt.xhtml
+  exp: number;
+  name: string;
+  given_name: string;
+  family_name: string;
+  email: string;
+  picture?: string;
+}
+
+/** Client user model */
+export interface User extends UserJWT {
+  token: string;
+}
+
+export interface LoginResult {
+  user?: User;
+  error?: string;
+}

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/profile/profile.component.html

@@ -0,0 +1,3 @@
+<h3>
+  Hello {{this.userService.currentUser!.name.toUpperCase()}}, you are now logged in!
+</h3>

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/profile/profile.component.spec.ts

@@ -0,0 +1,28 @@
+import { ComponentFixture, TestBed, waitForAsync } from '@angular/core/testing';
+import { UserService } from '../services/user.service';
+import { ProfileComponent } from './profile.component';
+
+describe('ProfileComponent', () => {
+  let component: ProfileComponent;
+  let fixture: ComponentFixture<ProfileComponent>;
+
+  beforeEach(waitForAsync(() => {
+    TestBed.configureTestingModule({
+      declarations: [ProfileComponent],
+      providers: [
+        { provide: UserService, useValue: { currentUser: { name: 'test' } } }
+      ]
+    })
+      .compileComponents();
+  }));
+
+  beforeEach(() => {
+    fixture = TestBed.createComponent(ProfileComponent);
+    component = fixture.componentInstance;
+    fixture.detectChanges();
+  });
+
+  it('should create', () => {
+    expect(component).toBeTruthy();
+  });
+});

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/profile/profile.component.ts

@@ -0,0 +1,11 @@
+import { Component } from '@angular/core';
+import { UserService } from '../services/user.service';
+
+@Component({
+  selector: 'app-profile',
+  templateUrl: './profile.component.html',
+  styleUrls: ['./profile.component.scss']
+})
+export class ProfileComponent {
+  constructor(public userService: UserService) { }
+}

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/providers/auth-provider.ts

@@ -0,0 +1,8 @@
+import { ExternalLogin } from '../models/login';
+
+export interface AuthProvider {
+  config(): void;
+  login(): void;
+  getUserInfo(): Promise<ExternalLogin>;
+  logout(): void;
+}

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/providers/base-oidc-provider.ts

@@ -0,0 +1,71 @@
+import {
+  AuthWellKnownEndpoints,
+  OidcConfigService,
+  OidcSecurityService,
+  OpenIDImplicitFlowConfiguration
+} from 'angular-auth-oidc-client';
+import { take } from 'rxjs/operators';
+import { ExternalLogin } from '../models/login';
+import { ExternalAuthConfig } from '../services/external-auth-configs';
+import { AuthProvider } from './auth-provider';
+
+/** Base provider for OpenID Connect (OIDC) https://openid.net/connect/ */
+export abstract class BaseOidcProvider implements AuthProvider {
+  constructor(
+    protected oidcConfigService: OidcConfigService,
+    protected oidcSecurityService: OidcSecurityService,
+    protected externalStsConfig: ExternalAuthConfig) { }
+
+  public config() {
+    const openIDImplicitFlowConfiguration = new OpenIDImplicitFlowConfiguration();
+    openIDImplicitFlowConfiguration.stsServer = this.externalStsConfig.stsServer;
+    openIDImplicitFlowConfiguration.redirect_url = this.externalStsConfig.redirect_url;
+    openIDImplicitFlowConfiguration.client_id = this.externalStsConfig.client_id;
+    openIDImplicitFlowConfiguration.response_type = this.externalStsConfig.response_type;
+    openIDImplicitFlowConfiguration.scope = this.externalStsConfig.scope;
+    openIDImplicitFlowConfiguration.post_logout_redirect_uri = this.externalStsConfig.redirect_url;
+    openIDImplicitFlowConfiguration.post_login_route = this.externalStsConfig.post_login_route;
+    openIDImplicitFlowConfiguration.auto_userinfo = this.externalStsConfig.auto_userinfo;
+    openIDImplicitFlowConfiguration.max_id_token_iat_offset_allowed_in_seconds =
+      this.externalStsConfig.max_id_token_iat_offset_allowed_in_seconds;
+
+    const authWellKnownEndpoints = new AuthWellKnownEndpoints();
+    authWellKnownEndpoints.setWellKnownEndpoints(this.oidcConfigService.wellKnownEndpoints);
+    this.oidcSecurityService.setupModule(openIDImplicitFlowConfiguration, authWellKnownEndpoints);
+  }
+
+  public login() {
+    this.oidcConfigService.onConfigurationLoaded.pipe(take(1)).subscribe(() => {
+      this.config();
+      this.oidcSecurityService.authorize();
+    });
+    this.oidcConfigService.load_using_stsServer(this.externalStsConfig.stsServer);
+  }
+
+  public getUserInfo(): Promise<ExternalLogin> {
+    let resolve: (val: ExternalLogin) => void;
+    let reject: () => void;
+    const user = new Promise<ExternalLogin>((res, rej) => {
+      resolve = res;
+      reject = rej;
+    });
+    this.oidcConfigService.onConfigurationLoaded.pipe(take(1)).subscribe(() => {
+      this.config();
+      this.oidcSecurityService.onAuthorizationResult.subscribe(() => {
+        this.oidcSecurityService.getUserData().subscribe(userData => {
+          resolve(this.formatUserData(userData));
+        });
+      });
+      this.oidcSecurityService.authorizedImplicitFlowCallback();
+    });
+    this.oidcConfigService.load_using_stsServer(this.externalStsConfig.stsServer);
+    return user;
+  }
+
+  public logout() {
+    this.oidcSecurityService.logoff();
+  }
+
+  /** Format received user data per provider claims */
+  protected abstract formatUserData(userData: { [key: string]: any; }): ExternalLogin;
+}

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/providers/facebook-provider.ts

@@ -0,0 +1,56 @@
+import { Router } from '@angular/router';
+import { ExternalLogin } from '../models/login';
+import { ExternalAuthConfig } from '../services/external-auth-configs';
+import { AuthProvider } from './auth-provider';
+
+export class FacebookProvider implements AuthProvider {
+  private user?: ExternalLogin;
+
+  constructor(private externalStsConfig: ExternalAuthConfig, private router: Router) { }
+
+  public config() {
+    // Requiring HTTPS for Facebook Login
+    // https://developers.facebook.com/blog/post/2018/06/08/enforce-https-facebook-login/
+    FB.init({
+      appId: this.externalStsConfig.client_id,
+      xfbml: false,
+      version: 'v3.1'
+    });
+  }
+
+  public login() {
+    const accessToken = 'accessToken';
+    this.config();
+    FB.login((response) => {
+      if (response.authResponse) {
+        FB.api(
+          '/me?fields=id,email,name,first_name,last_name,picture',
+          (newResponse: { [key: string]: any; }) => {
+            this.user = {
+              id: newResponse.id,
+              name: newResponse.name,
+              given_name: newResponse.first_name,
+              family_name: newResponse.last_name,
+              email: newResponse.email,
+              picture: newResponse.picture,
+              externalToken: FB.getAuthResponse()[accessToken]
+            };
+            this.router.navigate([this.externalStsConfig.redirect_url]);
+          });
+      } else {
+        console.log('User cancelled login or did not fully authorize.');
+      }
+    }, { scope: 'public_profile' });
+  }
+
+  public getUserInfo(): Promise<ExternalLogin> {
+    if (!this.user) {
+      throw "User not logged in";
+    }
+    return Promise.resolve(this.user);
+  }
+
+  public logout() {
+    FB.logout((response) => { });
+  }
+}

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/providers/google-provider.ts

@@ -0,0 +1,23 @@
+import { ExternalLogin } from '../models/login';
+import { BaseOidcProvider } from './base-oidc-provider';
+
+export class GoogleProvider extends BaseOidcProvider {
+  /**
+   * Format user data per provider claims:
+   * https://developers.google.com/identity/protocols/OpenIDConnect
+   * https://developers.google.com/+/web/api/rest/openidconnect/getOpenIdConnect
+   */
+  protected formatUserData(userData: { [key: string]: any; }): ExternalLogin {
+    const login: ExternalLogin = {
+      id: userData.sub,
+      name: userData.name,
+      email: userData.email,
+      given_name: userData.given_name,
+      family_name: userData.family_name,
+      picture: userData.picture,
+      externalToken: this.oidcSecurityService.getToken()
+
+    };
+    return login;
+  }
+}

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/providers/microsoft-provider.ts

@@ -0,0 +1,44 @@
+import { ExternalLogin } from '../models/login';
+import { BaseOidcProvider } from './base-oidc-provider';
+
+export class MicrosoftProvider extends BaseOidcProvider {
+  public static keysURL = 'ms-discovery/keys';
+
+  /** ADD endpoint specific tenant + ID, used when connecting users from work or school accounts.
+   * https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-protocols-oidc#fetch-the-openid-connect-metadata-document
+   */
+  public tenant = 'consumers';
+  public tenantID = '';
+
+  public config() {
+    if (this.tenant !== 'consumers') {
+      // Replace common discovery URL issuer with correct tenant ID for token validation:
+      this.oidcConfigService.wellKnownEndpoints.issuer =
+        this.oidcConfigService.wellKnownEndpoints.issuer.replace('{tenantid}', this.tenantID);
+    }
+
+    // Microsoft OIDC doesn't support CORS for keys discovery URIs, intended for backend
+    // See https://stackoverflow.com/a/44688644
+    // Example implementation:
+    // tslint:disable-next-line:max-line-length
+    // https://blogs.msdn.microsoft.com/mihansen/2018/07/12/net-core-angular-app-with-openid-connection-implicit-flow-authentication-angular-auth-oidc-client/
+    // https://docs.microsoft.com/en-us/azure/active-directory/develop/v2-protocols-oidc
+    this.oidcConfigService.wellKnownEndpoints.jwks_uri = MicrosoftProvider.keysURL;
+    super.config();
+  }
+
+  /**
+   * Format user data response from available claims:
+   * https://docs.microsoft.com/en-us/azure/active-directory/develop/id-tokens#payload-claims
+   */
+  protected formatUserData(userData: { [key: string]: any; }): ExternalLogin {
+    const login: ExternalLogin = {
+      id: userData.oid,
+      name: userData.name,
+      email: userData.email,
+      externalToken: this.oidcSecurityService.getToken()
+
+    };
+    return login;
+  }
+}

package/igx-ts-legacy/projects/side-nav-auth/files/src/app/authentication/providers/providers.spec.ts

@@ -0,0 +1,305 @@
+import { FacebookProvider } from './facebook-provider';
+import { GoogleProvider } from './google-provider';
+import { MicrosoftProvider } from './microsoft-provider';
+
+describe('Providers', () => {
+  const MOCK_EXTERNAL_AUTH_CONFIG = {
+    stsServer: 'test-stsServer',
+    redirect_url: 'test-redirect_url',
+    client_id: 'test-client_id',
+    response_type: 'test-response_type',
+    scope: 'test-scope',
+    post_login_route: 'test-post_login_route',
+    auto_userinfo: 'test-auto_userinfo',
+    max_id_token_iat_offset_allowed_in_seconds: 'test-max_id_token_iat_offset_allowed_in_seconds'
+  } as any;
+  const MOCK_ROUTER = {
+    navigate: () => { }
+  } as any;
+  const MOCK_OIDC_CONFIG = {
+    wellKnownEndpoints: {
+      issuer: ''
+    },
+    load_using_stsServer: () => { },
+    onConfigurationLoaded: {
+      pipe: () => { }
+    }
+  } as any;
+  const MOCK_OIDC_SECURITY = {
+    setupModule: () => { },
+    authorize: () => { },
+    getToken: () => { },
+    onAuthorizationResult: () => { },
+    authorizedImplicitFlowCallback: () => { },
+    getUserData: () => { },
+    logoff: () => { }
+  } as any;
+  describe('Facebook Provider', () => {
+    const facebookProviderName = 'FB';
+    let mockResponse: any = {};
+    let mockAPIObj = {
+      id: 'mock-id',
+      name: 'mock-name',
+      first_name: 'mock-first_name',
+      last_name: 'mock_last_name',
+      email: 'mock_email',
+      picture: 'mock_picture'
+    };
+    global[facebookProviderName] = {
+      login: (callback: (obj: any) => void, scope: { scope: string }) => { callback({ authResponse: mockResponse }); },
+      init: () => { },
+      api: (params: string, callback: (obj: any) => void) => { callback(mockAPIObj); },
+      getAuthResponse: (): any => { return { accessToken: 'mockAccessToken' } },
+      logout: () => { },
+      AppEvents: null,
+      Canvas: null,
+      Event: null,
+      getLoginStatus: (): any => null,
+      ui: (params: any, callback: (response: any) => void): void => { },
+      XFBML: null
+    };
+    it('Should properly initialize', () => {
+      const provider = new FacebookProvider(MOCK_EXTERNAL_AUTH_CONFIG, MOCK_ROUTER);
+      expect(provider).toBeDefined();
+    });
+
+    it('Should properly call config', () => {
+      const provider = new FacebookProvider(MOCK_EXTERNAL_AUTH_CONFIG, MOCK_ROUTER);
+      spyOn(FB, 'init');
+      provider.config();
+      expect(FB.init).toHaveBeenCalled();
+      expect(FB.init).toHaveBeenCalledWith({
+        appId: MOCK_EXTERNAL_AUTH_CONFIG.client_id,
+        xfbml: false,
+        version: 'v3.1'
+      });
+    });
+
+    it('Should properly call login', () => {
+      const provider = new FacebookProvider(MOCK_EXTERNAL_AUTH_CONFIG, MOCK_ROUTER);
+      spyOn(provider, 'config');
+      spyOn(FB, 'login').and.callThrough();
+      spyOn(console, 'log').and.callThrough();
+      spyOn(FB, 'api').and.callThrough();
+      mockResponse = false;
+      provider.login();
+      expect(provider.config).toHaveBeenCalledTimes(1);
+      expect(FB.login).toHaveBeenCalledTimes(1);
+      expect(FB.api).not.toHaveBeenCalled();
+      expect(console.log).toHaveBeenCalledWith('User cancelled login or did not fully authorize.');
+      spyOn(FB, 'getAuthResponse').and.returnValue({ accessToken: 'Fake' } as any);
+      spyOn(MOCK_ROUTER, 'navigate');
+      mockResponse = true;
+      const mockObj = {
+        id: 'test id',
+        name: 'test name',
+        first_name: 'test first name',
+        last_name: 'test family name',
+        email: 'test email',
+        picture: 'test picture'
+      };
+      const expectedObject = {
+        id: 'test id',
+        name: 'test name',
+        given_name: 'test first name',
+        family_name: 'test family name',
+        email: 'test email',
+        picture: 'test picture',
+        externalToken: 'Fake'
+      };
+      mockAPIObj = mockObj;
+      provider.login();
+      expect(provider.config).toHaveBeenCalledTimes(2);
+      expect(FB.login).toHaveBeenCalledTimes(2);
+      expect(FB.api).toHaveBeenCalled();
+      expect(MOCK_ROUTER.navigate).toHaveBeenCalledWith([MOCK_EXTERNAL_AUTH_CONFIG.redirect_url]);
+      expect((provider as any).user).toEqual(expectedObject);
+    });
+
+    it(`Should properly call 'getUserInfo'`, () => {
+      const provider = new FacebookProvider(MOCK_EXTERNAL_AUTH_CONFIG, MOCK_ROUTER);
+      provider.login();
+      spyOn(Promise, 'resolve').and.returnValue('Mock' as any);
+      expect(provider.getUserInfo()).toEqual('Mock' as any);
+    });
+
+    it(`Should properly call 'logout'`, () => {
+      const provider = new FacebookProvider(MOCK_EXTERNAL_AUTH_CONFIG, MOCK_ROUTER);
+      spyOn(FB, 'logout');
+      provider.logout();
+      expect(FB.logout).toHaveBeenCalled();
+    });
+  });
+
+  describe('Google Provider', () => {
+
+    it('Should properly initialize', () => {
+      const provider = new GoogleProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
+      expect(provider).toBeDefined();
+    });
+
+    it('Should properly call config', () => {
+      const provider = new GoogleProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
+      spyOn(MOCK_OIDC_SECURITY, 'setupModule').and.callThrough();
+      provider.config();
+      expect(MOCK_OIDC_SECURITY.setupModule).toHaveBeenCalled();
+    });
+
+    it('Should properly call login', () => {
+      const provider = new GoogleProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
+      const mockSub = {
+        subscribe: (fn: () => {}) => {
+          fn.apply(MOCK_OIDC_SECURITY);
+        }
+      };
+      spyOn(mockSub, 'subscribe').and.callThrough();
+      spyOn(MOCK_OIDC_SECURITY, 'authorize');
+      spyOn(MOCK_OIDC_CONFIG.onConfigurationLoaded, 'pipe').and.returnValue(mockSub);
+      spyOn(MOCK_OIDC_CONFIG, 'load_using_stsServer');
+      const mockSpy = spyOn(provider, 'config');
+      provider.login();
+      expect(mockSub.subscribe).toHaveBeenCalled();
+      expect(mockSpy).toHaveBeenCalled();
+      expect(MOCK_OIDC_SECURITY.authorize).toHaveBeenCalled();
+      expect(MOCK_OIDC_CONFIG.load_using_stsServer).toHaveBeenCalled();
+    });
+
+    it(`Should properly call 'formatUserData'`, () => {
+      const provider = new GoogleProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
+      const mockObj = {
+        sub: 'test-id',
+        name: 'test-name',
+        email: 'test-email',
+        given_name: 'test-given_name',
+        family_name: 'test-family_name',
+        picture: 'test-picture'
+      };
+      spyOn(MOCK_OIDC_SECURITY, 'getToken').and.returnValue('FAKE');
+      expect((provider as any).formatUserData(mockObj)).toEqual({
+        id: mockObj.sub,
+        name: mockObj.name,
+        email: mockObj.email,
+        given_name: mockObj.given_name,
+        family_name: mockObj.family_name,
+        picture: mockObj.picture,
+        externalToken: 'FAKE'
+      });
+    });
+
+    it('Should properly call getUserInfo', () => {
+      const provider = new GoogleProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
+      const mockSub = {
+        subscribe: (fn: () => {}) => {
+          fn.apply(this);
+        }
+      };
+      spyOn(mockSub, 'subscribe').and.callThrough();
+      spyOn(MOCK_OIDC_CONFIG.onConfigurationLoaded, 'pipe').and.returnValue(mockSub);
+      spyOn(provider, 'config');
+      spyOn(MOCK_OIDC_CONFIG, 'load_using_stsServer');
+      MOCK_OIDC_SECURITY.onAuthorizationResult = mockSub;
+      spyOn(MOCK_OIDC_SECURITY, 'getUserData').and.returnValue(mockSub);
+      spyOn(MOCK_OIDC_SECURITY, 'authorizedImplicitFlowCallback');
+      const formatDataSpy = spyOn<any>(provider, 'formatUserData');
+      provider.getUserInfo();
+      expect(mockSub.subscribe).toHaveBeenCalled();
+      expect(mockSub.subscribe).toHaveBeenCalledTimes(3);
+      expect(formatDataSpy).toHaveBeenCalled();
+      expect(provider.config).toHaveBeenCalled();
+      expect(MOCK_OIDC_SECURITY.authorizedImplicitFlowCallback).toHaveBeenCalled();
+      expect(MOCK_OIDC_CONFIG.load_using_stsServer).toHaveBeenCalled();
+    });
+
+    it('Should properly call logout', () => {
+      const provider = new GoogleProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
+      spyOn(MOCK_OIDC_SECURITY, 'logoff').and.callThrough();
+      provider.logout();
+      expect(MOCK_OIDC_SECURITY.logoff).toHaveBeenCalled();
+    });
+  });
+
+  describe('Microsoft Provider', () => {
+
+    it('Should properly initialize', () => {
+      const provider = new MicrosoftProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
+      expect(provider).toBeDefined();
+    });
+
+    it('Should properly call config', () => {
+      const provider = new MicrosoftProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
+      spyOn(MOCK_OIDC_SECURITY, 'setupModule').and.callThrough();
+      provider.config();
+      expect(MOCK_OIDC_SECURITY.setupModule).toHaveBeenCalled();
+    });
+
+    it('Should properly call config if tenant !== consumer', () => {
+      const provider = new MicrosoftProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
+      provider.tenant = 'test';
+      provider.tenantID = 'test_id';
+      const replaceSpy = spyOn<any>(String.prototype, 'replace');
+      spyOn(MOCK_OIDC_SECURITY, 'setupModule').and.callThrough();
+      provider.config();
+      expect(replaceSpy).toHaveBeenCalledWith('{tenantid}', 'test_id');
+      expect(MOCK_OIDC_SECURITY.setupModule).toHaveBeenCalled();
+    });
+
+    it('Should properly call login', () => {
+      const provider = new MicrosoftProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
+      const mockSub = {
+        subscribe: (fn: () => {}) => {
+          fn.apply(MOCK_OIDC_SECURITY);
+        }
+      };
+      spyOn(mockSub, 'subscribe').and.callThrough();
+      spyOn(MOCK_OIDC_SECURITY, 'authorize');
+      spyOn(MOCK_OIDC_CONFIG.onConfigurationLoaded, 'pipe').and.returnValue(mockSub);
+      spyOn(MOCK_OIDC_CONFIG, 'load_using_stsServer');
+      const mockSpy = spyOn(provider, 'config');
+      provider.login();
+      expect(mockSub.subscribe).toHaveBeenCalled();
+      expect(mockSpy).toHaveBeenCalled();
+      expect(MOCK_OIDC_SECURITY.authorize).toHaveBeenCalled();
+      expect(MOCK_OIDC_CONFIG.load_using_stsServer).toHaveBeenCalled();
+    });
+
+    it('Should properly call getUserInfo', () => {
+      const provider = new MicrosoftProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
+      const mockSub = {
+        subscribe: (fn: () => {}) => {
+          fn.apply(MOCK_OIDC_SECURITY);
+        }
+      };
+      spyOn(mockSub, 'subscribe').and.callThrough();
+      spyOn(MOCK_OIDC_CONFIG.onConfigurationLoaded, 'pipe').and.returnValue(mockSub);
+      spyOn(MOCK_OIDC_CONFIG, 'load_using_stsServer');
+      spyOn(provider, 'config');
+      spyOn(MOCK_OIDC_SECURITY, 'authorizedImplicitFlowCallback');
+      MOCK_OIDC_SECURITY.onAuthorizationResult = mockSub;
+      spyOn(MOCK_OIDC_SECURITY, 'getUserData').and.returnValue(mockSub);
+      const formatDataSpy = spyOn<any>(provider, 'formatUserData');
+      provider.getUserInfo();
+      expect(mockSub.subscribe).toHaveBeenCalled();
+      expect(mockSub.subscribe).toHaveBeenCalledTimes(3);
+      expect(formatDataSpy).toHaveBeenCalled();
+      expect(provider.config).toHaveBeenCalled();
+      expect(MOCK_OIDC_SECURITY.authorizedImplicitFlowCallback).toHaveBeenCalled();
+      expect(MOCK_OIDC_CONFIG.load_using_stsServer).toHaveBeenCalled();
+    });
+
+    it(`Should properly call 'formatUserData'`, () => {
+      const provider = new MicrosoftProvider(MOCK_OIDC_CONFIG, MOCK_OIDC_SECURITY, MOCK_EXTERNAL_AUTH_CONFIG);
+      const mockObj = {
+        oid: 'test-id',
+        name: 'test-name',
+        email: 'test-email',
+      };
+      spyOn(MOCK_OIDC_SECURITY, 'getToken').and.returnValue('FAKE');
+      expect((provider as any).formatUserData(mockObj)).toEqual({
+        id: mockObj.oid,
+        name: mockObj.name,
+        email: mockObj.email,
+        externalToken: 'FAKE'
+      });
+    });
+  });
+});