@webex/webex-core 3.0.0-beta.2 → 3.0.0-beta.200

package/test/unit/spec/webex-core.js

@@ -4,11 +4,7 @@
 
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
-import WebexCore, {
-  MemoryStoreAdapter,
-  registerPlugin,
-  WebexPlugin
-} from '@webex/webex-core';
+import WebexCore, {MemoryStoreAdapter, registerPlugin, WebexPlugin} from '@webex/webex-core';
 import {set} from 'lodash';
 import {version} from '@webex/webex-core/package';
 
@@ -58,6 +54,18 @@ describe('Webex', () => {
     });
   });
 
+  describe('#request', () => {
+    it('exists', () => {
+      assert.property(webex, 'request');
+    });
+  });
+
+  describe('#prepareFetchOptions', () => {
+    it('exists', () => {
+      assert.property(webex, 'prepareFetchOptions');
+    });
+  });
+
   describe('#initialize()', () => {
     it('initializes without arguments', () => {
       let webex;
@@ -88,16 +96,26 @@ describe('Webex', () => {
       'data.credentials.authorization',
       'data.credentials.authorization.access_token',
       'data.credentials.authorization.supertoken',
-      'data.credentials.authorization.supertoken.access_token'
-    ].reduce((acc, path) => acc.concat(['ST', 'Bearer ST'].map((str) => {
-      const obj = {
-        msg: `accepts token string "${str}" at path "${path.split('.').slice(1).join('.')}"`
-      };
-
-      set(obj, path, str);
-
-      return obj;
-    })), [])
+      'data.credentials.authorization.supertoken.access_token',
+    ]
+      .reduce(
+        (acc, path) =>
+          acc.concat(
+            ['ST', 'Bearer ST'].map((str) => {
+              const obj = {
+                msg: `accepts token string "${str}" at path "${path
+                  .split('.')
+                  .slice(1)
+                  .join('.')}"`,
+              };
+
+              set(obj, path, str);
+
+              return obj;
+            })
+          ),
+        []
+      )
       .forEach(({msg, data}) => {
         it(msg, () => {
           const webex = new WebexCore(data);
@@ -110,21 +128,35 @@ describe('Webex', () => {
       });
   });
 
-
   describe('initializes with Bearer Token', () => {
     [
       ['initializes with a correctly formatted token', 'Bearer 1234'],
-      ['initializes and removes extra space from a token that has an extra space after Bearer', 'Bearer  1234'],
-      ['initializes and adds a space after Bearer from a token that has no spaces after Bearer', 'Bearer1234'],
-      ['initializes and trims whitespace from a token that has spaces before Bearer and after token', ' Bearer 1234 '],
-      ['initializes and removes extra space and trims whitespace from a token that has spaces before and after Bearer and after token', ' Bearer  1234 '],
-      ['initializes and trims whitspace and adds a space after Bearer from a token that has spaces before Bearer and after token and no spaces after Bearer', ' Bearer1234 ']
+      [
+        'initializes and removes extra space from a token that has an extra space after Bearer',
+        'Bearer  1234',
+      ],
+      [
+        'initializes and adds a space after Bearer from a token that has no spaces after Bearer',
+        'Bearer1234',
+      ],
+      [
+        'initializes and trims whitespace from a token that has spaces before Bearer and after token',
+        ' Bearer 1234 ',
+      ],
+      [
+        'initializes and removes extra space and trims whitespace from a token that has spaces before and after Bearer and after token',
+        ' Bearer  1234 ',
+      ],
+      [
+        'initializes and trims whitspace and adds a space after Bearer from a token that has spaces before Bearer and after token and no spaces after Bearer',
+        ' Bearer1234 ',
+      ],
     ].forEach(([msg, token]) => {
       it(msg, () => {
         const webex = new WebexCore({
           credentials: {
-            access_token: token
-          }
+            access_token: token,
+          },
         });
 
         assert.isTrue(webex.credentials.canAuthorize);
@@ -161,13 +193,13 @@ describe('Webex', () => {
               '@': {
                 supertoken: {
                   // eslint-disable-next-line camelcase
-                  access_token: 'AT'
-                }
-              }
-            }
-          })
-        }
-      }
+                  access_token: 'AT',
+                },
+              },
+            },
+          }),
+        },
+      },
     });
 
     assert.isFalse(webex.loaded);
