@webex/webex-core 3.0.0-beta.4 → 3.0.0-beta.400

package/test/unit/spec/credentials/scope.js

@@ -0,0 +1,80 @@
+import {assert} from '@webex/test-helper-chai';
+import {
+  sortScope,
+  filterScope,
+  diffScopes,
+  isGuestScope,
+} from '@webex/webex-core/src/lib/credentials/scope';
+
+describe('webex-core', () => {
+  describe('scope utils', () => {
+    describe('sortScope', () => {
+      [
+        {scope: undefined, expected: ''},
+        {scope: '', expected: ''},
+        {scope: 'a', expected: 'a'},
+        {scope: 'b c a', expected: 'a b c'},
+      ].forEach(({scope, expected}) =>
+        it(`should sort "${scope}" alphabetically`, () => {
+          assert.equal(sortScope(scope), expected);
+        })
+      );
+    });
+
+    describe('filterScope', () => {
+      [
+        {toFilter: 'a', scope: undefined, expected: ''},
+        {toFilter: 'a', scope: '', expected: ''},
+        {toFilter: 'a', scope: 'a', expected: ''},
+        {toFilter: 'a', scope: 'a b c', expected: 'b c'},
+        {toFilter: 'c', scope: 'a c b', expected: 'a b'},
+      ].forEach(({toFilter, scope, expected}) =>
+        it(`should filter out ${toFilter} scope from ${scope} scope and sort the result`, () => {
+          assert.equal(filterScope(toFilter, scope), expected);
+        })
+      );
+
+      [
+        {toFilter: [], scope: 'a', expected: 'a'},
+        {toFilter: ['a', 'b'], scope: undefined, expected: ''},
+        {toFilter: ['a', 'b'], scope: '', expected: ''},
+        {toFilter: ['a', 'b'], scope: 'a', expected: ''},
+        {toFilter: ['a', 'b'], scope: 'a b c', expected: 'c'},
+        {toFilter: ['a', 'd'], scope: 'a c a b', expected: 'b c'},
+      ].forEach(({toFilter, scope, expected}) =>
+        it(`should filter out ${toFilter} from ${scope} and sort the result`, () => {
+          assert.equal(filterScope(toFilter, scope), expected);
+        })
+      );
+    });
+
+    describe('diffScopes', () => {
+      [
+        {scope1: undefined, scope2: undefined, expected: ''},
+        {scope1: undefined, scope2: '', expected: ''},
+        {scope1: '', scope2: undefined, expected: ''},
+        {scope1: '', scope2: '', expected: ''},
+        {scope1: 'a', scope2: 'a', expected: ''},
+        {scope1: 'a b c', scope2: 'a b c', expected: ''},
+        {scope1: undefined, scope2: 'a b c', expected: ''},
+        {scope1: 'a b c', scope2: 'a b c d', expected: ''},
+      ].forEach(({scope1, scope2, expected}) =>
+        it(`should return an empty string, when all items in ${scope1} scope are contained in the ${scope2} scope`, () => {
+          assert.deepEqual(diffScopes(scope1, scope2), expected);
+        })
+      );
+
+      [
+        {scope1: 'a', scope2: undefined, expected: 'a'},
+        {scope1: 'a', scope2: 'b', expected: 'a'},
+        {scope1: 'a b c', scope2: 'a b', expected: 'c'},
+        {scope1: 'a b c d', scope2: 'a b c', expected: 'd'},
+        {scope1: 'a b c', scope2: undefined, expected: 'a b c'},
+      ].forEach(({scope1, scope2, expected}) =>
+        it(`should return a string containing all items in the ${scope1} scope that are not in the ${scope2} scope`, () => {
+          assert.deepEqual(diffScopes(scope1, scope2), expected);
+        })
+      );
+    });
+  });
+});

package/test/unit/spec/credentials/token.js

