@webex/plugin-authorization-browser 3.0.0-beta.9 → 3.0.0-beta.91

package/test/unit/spec/authorization.js

@@ -22,41 +22,48 @@ browserOnly(describe)('plugin-authorization-browser', () => {
         history: {
           replaceState(a, b, location) {
             mockWindow.location.href = location;
-          }
+          },
         },
         location: {
-          href
+          href,
         },
         sessionStorage: {
           getItem: sinon.stub().returns(csrfToken),
           removeItem: sinon.spy(),
-          setItem: sinon.spy()
-        }
+          setItem: sinon.spy(),
+        },
       };
 
       const webex = new MockWebex({
         children: {
           authorization: Authorization,
-          credentials: Credentials
+          credentials: Credentials,
         },
-        config: merge({
-          credentials: {
-            authorizeUrl: `${process.env.IDBROKER_BASE_URL || 'https://idbroker.webex.com'}/idb/oauth2/v1/authorize`,
-            logoutUrl: `${process.env.IDBROKER_BASE_URL || 'https://idbroker.webex.com'}/idb/oauth2/v1/logout`,
-            // eslint-disable-next-line camelcase
-            client_id: 'fake',
-            // eslint-disable-next-line camelcase
-            client_secret: 'fake',
-            // eslint-disable-next-line camelcase
-            redirect_uri: 'http://example.com',
-            // eslint-disable-next-line camelcase
-            scope: 'scope:one',
-            refreshCallback: () => Promise.resolve()
-          }
-        }, config),
+        config: merge(
+          {
+            credentials: {
+              authorizeUrl: `${
+                process.env.IDBROKER_BASE_URL || 'https://idbroker.webex.com'
+              }/idb/oauth2/v1/authorize`,
+              logoutUrl: `${
+                process.env.IDBROKER_BASE_URL || 'https://idbroker.webex.com'
+              }/idb/oauth2/v1/logout`,
+              // eslint-disable-next-line camelcase
+              client_id: 'fake',
+              // eslint-disable-next-line camelcase
+              client_secret: 'fake',
+              // eslint-disable-next-line camelcase
+              redirect_uri: 'http://example.com',
+              // eslint-disable-next-line camelcase
+              scope: 'scope:one',
+              refreshCallback: () => Promise.resolve(),
+            },
+          },
+          config
+        ),
         getWindow() {
           return mockWindow;
-        }
+        },
       });
 
       return webex;
