Add tests

lib/msal-core/test/authority/Authority.spec.ts

@@ -1,10 +1,12 @@
 import { expect } from "chai";
 import { Authority } from "../../src/authority/Authority";
-import { ClientConfigurationErrorMessage } from "../../src/error/ClientConfigurationError"
+import { ClientConfigurationErrorMessage, ClientConfigurationError } from "../../src/error/ClientConfigurationError"
 import { TEST_CONFIG, TENANT_DISCOVERY_RESPONSE } from "../TestConstants";
 import TelemetryManager from "../../src/telemetry/TelemetryManager";
 import { TelemetryConfig } from "../../src/telemetry/TelemetryTypes";
 import { Logger } from "../../src";
+import { TrustedAuthority } from "../../src/authority/TrustedAuthority";
+import sinon from "sinon";
 
 const stubbedTelemetryConfig: TelemetryConfig = {
     clientId: TEST_CONFIG.MSAL_CLIENT_ID,
@@ -25,82 +27,156 @@ describe("Authority.ts Class", function () {
 
     afterEach(function () {
         authority = null;
+        sinon.restore();
     });
 
-    it("tests initialization of Authority", function() {
-        expect(authority).to.be.instanceOf(Authority);
+    describe("Constructor", () => {
+        it("tests initialization of Authority", function() {
+            expect(authority).to.be.instanceOf(Authority);
+        });
+
+        it("throws invalidAuthorityType on init if authority is not url", function () {
+            try {
+                authority = new Authority("", true);
+            }
+            catch(e) {
+                expect(e).to.be.equal(ClientConfigurationErrorMessage.invalidAuthorityType)
+            }
+        });
+
+        it("throws authorityUriInsecure on init if not https", function () {
+            try {
+                authority = new Authority("http://login.microsoftonline.com/common", true);
+            }
+            catch(e) {
+                expect(e).to.be.equal(ClientConfigurationErrorMessage.authorityUriInsecure)
+            }
+        });
+
+        it("throws authorityUriInvalidPath on init if there is no path", function () {
+            try {
+                authority = new Authority("https://login.microsoftonline.com", true);
+            }
+            catch(e) {
+                expect(e).to.be.equal(ClientConfigurationErrorMessage.authorityUriInvalidPath)
+            }
+        });
     });
 
-    it("throws error if ResolveEndpointsAsync hasn't been called yet", function () {
-        try {
-            const authEndpoint = authority.AuthorizationEndpoint
-        }
-        catch(e) {
-            expect(e).to.be.equal("Please call ResolveEndpointsAsync first");
-        }
+    describe("get AuthoritzationEndpoint", () => {
+        it("throws error if ResolveEndpointsAsync hasn't been called yet", function () {
+            try {
+                const authEndpoint = authority.AuthorizationEndpoint
+            }
+            catch(e) {
+                expect(e).to.be.equal("Please call ResolveEndpointsAsync first");
+            }
+        });
+
+        it("tests AuthorizationEndpoint", async function () {
+            const response = await authority.resolveEndpointsAsync(stubbedTelemetryManager, TEST_CONFIG.CorrelationId);
+
+            expect(authority.AuthorizationEndpoint).to.equal("https://login.microsoftonline.com/common/oauth2/v2.0/authorize")
+        });
     });
 
-    it("tests EndSessionEndpoint", async function () {
-        const response = await authority.resolveEndpointsAsync(stubbedTelemetryManager, TEST_CONFIG.CorrelationId);
-
-        expect(authority.EndSessionEndpoint).to.equal("https://login.microsoftonline.com/common/oauth2/v2.0/logout")
-    });
-
-    it("tests SelfSignedJwtAudience", async function () {
-        const response = await authority.resolveEndpointsAsync(stubbedTelemetryManager, TEST_CONFIG.CorrelationId);
-
-        expect(authority.SelfSignedJwtAudience).to.equal("https://login.microsoftonline.com/common/v2.0")
+    describe("get EndSessionEndpoint", () => {
+        it("throws error if ResolveEndpointsAsync hasn't been called yet", function () {
+            try {
+                const authEndpoint = authority.EndSessionEndpoint
+            }
+            catch(e) {
+                expect(e).to.be.equal("Please call ResolveEndpointsAsync first");
+            }
+        });
+
+        it("tests EndSessionEndpoint", async function () {
+            const response = await authority.resolveEndpointsAsync(stubbedTelemetryManager, TEST_CONFIG.CorrelationId);
+
+            expect(authority.EndSessionEndpoint).to.equal("https://login.microsoftonline.com/common/oauth2/v2.0/logout")
+        });
     });
 
-    it("throws invalidAuthorityType on init if authority is not url", function () {
-        try {
-            authority = new Authority("", true);
-        }
-        catch(e) {
-            expect(e).to.be.equal(ClientConfigurationErrorMessage.invalidAuthorityType)
-        }
+    describe("get SelfSignedJwtAudience", () => {
+        it("throws error if ResolveEndpointsAsync hasn't been called yet", function () {
+            try {
+                const authEndpoint = authority.SelfSignedJwtAudience
+            }
+            catch(e) {
+                expect(e).to.be.equal("Please call ResolveEndpointsAsync first");
+            }
+        });
+
+        it("tests SelfSignedJwtAudience", async function () {
+            const response = await authority.resolveEndpointsAsync(stubbedTelemetryManager, TEST_CONFIG.CorrelationId);
+
+            expect(authority.SelfSignedJwtAudience).to.equal("https://login.microsoftonline.com/common/v2.0")
+        });
     });
 
-    it("throws authorityUriInsecure on init if not https", function () {
-        try {
-            authority = new Authority("http://login.microsoftonline.com/common", true);
-        }
-        catch(e) {
-            expect(e).to.be.equal(ClientConfigurationErrorMessage.authorityUriInsecure)
-        }
+    describe("resolveEndpointsAsync", () => {
+        it("returns authority metadata", async function () {
+            const endpoints = await authority.resolveEndpointsAsync(stubbedTelemetryManager, TEST_CONFIG.CorrelationId);
+
+            expect(endpoints.EndSessionEndpoint).to.not.be.undefined;
+            expect(endpoints.AuthorizationEndpoint).to.not.be.undefined;
+            expect(endpoints.Issuer).to.not.be.undefined;
+        });
+
+        it("Calls Instance Discovery Endpoint if TrustedHostList not set", async function () {
+            // Testing of setTrustedAuthoritiesFromNetwork done in another test
+            let setFromNetworkCalled = false;
+            sinon.stub(TrustedAuthority, "IsInTrustedHostList").returns(true);
+            sinon.stub(TrustedAuthority, "getTrustedHostList").returns([]);
+            sinon.stub(TrustedAuthority, "setTrustedAuthoritiesFromNetwork").callsFake(async function() {
+                setFromNetworkCalled = true;
+            });
+
+            await authority.resolveEndpointsAsync(stubbedTelemetryManager, TEST_CONFIG.CorrelationId);
+            expect(setFromNetworkCalled).to.be.true;
+        });
+
+        it("Throws error if authority is not in TrustedHostList", async function () {
+            sinon.stub(TrustedAuthority, "IsInTrustedHostList").returns(false);
+            let err = null;
+            try {
+                const endpoints = await authority.resolveEndpointsAsync(stubbedTelemetryManager, TEST_CONFIG.CorrelationId);
+            } catch(e) {
+                expect(e).to.be.instanceOf(ClientConfigurationError);
+                err = e;
+            }
+
+            expect(err.errorCode).to.equal(ClientConfigurationErrorMessage.untrustedAuthority.code);
+            expect(err.errorMessage).to.contain(ClientConfigurationErrorMessage.untrustedAuthority.desc);
+        });
     });
 
-    it("throws authorityUriInvalidPath on init if there is no path", function () {
-        try {
-            authority = new Authority("https://login.microsoftonline.com", true);
-        }
-        catch(e) {
-            expect(e).to.be.equal(ClientConfigurationErrorMessage.authorityUriInvalidPath)
-        }
+    describe("hasCachedMetadata", () => {
+        it("returns false if metadata no fetched", () => {
+            expect(authority.hasCachedMetadata()).to.be.false;
+        });
+
+        it("returns true when metadata is provided", () => {
+            const testAuthorityWithMetadata = new Authority(TEST_CONFIG.validAuthority, true, TENANT_DISCOVERY_RESPONSE);
+
+            expect(testAuthorityWithMetadata.hasCachedMetadata()).to.be.true;
+        });
     });
 
-    it("hasCachedMetadata returns false if metadata no fetched", () => {
-        expect(authority.hasCachedMetadata()).to.be.false;
-    });
-
-    it("hasCachedMetadata returns true when metadata is provided", () => {
-        const testAuthorityWithMetadata = new Authority(TEST_CONFIG.validAuthority, true, TENANT_DISCOVERY_RESPONSE);
-
-        expect(testAuthorityWithMetadata.hasCachedMetadata()).to.be.true;
-    });
-
-    it("GetOpenIdConfigurationEndpoint returns well-known endpoint", async function () {
-        const endpoint = authority.GetOpenIdConfigurationEndpoint();
-
-        expect(endpoint).to.include("/v2.0/.well-known/openid-configuration");
-        expect(endpoint).to.include(TEST_CONFIG.validAuthority);
-    });
-
-    it("GetOpenIdConfigurationEndpoint returns well-known endpoint", async function () {
-        authority = new Authority(TEST_CONFIG.alternateValidAuthority, true);
-        const endpoint = authority.GetOpenIdConfigurationEndpoint();
-
-        expect(endpoint).to.include("/v2.0/.well-known/openid-configuration");
-        expect(endpoint).to.include(TEST_CONFIG.alternateValidAuthority);
+    describe("GetOpenIdConfigurationEndpoint", () => {
+        it("returns well-known endpoint", async function () {
+            const endpoint = authority.GetOpenIdConfigurationEndpoint();
+
+            expect(endpoint).to.include("/v2.0/.well-known/openid-configuration");
+            expect(endpoint).to.include(TEST_CONFIG.validAuthority);
+        });
+
+        it("returns well-known endpoint, alternate authority", async function () {
+            authority = new Authority(TEST_CONFIG.alternateValidAuthority, true);
+            const endpoint = authority.GetOpenIdConfigurationEndpoint();
+
+            expect(endpoint).to.include("/v2.0/.well-known/openid-configuration");
+            expect(endpoint).to.include(TEST_CONFIG.alternateValidAuthority);
+        });
     });
 });

lib/msal-core/test/authority/AuthorityFactory.spec.ts

@@ -1,8 +1,9 @@
 import { expect } from "chai";
-import { ClientConfigurationError, ClientConfigurationErrorMessage } from "../../src/error/ClientConfigurationError";
+import { ClientConfigurationError } from "../../src/error/ClientConfigurationError";
 import { AuthorityFactory } from "../../src/authority/AuthorityFactory";
 import { TEST_CONFIG, OPENID_CONFIGURATION, TENANT_DISCOVERY_RESPONSE } from "../TestConstants";
 import sinon from "sinon";
+import { Authority } from "../../src/authority/Authority";
 
 
 describe("AuthorityFactory.ts Class", function () {
@@ -16,6 +17,24 @@ describe("AuthorityFactory.ts Class", function () {
 
             expect(authority).to.be.null;
         });
+
+        it("Creates Authority Instance", function () {
+            let authority = AuthorityFactory.CreateInstance(TEST_CONFIG.validAuthority, false);
+
+            expect(authority).to.be.instanceOf(Authority);
+        });
+
+        it("calls saveMetadataFromConfig if metadata provided", function (done) {
+            // Verification of saved metadata is done in separate tests below
+            const testMetadata = JSON.stringify(OPENID_CONFIGURATION)
+            sinon.stub(AuthorityFactory, "saveMetadataFromConfig").callsFake(function (authorityUrl, metadata) {
+                expect(authorityUrl).to.equal(TEST_CONFIG.validAuthority);
+                expect(metadata).to.equal(testMetadata);
+                done();
+            });
+
+            AuthorityFactory.CreateInstance(TEST_CONFIG.validAuthority, false, testMetadata);
+        });
     });
 
     describe("saveMetadataFromConfig", () => {

lib/msal-core/test/authority/TrustedAuthority.spec.ts

@@ -22,7 +22,7 @@ describe("TrustedAuthority.ts Class", function () {
     });
 
     describe("setTrustedAuthoritiesFromConfig", () => {
-        it("Sets TrustedHostList with Known Authorities", async () => {
+        it("Sets TrustedHostList with Known Authorities", () => {
             sinon.stub(TrustedAuthority, "getTrustedHostList").returns([]);
             TrustedAuthority.setTrustedAuthoritiesFromConfig(true, TEST_CONFIG.knownAuthorities);
 
@@ -31,11 +31,20 @@ describe("TrustedAuthority.ts Class", function () {
             });
         });
 
-        it("Do not add additional authorities to trusted host list if it has already been populated", async () => {
+        it("Do not add additional authorities to trusted host list if it has already been populated", () => {
             sinon.stub(TrustedAuthority, "getTrustedHostList").returns(["login.microsoftonline.com"]);
             TrustedAuthority.setTrustedAuthoritiesFromConfig(true, ["contoso.b2clogin.com"]);
 
             expect(TrustedAuthority.IsInTrustedHostList("contoso.b2clogin.com")).to.be.false;
         });
     });
+
+    describe("setTrustedAuthoritiesFromNetwork", () => {
+        it("Sets TrustedHostList with Authorities known to Microsoft via Instance Discovery Network Call", async () => {
+            const countBefore = TrustedAuthority.getTrustedHostList().length;
+            await TrustedAuthority.setTrustedAuthoritiesFromNetwork(stubbedTelemetryManager);
+            const countAfter = TrustedAuthority.getTrustedHostList().length;
+            expect(countBefore).to.be.lessThan(countAfter);
+        });
+    });
 });