@@ -24,13 +24,19 @@ describe('webex-core', () => {
       });
 
       function makeToken(options = {}) {
-        return new Token(Object.assign({
-          access_token: 'AT',
-          expires_in: 10000,
-          token_type: 'Fake',
-          refresh_token: 'RT',
-          refresh_token_expires_in: 20000
-        }, options), {parent: webex});
+        return new Token(
+          Object.assign(
+            {
+              access_token: 'AT',
+              expires_in: 10000,
+              token_type: 'Fake',
+              refresh_token: 'RT',
+              refresh_token_expires_in: 20000,
+            },
+            options
+          ),
+          {parent: webex}
+        );
       }
 
       describe('#canAuthorize', () => {
@@ -154,15 +160,29 @@ describe('webex-core', () => {
         it('requires an unexpired access token', () => {
           const token = makeToken({expires: Date.now() - 10000});
 
-          return assert.isRejected(token.downscope('spark:kms'), /cannot downscope expired access token/);
+          return assert.isRejected(
+            token.downscope('spark:kms'),
+            /cannot downscope expired access token/
+          );
+        });
+
+        it('rejects downscope when the new scope is not super set of the available scopes', () => {
+          const token = makeToken();
+          token.config.scope = 'scopeY scopeZ';
+
+          return assert.isRejected(
+            token.downscope('scopeX'),
+            /new scope \(scopeX\) is not subset of the available scopes \(scopeY scopeZ\)/
+          );
         });
 
         it('alphabetizes the requested scope', () => {
           const token = makeToken();
 
           webex.request.returns(Promise.resolve({body: {access_token: 'AT2'}}));
-
-          return token.downscope('b a')
+          token.config.scope = 'a b c';
+          return token
+            .downscope('b a')
             .then(() => assert.equal(webex.request.args[0][0].form.scope, 'a b'));
         });
       });
@@ -189,7 +209,7 @@ describe('webex-core', () => {
 
         it('infers token_type from an access token string', () => {
           const t = new Token({
-            access_token: 'Fake AT'
+            access_token: 'Fake AT',
           });
 
           assert.equal(t.access_token, 'AT');
@@ -203,17 +223,17 @@ describe('webex-core', () => {
             expires_in: 6000,
             refresh_token_expires_in: 12000,
             expires: null,
-            refresh_token_expires: null
+            refresh_token_expires: null,
           });
 
           assert.approximately(t.expires, 6000000 + now, 5);
           assert.approximately(t.refresh_token_expires, 12000000 + now, 5);
         });
 
-        it('alphabetizes the token\'s scopes', () => {
+        it("alphabetizes the token's scopes", () => {
           const t = new Token({
             access_token: 'AT',
-            scope: 'b a'
+            scope: 'b a',
           });
 
           assert.equal(t.scope, 'a b');
@@ -222,7 +242,7 @@ describe('webex-core', () => {
         it('it sets a timer to set Token#_isExpired (and therefore Token#isExpired)', () => {
           const t = makeToken({
             // Reminder: expires_in is in seconds, ticks are in miliseconds
-            expires_in: 1
+            expires_in: 1,
           });
 
           assert.isFalse(t.isExpired);
@@ -251,37 +271,39 @@ describe('webex-core', () => {
         browserOnly(it)('refreshes the access_token', () => {
           const token = makeToken();
 
-          webex.config.credentials.refreshCallback = sinon.stub().returns(Promise.resolve({
-            access_token: 'AT2',
-            expires_in: 10000,
-            token_type: 'Fake'
-          }));
+          webex.config.credentials.refreshCallback = sinon.stub().returns(
+            Promise.resolve({
+              access_token: 'AT2',
+              expires_in: 10000,
+              token_type: 'Fake',
+            })
+          );
 
           // FIXME this next line should be necessary. we need a better way to
           // do config
           token.trigger('change:config');
 
-          return token.refresh()
-            .then((token2) => {
-              assert.equal(token2.access_token, 'AT2');
-            });
+          return token.refresh().then((token2) => {
+            assert.equal(token2.access_token, 'AT2');
+          });
         });
 
         nodeOnly(it)('refreshes the access_token', () => {
           const token = makeToken();
 
-          webex.request.onCall(0).returns(Promise.resolve({
-            body: {
-              access_token: 'AT2',
-              expires_in: 10000,
-              token_type: 'Fake'
-            }
-          }));
+          webex.request.onCall(0).returns(
+            Promise.resolve({
+              body: {
+                access_token: 'AT2',
+                expires_in: 10000,
+                token_type: 'Fake',
+              },
+            })
+          );
 
-          return token.refresh()
-            .then((token2) => {
-              assert.equal(token2.access_token, 'AT2');
-            });
+          return token.refresh().then((token2) => {
+            assert.equal(token2.access_token, 'AT2');
+          });
         });
 
         browserOnly(it)('revokes the previous token when set', () => {
@@ -290,23 +312,28 @@ describe('webex-core', () => {
           sinon.spy(token, 'revoke');
           webex.config.credentials.refreshCallback = sinon.stub();
 
-          webex.config.credentials.refreshCallback.onCall(0).returns(Promise.resolve({
-            access_token: 'AT2',
-            expires_in: 10000,
-            token_type: 'Fake'
-          }));
+          webex.config.credentials.refreshCallback.onCall(0).returns(
+            Promise.resolve({
+              access_token: 'AT2',
+              expires_in: 10000,
+              token_type: 'Fake',
+            })
+          );
 
-          webex.config.credentials.refreshCallback.onCall(1).returns(Promise.resolve({
-            access_token: 'AT3',
-            expires_in: 10000,
-            token_type: 'Fake'
-          }));
+          webex.config.credentials.refreshCallback.onCall(1).returns(
+            Promise.resolve({
+              access_token: 'AT3',
+              expires_in: 10000,
+              token_type: 'Fake',
+            })
+          );
 
           // FIXME this next line should be necessary. we need a better way to
           // do config
           token.trigger('change:config');
 
-          return token.refresh()
+          return token
+            .refresh()
             .then((token2) => {
               assert.isTrue(token.canRefresh);
               assert.notCalled(token.revoke);
@@ -324,23 +351,28 @@ describe('webex-core', () => {
 
           sinon.spy(token, 'revoke');
 
-          webex.request.onCall(0).returns(Promise.resolve({
-            body: {
-              access_token: 'AT2',
-              expires_in: 10000,
-              token_type: 'Fake'
-            }
-          }));
-
-          webex.request.onCall(1).returns(Promise.resolve({
-            body: {
-              access_token: 'AT3',
-              expires_in: 10000,
-              token_type: 'Fake'
-            }
-          }));
+          webex.request.onCall(0).returns(
+            Promise.resolve({
+              body: {
+                access_token: 'AT2',
+                expires_in: 10000,
+                token_type: 'Fake',
+              },
+            })
+          );
+
+          webex.request.onCall(1).returns(
+            Promise.resolve({
+              body: {
+                access_token: 'AT3',
+                expires_in: 10000,
+                token_type: 'Fake',
+              },
+            })
+          );
 
-          return token.refresh()
+          return token
+            .refresh()
             .then((token2) => {
               assert.isTrue(token.canRefresh);
               assert.notCalled(token.revoke);
@@ -359,8 +391,7 @@ describe('webex-core', () => {
           it('is a noop', () => {
             const token = makeToken({expires: Date.now() - 10000});
 
-            return token.revoke()
-              .then(() => assert.notCalled(webex.request));
+            return token.revoke().then(() => assert.notCalled(webex.request));
           });
         });
 
@@ -370,8 +401,7 @@ describe('webex-core', () => {
 
             token.unset('access_token');
 
-            return token.revoke()
-              .then(() => assert.notCalled(webex.request));
+            return token.revoke().then(() => assert.notCalled(webex.request));
           });
         });
 
@@ -385,23 +415,21 @@ describe('webex-core', () => {
 
             token.unset('access_token');
 
-            return token.revoke()
-              .then(() => assert.notCalled(webex.request));
+            return token.revoke().then(() => assert.notCalled(webex.request));
           });
         });
 
         it('unsets the access_token and related values', () => {
           const token = makeToken();
 
-          return token.revoke()
-            .then(() => {
-              assert.isUndefined(token.access_token);
-              assert.isUndefined(token.expires);
-              assert.isUndefined(token.expires_in);
-              assert.isDefined(token.refresh_token);
-              assert.isDefined(token.refresh_token_expires);
-              assert.isDefined(token.refresh_token_expires_in);
-            });
+          return token.revoke().then(() => {
+            assert.isUndefined(token.access_token);
+            assert.isUndefined(token.expires);
+            assert.isUndefined(token.expires_in);
+            assert.isDefined(token.refresh_token);
+            assert.isDefined(token.refresh_token_expires);
+            assert.isDefined(token.refresh_token_expires_in);
+          });
         });
       });