@@ -65,31 +72,32 @@ browserOnly(describe)('plugin-authorization-browser', () => {
     describe('#initialize()', () => {
       describe('when there is a token in the url', () => {
         it('sets the token and sets ready', () => {
-          const webex = makeWebexCore('http://example.com/#access_token=AT&expires_in=3600&token_type=Bearer');
+          const webex = makeWebexCore(
+            'http://example.com/#access_token=AT&expires_in=3600&token_type=Bearer'
+          );
 
           assert.isFalse(webex.authorization.ready);
           assert.isFalse(webex.credentials.canAuthorize);
 
-          return webex.authorization.when('change:ready')
-            .then(() => {
-              assert.isTrue(webex.authorization.ready);
-              assert.isTrue(webex.credentials.canAuthorize);
-            });
+          return webex.authorization.when('change:ready').then(() => {
+            assert.isTrue(webex.authorization.ready);
+            assert.isTrue(webex.credentials.canAuthorize);
+          });
         });
 
         describe('when url parsing is disabled', () => {
           it('sets ready', () => {
             const webex = new MockWebex({
               children: {
-                credentials: Credentials
+                credentials: Credentials,
               },
               getWindow() {
                 return {
                   location: {
-                    href: 'http://example.com/#access_token=AT&expires_in=3600&token_type=Bearer'
-                  }
+                    href: 'http://example.com/#access_token=AT&expires_in=3600&token_type=Bearer',
+                  },
                 };
-              }
+              },
             });
 
             webex.authorization = new Authorization({parse: false}, {parent: webex});
@@ -100,18 +108,19 @@ browserOnly(describe)('plugin-authorization-browser', () => {
         });
 
         it('sets the token, refresh token and sets ready', () => {
-          const webex = makeWebexCore('http://example.com/#access_token=AT&expires_in=3600&token_type=Bearer&refresh_token=RT&refresh_token_expires_in=36000');
+          const webex = makeWebexCore(
+            'http://example.com/#access_token=AT&expires_in=3600&token_type=Bearer&refresh_token=RT&refresh_token_expires_in=36000'
+          );
 
           assert.isFalse(webex.authorization.ready);
           assert.isFalse(webex.credentials.canAuthorize);
           assert.isFalse(webex.credentials.canRefresh);
 
-          return webex.authorization.when('change:ready')
-            .then(() => {
-              assert.isTrue(webex.authorization.ready);
-              assert.isTrue(webex.credentials.canAuthorize);
-              assert.isTrue(webex.credentials.canRefresh);
-            });
+          return webex.authorization.when('change:ready').then(() => {
+            assert.isTrue(webex.authorization.ready);
+            assert.isTrue(webex.credentials.canAuthorize);
+            assert.isTrue(webex.credentials.canRefresh);
+          });
         });
 
         it('validates the csrf token', () => {
@@ -119,44 +128,70 @@ browserOnly(describe)('plugin-authorization-browser', () => {
 
           assert.throws(() => {
             // eslint-disable-next-line no-unused-vars
-            const webex = makeWebexCore(`http://example.com/#access_token=AT&expires_in=3600&token_type=Bearer&refresh_token=RT&refresh_token_expires_in=36000&state=${base64.encode(JSON.stringify({csrf_token: 'someothertoken'}))}`, csrfToken);
+            const webex = makeWebexCore(
+              `http://example.com/#access_token=AT&expires_in=3600&token_type=Bearer&refresh_token=RT&refresh_token_expires_in=36000&state=${base64.encode(
+                JSON.stringify({csrf_token: 'someothertoken'})
+              )}`,
+              csrfToken
+            );
           }, /CSRF token someothertoken does not match stored token abcd/);
 
           assert.throws(() => {
             // eslint-disable-next-line no-unused-vars
-            const webex = makeWebexCore(`http://example.com/#access_token=AT&expires_in=3600&token_type=Bearer&refresh_token=RT&refresh_token_expires_in=36000&state=${base64.encode(JSON.stringify({}))}`, csrfToken);
+            const webex = makeWebexCore(
+              `http://example.com/#access_token=AT&expires_in=3600&token_type=Bearer&refresh_token=RT&refresh_token_expires_in=36000&state=${base64.encode(
+                JSON.stringify({})
+              )}`,
+              csrfToken
+            );
           }, /Expected CSRF token abcd, but not found in redirect hash/);
 
           assert.throws(() => {
             // eslint-disable-next-line no-unused-vars
-            const webex = makeWebexCore('http://example.com/#access_token=AT&expires_in=3600&token_type=Bearer&refresh_token=RT&refresh_token_expires_in=36000', csrfToken);
+            const webex = makeWebexCore(
+              'http://example.com/#access_token=AT&expires_in=3600&token_type=Bearer&refresh_token=RT&refresh_token_expires_in=36000',
+              csrfToken
+            );
           }, /Expected CSRF token abcd, but not found in redirect hash/);
 
-          const webex = makeWebexCore(`http://example.com/#access_token=AT&expires_in=3600&token_type=Bearer&refresh_token=RT&refresh_token_expires_in=36000&state=${base64.encode(JSON.stringify({csrf_token: csrfToken}))}`, csrfToken);
+          const webex = makeWebexCore(
+            `http://example.com/#access_token=AT&expires_in=3600&token_type=Bearer&refresh_token=RT&refresh_token_expires_in=36000&state=${base64.encode(
+              JSON.stringify({csrf_token: csrfToken})
+            )}`,
+            csrfToken
+          );
 
-          return webex.authorization.when('change:ready')
-            .then(() => {
-              assert.isTrue(webex.credentials.canAuthorize);
-              assert.called(webex.getWindow().sessionStorage.removeItem);
-            });
+          return webex.authorization.when('change:ready').then(() => {
+            assert.isTrue(webex.credentials.canAuthorize);
+            assert.called(webex.getWindow().sessionStorage.removeItem);
+          });
         });
 
         it('removes the oauth parameters from the url', () => {
           const csrfToken = 'abcd';
 
-          const webex = makeWebexCore(`http://example.com/#access_token=AT&expires_in=3600&token_type=Bearer&refresh_token=RT&refresh_token_expires_in=36000&state=${base64.encode(JSON.stringify({csrf_token: csrfToken, something: true}))}`, csrfToken);
-
-          return webex.authorization.when('change:ready')
-            .then(() => {
-              assert.isTrue(webex.credentials.canAuthorize);
-              assert.called(webex.getWindow().sessionStorage.removeItem);
-              assert.equal(webex.getWindow().location.href, `http://example.com/#state=${base64.encode(JSON.stringify({something: true}))}`);
-            });
+          const webex = makeWebexCore(
+            `http://example.com/#access_token=AT&expires_in=3600&token_type=Bearer&refresh_token=RT&refresh_token_expires_in=36000&state=${base64.encode(
+              JSON.stringify({csrf_token: csrfToken, something: true})
+            )}`,
+            csrfToken
+          );
+
+          return webex.authorization.when('change:ready').then(() => {
+            assert.isTrue(webex.credentials.canAuthorize);
+            assert.called(webex.getWindow().sessionStorage.removeItem);
+            assert.equal(
+              webex.getWindow().location.href,
+              `http://example.com/#state=${base64.encode(JSON.stringify({something: true}))}`
+            );
+          });
         });
 
         it('throws a grant error when the url contains one', () => {
           assert.throws(() => {
-            makeWebexCore('http://127.0.0.1:8000/?error=invalid_scope&error_description=The%20requested%20scope%20is%20invalid.');
+            makeWebexCore(
+              'http://127.0.0.1:8000/?error=invalid_scope&error_description=The%20requested%20scope%20is%20invalid.'
+            );
           }, /The requested scope is invalid./);
         });
       });
@@ -176,42 +211,44 @@ browserOnly(describe)('plugin-authorization-browser', () => {
         it('calls #initiateImplicitGrant()', () => {
           const webex = makeWebexCore(undefined, undefined, {
             credentials: {
-              clientType: 'public'
-            }
+              clientType: 'public',
+            },
           });
 
           sinon.spy(webex.authorization, 'initiateImplicitGrant');
 
-          return webex.authorization.initiateLogin()
-            .then(() => {
-              assert.called(webex.authorization.initiateImplicitGrant);
-              assert.include(webex.getWindow().location, 'response_type=token');
-            });
+          return webex.authorization.initiateLogin().then(() => {
+            assert.called(webex.authorization.initiateImplicitGrant);
+            assert.include(webex.getWindow().location, 'response_type=token');
+          });
         });
 
         it('adds a csrf_token to the login url and sessionStorage', () => {
           const webex = makeWebexCore(undefined, undefined, {
             credentials: {
-              clientType: 'public'
-            }
+              clientType: 'public',
+            },
           });
 
           sinon.spy(webex.authorization, 'initiateImplicitGrant');
 
-          return webex.authorization.initiateLogin()
-            .then(() => {
-              assert.called(webex.authorization.initiateImplicitGrant);
-              assert.include(webex.getWindow().location, 'response_type=token');
-              const {query} = url.parse(webex.getWindow().location, true);
-              let {state} = query;
-
-              state = JSON.parse(base64.decode(state));
-              assert.property(state, 'csrf_token');
-              assert.isDefined(state.csrf_token);
-              assert.match(state.csrf_token, patterns.uuid);
-              assert.called(webex.getWindow().sessionStorage.setItem);
-              assert.calledWith(webex.getWindow().sessionStorage.setItem, 'oauth2-csrf-token', state.csrf_token);
-            });
+          return webex.authorization.initiateLogin().then(() => {
+            assert.called(webex.authorization.initiateImplicitGrant);
+            assert.include(webex.getWindow().location, 'response_type=token');
+            const {query} = url.parse(webex.getWindow().location, true);
+            let {state} = query;
+
+            state = JSON.parse(base64.decode(state));
+            assert.property(state, 'csrf_token');
+            assert.isDefined(state.csrf_token);
+            assert.match(state.csrf_token, patterns.uuid);
+            assert.called(webex.getWindow().sessionStorage.setItem);
+            assert.calledWith(
+              webex.getWindow().sessionStorage.setItem,
+              'oauth2-csrf-token',
+              state.csrf_token
+            );
+          });
         });
       });
 
@@ -219,50 +256,52 @@ browserOnly(describe)('plugin-authorization-browser', () => {
         it('calls #initiateAuthorizationCodeGrant()', () => {
           const webex = makeWebexCore(undefined, undefined, {
             credentials: {
-              clientType: 'confidential'
-            }
+              clientType: 'confidential',
+            },
           });
 
           sinon.spy(webex.authorization, 'initiateAuthorizationCodeGrant');
 
-          return webex.authorization.initiateLogin()
-            .then(() => {
-              assert.called(webex.authorization.initiateAuthorizationCodeGrant);
-              assert.include(webex.getWindow().location, 'response_type=code');
-            });
+          return webex.authorization.initiateLogin().then(() => {
+            assert.called(webex.authorization.initiateAuthorizationCodeGrant);
+            assert.include(webex.getWindow().location, 'response_type=code');
+          });
         });
 
         it('adds a csrf_token to the login url and sessionStorage', () => {
           const webex = makeWebexCore(undefined, undefined, {
             credentials: {
-              clientType: 'confidential'
-            }
+              clientType: 'confidential',
+            },
           });
 
           sinon.spy(webex.authorization, 'initiateAuthorizationCodeGrant');
 
-          return webex.authorization.initiateLogin()
-            .then(() => {
-              assert.called(webex.authorization.initiateAuthorizationCodeGrant);
-              assert.include(webex.getWindow().location, 'response_type=code');
-              const {query} = url.parse(webex.getWindow().location, true);
-              let {state} = query;
-
-              state = JSON.parse(base64.decode(state));
-              assert.property(state, 'csrf_token');
-              assert.isDefined(state.csrf_token);
-              assert.match(state.csrf_token, patterns.uuid);
-              assert.called(webex.getWindow().sessionStorage.setItem);
-              assert.calledWith(webex.getWindow().sessionStorage.setItem, 'oauth2-csrf-token', state.csrf_token);
-            });
+          return webex.authorization.initiateLogin().then(() => {
+            assert.called(webex.authorization.initiateAuthorizationCodeGrant);
+            assert.include(webex.getWindow().location, 'response_type=code');
+            const {query} = url.parse(webex.getWindow().location, true);
+            let {state} = query;
+
+            state = JSON.parse(base64.decode(state));
+            assert.property(state, 'csrf_token');
+            assert.isDefined(state.csrf_token);
+            assert.match(state.csrf_token, patterns.uuid);
+            assert.called(webex.getWindow().sessionStorage.setItem);
+            assert.calledWith(
+              webex.getWindow().sessionStorage.setItem,
+              'oauth2-csrf-token',
+              state.csrf_token
+            );
+          });
         });
       });
 
       it('sets #isAuthorizing', () => {
         const webex = makeWebexCore(undefined, undefined, {
           credentials: {
-            clientType: 'confidential'
-          }
+            clientType: 'confidential',
+          },
         });
 
         assert.isFalse(webex.authorization.isAuthorizing);
@@ -276,8 +315,8 @@ browserOnly(describe)('plugin-authorization-browser', () => {
       it('sets #isAuthenticating', () => {
         const webex = makeWebexCore(undefined, undefined, {
           credentials: {
-            clientType: 'confidential'
-          }
+            clientType: 'confidential',
+          },
         });
 
         assert.isFalse(webex.authorization.isAuthenticating);
@@ -293,8 +332,8 @@ browserOnly(describe)('plugin-authorization-browser', () => {
       it('removes the state parameter when it is empty', () => {
         const webex = makeWebexCore(undefined, undefined, {
           credentials: {
-            clientType: 'confidential'
-          }
+            clientType: 'confidential',
+          },
         });
 
         sinon.spy(webex.authorization, '_cleanUrl');
@@ -309,17 +348,17 @@ browserOnly(describe)('plugin-authorization-browser', () => {
       it('removes the state parameter when only token is present', () => {
         const webex = makeWebexCore(undefined, undefined, {
           credentials: {
-            clientType: 'confidential'
-          }
+            clientType: 'confidential',
+          },
         });
 
         sinon.spy(webex.authorization, '_cleanUrl');
         const location = {
           hash: {
             state: {
-              csrf_token: 'token'
-            }
-          }
+              csrf_token: 'token',
+            },
+          },
         };
 
         webex.authorization._cleanUrl(location);
@@ -329,16 +368,16 @@ browserOnly(describe)('plugin-authorization-browser', () => {
       it('keeps the state parameter when it has keys', () => {
         const webex = makeWebexCore(undefined, undefined, {
           credentials: {
-            clientType: 'confidential'
-          }
+            clientType: 'confidential',
+          },
         });
         const location = {
           hash: {
             state: {
               csrf_token: 'token',
-              key: 'value'
-            }
-          }
+              key: 'value',
+            },
+          },
         };
 
         sinon.spy(webex.authorization, '_cleanUrl');
@@ -355,17 +394,16 @@ browserOnly(describe)('plugin-authorization-browser', () => {
       it('redirects to the login page with response_type=token', () => {
         const webex = makeWebexCore(undefined, undefined, {
           credentials: {
-            clientType: 'public'
-          }
+            clientType: 'public',
+          },
         });
 
         sinon.spy(webex.authorization, 'initiateImplicitGrant');
 
-        return webex.authorization.initiateLogin()
-          .then(() => {
-            assert.called(webex.authorization.initiateImplicitGrant);
-            assert.include(webex.getWindow().location, 'response_type=token');
-          });
+        return webex.authorization.initiateLogin().then(() => {
+          assert.called(webex.authorization.initiateImplicitGrant);
+          assert.include(webex.getWindow().location, 'response_type=token');
+        });
       });
     });
 
@@ -373,17 +411,16 @@ browserOnly(describe)('plugin-authorization-browser', () => {
       it('redirects to the login page with response_type=code', () => {
         const webex = makeWebexCore(undefined, undefined, {
           credentials: {
-            clientType: 'confidential'
-          }
+            clientType: 'confidential',
+          },
         });
 
         sinon.spy(webex.authorization, 'initiateAuthorizationCodeGrant');
 
-        return webex.authorization.initiateLogin()
-          .then(() => {
-            assert.called(webex.authorization.initiateAuthorizationCodeGrant);
-            assert.include(webex.getWindow().location, 'response_type=code');
-          });
+        return webex.authorization.initiateLogin().then(() => {
+          assert.called(webex.authorization.initiateAuthorizationCodeGrant);
+          assert.include(webex.getWindow().location, 'response_type=code');
+        });
       });
     });
   });