@@ -175,12 +207,11 @@ describe('Webex', () => {
 
     return new Promise((resolve) => {
       webex.once('loaded', resolve);
-    })
-      .then(() => {
-        assert.isTrue(webex.loaded);
-        assert.equal(webex.credentials.supertoken.access_token, 'AT');
-        assert.isTrue(webex.canAuthorize);
-      });
+    }).then(() => {
+      assert.isTrue(webex.loaded);
+      assert.equal(webex.credentials.supertoken.access_token, 'AT');
+      assert.isTrue(webex.canAuthorize);
+    });
   });
 
   it('emits the ready event when the storage layer has loaded and all plugins signal ready', () => {
@@ -190,20 +221,23 @@ describe('Webex', () => {
 
     return new Promise((resolve) => {
       webex.once('ready', resolve);
-    })
-      .then(() => assert.isTrue(webex.ready));
+    }).then(() => assert.isTrue(webex.ready));
   });
 
   it('allows plugins to control ready status', () => {
-    registerPlugin('test', WebexPlugin.extend({
-      namespace: 'test',
-      session: {
-        ready: {
-          default: false,
-          type: 'boolean'
-        }
-      }
-    }), {replace: true});
+    registerPlugin(
+      'test',
+      WebexPlugin.extend({
+        namespace: 'test',
+        session: {
+          ready: {
+            default: false,
+            type: 'boolean',
+          },
+        },
+      }),
+      {replace: true}
+    );
 
     const webex = new WebexCore();
 
@@ -220,15 +254,14 @@ describe('Webex', () => {
     assert.isFalse(webex.test.ready);
     assert.isFalse(webex.ready);
 
-    return new Promise((resolve) => webex.once('loaded', resolve))
-      .then(() => {
-        assert.isFalse(webex.ready);
-        assert.isFalse(webex.test.ready);
-        webex.test.ready = true;
-        assert.isTrue(webex.test.ready);
-        assert.isTrue(webex.ready);
-        assert.called(changeSpy);
-        assert.called(readySpy);
-      });
+    return new Promise((resolve) => webex.once('loaded', resolve)).then(() => {
+      assert.isFalse(webex.ready);
+      assert.isFalse(webex.test.ready);
+      webex.test.ready = true;
+      assert.isTrue(webex.test.ready);
+      assert.isTrue(webex.ready);
+      assert.called(changeSpy);
+      assert.called(readySpy);
+    });
   });
 });

package/test/unit/spec/webex-internal-core.js

@@ -9,16 +9,20 @@ import WebexCore, {WebexPlugin, registerInternalPlugin} from '@webex/webex-core'
 describe('Webex', () => {
   describe('#internal', () => {
     it('grants plugins access to their namepace config', () => {
-      registerInternalPlugin('test', WebexPlugin.extend({
-        namespace: 'test'
-      }), {replace: true});
+      registerInternalPlugin(
+        'test',
+        WebexPlugin.extend({
+          namespace: 'test',
+        }),
+        {replace: true}
+      );
 
       const webex = new WebexCore({
         config: {
           test: {
-            reachable: true
-          }
-        }
+            reachable: true,
+          },
+        },
       });
 
       assert.isTrue(webex.internal.test.config.reachable);
@@ -27,26 +31,48 @@ describe('Webex', () => {
     });
 
     it('controls ready status', () => {
-      registerInternalPlugin('test', WebexPlugin.extend({
-        namespace: 'test',
-        session: {
-          ready: {
-            default: false,
-            type: 'boolean'
-          }
-        }
-      }), {replace: true});
+      registerInternalPlugin(
+        'test',
+        WebexPlugin.extend({
+          namespace: 'test',
+          session: {
+            ready: {
+              default: false,
+              type: 'boolean',
+            },
+          },
+        }),
+        {replace: true}
+      );
 
       const webex = new WebexCore({
         config: {
           test: {
-            reachable: true
-          }
-        }
+            reachable: true,
+          },
+        },
       });
 
-      webex.internal.on('all', (ev) => console.info('YYY', ev, webex.credentials.ready, webex.internal.test.ready, webex.internal.ready, webex.ready));
-      webex.on('all', (ev) => console.info('XXX', ev, webex.credentials.ready, webex.internal.test.ready, webex.internal.ready, webex.ready));
+      webex.internal.on('all', (ev) =>
+        console.info(
+          'YYY',
+          ev,
+          webex.credentials.ready,
+          webex.internal.test.ready,
+          webex.internal.ready,
+          webex.ready
+        )
+      );
+      webex.on('all', (ev) =>
+        console.info(
+          'XXX',
+          ev,
+          webex.credentials.ready,
+          webex.internal.test.ready,
+          webex.internal.ready,
+          webex.ready
+        )
+      );
 
       const changeSpy = sinon.spy();
 
@@ -60,17 +86,16 @@ describe('Webex', () => {
       assert.isFalse(webex.internal.ready);
       assert.isFalse(webex.ready);
 
-      return new Promise((resolve) => webex.once('loaded', resolve))
-        .then(() => {
-          assert.isFalse(webex.internal.test.ready);
-          assert.isFalse(webex.internal.ready);
-          assert.isFalse(webex.ready);
-          webex.internal.test.ready = true;
-          assert.isTrue(webex.internal.ready);
-          assert.isTrue(webex.ready);
-          assert.called(changeSpy);
-          assert.called(readySpy);
-        });
+      return new Promise((resolve) => webex.once('loaded', resolve)).then(() => {
+        assert.isFalse(webex.internal.test.ready);
+        assert.isFalse(webex.internal.ready);
+        assert.isFalse(webex.ready);
+        webex.internal.test.ready = true;
+        assert.isTrue(webex.internal.ready);
+        assert.isTrue(webex.ready);
+        assert.called(changeSpy);
+        assert.called(readySpy);
+      });
     });
   });
 });