Merge branch 'dev' into fix-expiration-issues

Author: pkanher617

lerna.json

@@ -15,7 +15,7 @@
   },
   "packages": [
     "lib/*",
-    "samples/*"
+    "samples/**/*"
   ],
   "version": "independent",
   "concurrency": 2

lib/msal-browser/docs/acquire-token.md

@@ -39,7 +39,7 @@ msalInstance.acquireTokenSilent(request).then(tokenResponse => {
         return myMSALObj.acquireTokenPopup(request);
     }
 }).catch(error => {
-    console.log(error);
+    handleError(error);
 });
 ```
 

lib/msal-browser/docs/token-lifetimes.md

@@ -53,7 +53,7 @@ const tokenResponse = await msalInstance.acquireTokenSilent(silentRequest).catch
     if (error instanceof InteractionRequiredAuthError) {
         // fallback to interaction when silent call fails
         return await myMSALObj.acquireTokenPopup(request).catch(error => {
-            console.log(error);
+            handleError(error);
         });
     }
 });

lib/msal-browser/docs/v1-migration.md

@@ -70,7 +70,7 @@ myMSALObj.handleRedirectPromise().then((tokenResponse) => {
     const username = accountObj.username;
 
 }).catch((error) => {
-    console.log(error);
+    handleError(error);
 });
 
 function signIn() {
@@ -79,7 +79,7 @@ function signIn() {
 
 async function getTokenRedirect(request) {
     return await myMSALObj.acquireTokenSilent(request).catch(error => {
-        console.log("silent token acquisition fails. acquiring token using redirect");
+        this.logger.info("silent token acquisition fails. acquiring token using redirect");
         // fallback to interaction when silent call fails
         return myMSALObj.acquireTokenRedirect(request)
     });
@@ -95,7 +95,7 @@ async function signIn(method) {
     try {
         const loginResponse = await myMSALObj.loginPopup(loginRequest);
     } catch (err) {
-        console.log(error);
+        handleError(error);
     }
 
     const currentAccounts = myMSALObj.getAllAccounts();
@@ -111,10 +111,10 @@ async function signIn(method) {
 
 async function getTokenPopup(request) {
     return await myMSALObj.acquireTokenSilent(request).catch(async (error) => {
-        console.log("silent token acquisition fails. acquiring token using popup");
+        this.logger.info("silent token acquisition fails. acquiring token using popup");
         // fallback to interaction when silent call fails
         return await myMSALObj.acquireTokenPopup(request).catch(error => {
-            console.log(error);
+            handleError(error);
         });
     });
 }

lib/msal-browser/src/cache/BrowserStorage.ts

@@ -125,8 +125,7 @@ export class BrowserStorage extends CacheManager {
                 break;
             }
             default: {
-                console.log("Invalid Cache Type");
-                return;
+                throw BrowserAuthError.createInvalidCacheTypeError();
             }
         }
     }
@@ -174,8 +173,7 @@ export class BrowserStorage extends CacheManager {
                 return value;
             }
             default: {
-                console.log("Invalid Cache Type");
-                return {};
+                throw BrowserAuthError.createInvalidCacheTypeError();
             }
         }
     }

lib/msal-browser/src/error/BrowserAuthError.ts

@@ -76,6 +76,10 @@ export const BrowserAuthErrorMessage = {
         code: "token_request_cache_error",
         desc: "The token request could not be fetched from the cache correctly."
     },
+    invalidCacheType: {
+        code: "invalid_cache_type",
+        desc: "Invalid cache type"
+    }
 };
 
 /**
@@ -228,4 +232,11 @@ export class BrowserAuthError extends AuthError {
         return new BrowserAuthError(BrowserAuthErrorMessage.tokenRequestCacheError.code,
             `${BrowserAuthErrorMessage.tokenRequestCacheError.desc} Error Detail: ${errDetail}`);
     }
+
+    /**
+    * Creates an error thrown if cache type is invalid.
+    */
+    static createInvalidCacheTypeError(): BrowserAuthError {
+        return new BrowserAuthError(BrowserAuthErrorMessage.invalidCacheType.code, `${BrowserAuthErrorMessage.invalidCacheType.desc}`);
+    }
 }

lib/msal-browser/test/cache/BrowserStorage.spec.ts

@@ -133,13 +133,29 @@ describe("BrowserStorage() tests", () => {
             expect(window.localStorage.getItem(msalCacheKey)).to.be.eq(cacheVal);
         });
 
+        it("setItem() throws error if type passed in is not one of CacheSchemaType types", () => {
+            expect(() => browserSessionStorage.setItem(msalCacheKey, cacheVal, "OTHER_TYPE")).to.throw(BrowserAuthError);
+            expect(() => browserSessionStorage.setItem(msalCacheKey, cacheVal, "OTHER_TYPE")).to.throw(BrowserAuthErrorMessage.invalidCacheType.desc);
+            expect(() => browserLocalStorage.setItem(msalCacheKey, cacheVal, "OTHER_TYPE")).to.throw(BrowserAuthError);
+            expect(() => browserLocalStorage.setItem(msalCacheKey, cacheVal, "OTHER_TYPE")).to.throw(BrowserAuthErrorMessage.invalidCacheType.desc);
+        });
+
         it("getItem()", () => {
             window.sessionStorage.setItem(msalCacheKey, cacheVal);
             window.localStorage.setItem(msalCacheKey, cacheVal);
             expect(browserSessionStorage.getItem(msalCacheKey, CacheSchemaType.TEMPORARY)).to.be.eq(cacheVal);
             expect(browserLocalStorage.getItem(msalCacheKey, CacheSchemaType.TEMPORARY)).to.be.eq(cacheVal);
         });
 
+        it("getItem() throws error if type passed in is not one of CacheSchemaType types", () => {
+            window.sessionStorage.setItem(msalCacheKey, cacheVal);
+            window.localStorage.setItem(msalCacheKey, cacheVal);
+            expect(() => browserSessionStorage.getItem(msalCacheKey, "OTHER_TYPE")).to.throw(BrowserAuthError);
+            expect(() => browserSessionStorage.getItem(msalCacheKey, "OTHER_TYPE")).to.throw(BrowserAuthErrorMessage.invalidCacheType.desc);
+            expect(() => browserLocalStorage.getItem(msalCacheKey, "OTHER_TYPE")).to.throw(BrowserAuthError);
+            expect(() => browserLocalStorage.getItem(msalCacheKey, "OTHER_TYPE")).to.throw(BrowserAuthErrorMessage.invalidCacheType.desc);
+        });
+
         it("removeItem()", () => {
             browserSessionStorage.setItem(msalCacheKey, cacheVal, CacheSchemaType.TEMPORARY);
             browserLocalStorage.setItem(msalCacheKey, cacheVal, CacheSchemaType.TEMPORARY);

lib/msal-browser/test/error/BrowserAuthError.spec.ts

@@ -244,9 +244,9 @@ describe("BrowserAuthError Unit Tests", () => {
         expect(err.message).to.include(BrowserAuthErrorMessage.silentPromptValueError.desc);
         expect(err.name).to.equal("BrowserAuthError");
         expect(err.stack).to.include("BrowserAuthError.spec.ts");
-	});
+    });
 
-	it("createTokenRequestCacheError creates a ClientAuthError object", () => {
+    it("createTokenRequestCacheError creates a ClientAuthError object", () => {
         const err: BrowserAuthError = BrowserAuthError.createTokenRequestCacheError("Couldn't parse request from cache");
 
         expect(err instanceof BrowserAuthError).to.be.true;
@@ -258,4 +258,17 @@ describe("BrowserAuthError Unit Tests", () => {
         expect(err.name).to.equal("BrowserAuthError");
         expect(err.stack).to.include("BrowserAuthError.spec.ts");
     });
+
+    it("createInvalidCacheTypeError()", () => {
+        const err: BrowserAuthError = BrowserAuthError.createInvalidCacheTypeError();
+
+        expect(err instanceof BrowserAuthError).to.be.true;
+        expect(err instanceof AuthError).to.be.true;
+        expect(err instanceof Error).to.be.true;
+        expect(err.errorCode).to.equal(BrowserAuthErrorMessage.invalidCacheType.code);
+        expect(err.errorMessage).to.include(BrowserAuthErrorMessage.invalidCacheType.desc);
+        expect(err.message).to.include(BrowserAuthErrorMessage.invalidCacheType.desc);
+        expect(err.name).to.equal("BrowserAuthError");
+        expect(err.stack).to.include("BrowserAuthError.spec.ts");
+    });
 });

lib/msal-common/src/cache/entities/AccountEntity.ts

@@ -84,8 +84,7 @@ export class AccountEntity {
             case CacheAccountType.GENERIC_ACCOUNT_TYPE:
                 return CacheType.GENERIC;
             default: {
-                console.log("Unexpected account type");
-                return null;
+                throw ClientAuthError.createUnexpectedAccountTypeError();
             }
         }
     }

lib/msal-common/src/cache/entities/CredentialEntity.ts

@@ -4,6 +4,7 @@
  */
 
 import { Separators, CredentialType, CacheType, Constants } from "../../utils/Constants";
+import { ClientAuthError } from "../../error/ClientAuthError";
 
 /**
  * Base type for credentials to be stored in the cache: eg: ACCESS_TOKEN, ID_TOKEN etc
@@ -87,8 +88,7 @@ export class CredentialEntity {
             case CredentialType.REFRESH_TOKEN:
                 return CacheType.REFRESH_TOKEN;
             default: {
-                console.log("Unexpected credential type");
-                return null;
+                throw ClientAuthError.createUnexpectedCredentialTypeError();
             }
         }
     }

lib/msal-common/src/error/ClientAuthError.ts

@@ -134,6 +134,18 @@ export const ClientAuthErrorMessage = {
     noCryptoObj: {
         code: "no_crypto_object",
         desc: "No crypto object detected. This is required for the following operation: "
+    },
+    invalidCacheType: {
+        code: "invalid_cache_type",
+        desc: "Invalid cache type"
+    },
+    unexpectedAccountType: {
+        code: "unexpected_account_type",
+        desc: "Unexpected account type."
+    },
+    unexpectedCredentialType: {
+        code: "unexpected_credential_type",
+        desc: "Unexpected credential type."
     }
 };
 
@@ -389,4 +401,25 @@ export class ClientAuthError extends AuthError {
     static createNoCryptoObjectError(operationName: string): ClientAuthError {
         return new ClientAuthError(ClientAuthErrorMessage.noCryptoObj.code, `${ClientAuthErrorMessage.noCryptoObj.desc}${operationName}`);
     }
+
+    /**
+    * Throws error if cache type is invalid.
+    */
+    static createInvalidCacheTypeError(): ClientAuthError {
+        return new ClientAuthError(ClientAuthErrorMessage.invalidCacheType.code, `${ClientAuthErrorMessage.invalidCacheType.desc}`);
+    }
+
+    /**
+    * Throws error if unexpected account type.
+    */
+    static createUnexpectedAccountTypeError(): ClientAuthError {
+        return new ClientAuthError(ClientAuthErrorMessage.unexpectedAccountType.code, `${ClientAuthErrorMessage.unexpectedAccountType.desc}`);
+    }
+
+    /**
+    * Throws error if unexpected credential type.
+    */
+    static createUnexpectedCredentialTypeError(): ClientAuthError {
+        return new ClientAuthError(ClientAuthErrorMessage.unexpectedCredentialType.code, `${ClientAuthErrorMessage.unexpectedCredentialType.desc}`);
+    }
 }

lib/msal-common/src/request/RequestValidator.ts

@@ -80,7 +80,6 @@ export class RequestValidator {
         // Remove any query parameters already included in SSO params
         queryParams.forEach((value, key) => {
             if (eQParams[key]) {
-                console.log("Removed param " + key + " from extraQueryParameters since it was already present in library query parameters.");
                 delete eQParams[key];
             }
         });

lib/msal-common/test/cache/entities/AccessTokenEntity.spec.ts

@@ -1,6 +1,8 @@
 import { expect } from "chai";
 import { AccessTokenEntity } from "../../../src/cache/entities/AccessTokenEntity";
 import { mockCache } from "./cacheConstants";
+import { ClientAuthError, ClientAuthErrorMessage } from "../../../src";
+import { CacheType } from "../../../src/utils/Constants";
 
 describe("AccessTokenEntity.ts Unit Tests", () => {
 
@@ -10,9 +12,20 @@ describe("AccessTokenEntity.ts Unit Tests", () => {
     });
 
     it("Generate AccessTokenEntity key", () => {
-        let at = mockCache.createMockATOne();
+        const at = mockCache.createMockATOne();
         expect(at.generateCredentialKey()).to.eql(
             "uid.utid-login.microsoftonline.com-accesstoken-mock_client_id-microsoft-scope1 scope2 scope3"
         );
     });
+
+    it("Throws error if AccessTokenEntity is not assigned a type", () => {
+        const at = new AccessTokenEntity();
+        expect(() => at.generateType()).to.throw(ClientAuthError);
+        expect(() => at.generateType()).to.throw(ClientAuthErrorMessage.unexpectedCredentialType.desc);
+    });
+
+    it("Generate AccessTokenEntity type", () => {
+        const at = mockCache.createMockATOne();
+        expect(at.generateType()).to.eql(CacheType.ACCESS_TOKEN);
+    });
 });

lib/msal-common/test/cache/entities/AccountEntity.spec.ts

@@ -8,6 +8,7 @@ import { NetworkRequestOptions, INetworkModule } from "../../../src/network/INet
 import { ICrypto, PkceCodes } from "../../../src/crypto/ICrypto";
 import { RANDOM_TEST_GUID, TEST_DATA_CLIENT_INFO, TEST_CONFIG, TEST_TOKENS, TEST_URIS } from "../../utils/StringConstants";
 import sinon from "sinon";
+import { ClientAuthError, ClientAuthErrorMessage } from "../../../src";
 import { ClientTestUtils } from "../../client/ClientTestUtils";
 
 describe("AccountEntity.ts Unit Tests", () => {
@@ -25,13 +26,25 @@ describe("AccountEntity.ts Unit Tests", () => {
     });
 
     it("generate an AccountEntityKey", () => {
-        let ac = new AccountEntity();
+        const ac = new AccountEntity();
         Object.assign(ac, mockAccountEntity);
         expect(ac.generateAccountKey()).to.eql(
             "uid.utid-login.microsoftonline.com-microsoft"
         );
     });
 
+    it("throws error if account entity is not assigned a type", () => {
+        const ac = new AccountEntity();
+        expect(() => ac.generateType()).to.throw(ClientAuthError);
+        expect(() => ac.generateType()).to.throw(ClientAuthErrorMessage.unexpectedAccountType.desc);
+    });
+
+    it("generate type of the cache", () => {
+        const ac = new AccountEntity();
+        Object.assign(ac, mockAccountEntity);
+        expect(ac.generateType()).to.eql(1003);
+    });
+
     it("create an Account", () => {
         let cryptoInterface: ICrypto = {
             createNewGuid(): string {

lib/msal-common/test/cache/entities/IdTokenEntity.spec.ts

@@ -1,6 +1,8 @@
 import { expect } from "chai";
 import { IdTokenEntity } from "../../../src/cache/entities/IdTokenEntity";
 import { mockIdTokenEntity } from "./cacheConstants";
+import { ClientAuthError, ClientAuthErrorMessage } from "../../../src";
+import { CacheType } from "../../../src/utils/Constants";
 
 describe("IdTokenEntity.ts Unit Tests", () => {
     it("Verify an IdTokenEntity", () => {
@@ -9,10 +11,22 @@ describe("IdTokenEntity.ts Unit Tests", () => {
     });
 
     it("Create an IdTokenEntity", () => {
-        let idT = new IdTokenEntity();
+        const idT = new IdTokenEntity();
         Object.assign(idT, mockIdTokenEntity);
         expect(idT.generateCredentialKey()).to.eql(
             "uid.utid-login.microsoftonline.com-idtoken-mock_client_id-microsoft-"
         );
     });
+
+    it("Throws error if IdTokenEntity is not assigned a type", () => {
+        const idT = new IdTokenEntity();
+        expect(() => idT.generateType()).to.throw(ClientAuthError);
+        expect(() => idT.generateType()).to.throw(ClientAuthErrorMessage.unexpectedCredentialType.desc);
+    });
+
+    it("Generate IdTokenEntity type", () => {
+        const idT = new IdTokenEntity();
+        Object.assign(idT, mockIdTokenEntity);
+        expect(idT.generateType()).to.eql(CacheType.ID_TOKEN);
+    });
 });

lib/msal-common/test/cache/entities/RefreshTokenEntity.spec.ts

@@ -1,6 +1,8 @@
 import { expect } from "chai";
 import { RefreshTokenEntity } from "../../../src/cache/entities/RefreshTokenEntity";
 import { mockRefreshTokenEntity, mockRefreshTokenEntityWithFamilyId } from "./cacheConstants";
+import { ClientAuthError, ClientAuthErrorMessage } from "../../../src";
+import { CacheType } from "../../../src/utils/Constants";
 
 describe("RefreshTokenEntity.ts Unit Tests", () => {
     it("Verify a RefreshTokenEntity", () => {
@@ -9,18 +11,30 @@ describe("RefreshTokenEntity.ts Unit Tests", () => {
     });
 
     it("Create a RefreshTokenEntity", () => {
-        let rt = new RefreshTokenEntity();
+        const rt = new RefreshTokenEntity();
         Object.assign(rt, mockRefreshTokenEntity);
         expect(rt.generateCredentialKey()).to.eql(
             "uid.utid-login.microsoftonline.com-refreshtoken-mock_client_id--"
         );
     });
 
     it("Create a RefreshTokenEntity with familyId", () => {
-        let rt = new RefreshTokenEntity();
+        const rt = new RefreshTokenEntity();
         Object.assign(rt, mockRefreshTokenEntityWithFamilyId);
         expect(rt.generateCredentialKey()).to.eql(
             "uid.utid-login.microsoftonline.com-refreshtoken-1--"
         );
     });
+
+    it("Throws error if RefreshTokenEntity is not assigned a type", () => {
+        const rt = new RefreshTokenEntity();
+        expect(() => rt.generateType()).to.throw(ClientAuthError);
+        expect(() => rt.generateType()).to.throw(ClientAuthErrorMessage.unexpectedCredentialType.desc);
+    });
+
+    it("Generate RefreshTokenEntity type", () => {
+        const rt = new RefreshTokenEntity();
+        Object.assign(rt, mockRefreshTokenEntity);
+        expect(rt.generateType()).to.eql(CacheType.REFRESH_TOKEN);
+    });
 });