@webex/internal-plugin-presence 3.0.0-beta.12 → 3.0.0-beta.121

package/src/presence.js

@@ -21,7 +21,7 @@ const Presence = WebexPlugin.extend({
   namespace: 'Presence',
 
   children: {
-    batcher: PresenceBatcher
+    batcher: PresenceBatcher,
   },
 
   session: {
@@ -29,8 +29,8 @@ const Presence = WebexPlugin.extend({
       default() {
         return new PresenceWorker();
       },
-      type: 'any'
-    }
+      type: 'any',
+    },
   },
 
   /**
@@ -62,7 +62,8 @@ const Presence = WebexPlugin.extend({
    * @returns {Promise<boolean>} resolves with true, if successful
    */
   enable() {
-    return this.webex.internal.feature.setFeature(USER, USER_PRESENCE_ENABLED, true)
+    return this.webex.internal.feature
+      .setFeature(USER, USER_PRESENCE_ENABLED, true)
       .then((response) => response.value);
   },
 
@@ -71,7 +72,8 @@ const Presence = WebexPlugin.extend({
    * @returns {Promise<boolean>} resolves with false, if successful
    */
   disable() {
-    return this.webex.internal.feature.setFeature(USER, USER_PRESENCE_ENABLED, false)
+    return this.webex.internal.feature
+      .setFeature(USER, USER_PRESENCE_ENABLED, false)
       .then((response) => response.value);
   },
 
@@ -113,17 +115,18 @@ const Presence = WebexPlugin.extend({
       return Promise.reject(new Error('A person id is required'));
     }
 
-    return this.webex.request({
-      method: 'GET',
-      service: 'apheleia',
-      resource: `compositions?userId=${personId}`
-    })
+    return this.webex
+      .request({
+        method: 'GET',
+        service: 'apheleia',
+        resource: `compositions?userId=${personId}`,
+      })
       .then((response) => response.body);
   },
 
   /**
-  * @typedef {Object} PresenceStatusesObject
-  * @property {Array.<PresenceStatusObject>} statusList
+   * @typedef {Object} PresenceStatusesObject
+   * @property {Array.<PresenceStatusObject>} statusList
    */
   /**
    * Gets the current presence statuses of an array of people ids
@@ -135,9 +138,9 @@ const Presence = WebexPlugin.extend({
       return Promise.reject(new Error('An array of person ids is required'));
     }
 
-    return Promise.all(personIds.map((id) =>
-      this.batcher.request(id)))
-      .then((presences) => ({statusList: presences}));
+    return Promise.all(personIds.map((id) => this.batcher.request(id))).then((presences) => ({
+      statusList: presences,
+    }));
   },
 
   /**
@@ -157,8 +160,7 @@ const Presence = WebexPlugin.extend({
     }
     if (Array.isArray(personIds)) {
       subjects = personIds;
-    }
-    else {
+    } else {
       subjects = [personIds];
     }
     // Limit batches to 50 ids per request
@@ -166,19 +168,22 @@ const Presence = WebexPlugin.extend({
       batches.push(subjects.slice(i, i + batchLimit));
     }
 
-    return Promise.all(batches.map((ids) =>
-      this.webex.request({
-        method: 'POST',
-        api: 'apheleia',
-        resource: 'subscriptions',
-        body: {
-          subjects: ids,
-          subscriptionTtl,
-          includeStatus: true
-        }
-      })
-        .then((response) => response.body.responses)))
-      .then((idBatches) => ({responses: [].concat(...idBatches)}));
+    return Promise.all(
+      batches.map((ids) =>
+        this.webex
+          .request({
+            method: 'POST',
+            api: 'apheleia',
+            resource: 'subscriptions',
+            body: {
+              subjects: ids,
+              subscriptionTtl,
+              includeStatus: true,
+            },
+          })
+          .then((response) => response.body.responses)
+      )
+    ).then((idBatches) => ({responses: [].concat(...idBatches)}));
   },
 
   /**
@@ -194,8 +199,7 @@ const Presence = WebexPlugin.extend({
     }
     if (Array.isArray(personIds)) {
       subjects = personIds;
-    }
-    else {
+    } else {
       subjects = [personIds];
     }
 
@@ -206,8 +210,8 @@ const Presence = WebexPlugin.extend({
       body: {
         subjects,
         subscriptionTtl: 0,
-        includeStatus: true
-      }
+        includeStatus: true,
+      },
     });
   },
 
@@ -222,16 +226,17 @@ const Presence = WebexPlugin.extend({
       return Promise.reject(new Error('A status is required'));
     }
 
-    return this.webex.request({
-      method: 'POST',
-      api: 'apheleia',
-      resource: 'events',
-      body: {
-        subject: this.webex.internal.device.userId,
-        eventType: status,
-        ttl
-      }
-    })
+    return this.webex
+      .request({
+        method: 'POST',
+        api: 'apheleia',
+        resource: 'events',
+        body: {
+          subject: this.webex.internal.device.userId,
+          eventType: status,
+          ttl,
+        },
+      })
       .then((response) => response.body);
   },
 
@@ -251,7 +256,7 @@ const Presence = WebexPlugin.extend({
    */
   dequeue(id) {
     return this.worker.dequeue(id);
-  }
+  },
 });
 
 export default Presence;

package/test/integration/spec/presence.js

@@ -11,82 +11,91 @@ import testUsers from '@webex/test-helper-test-users';
 import {expectEvent} from '@webex/test-helper-mocha';
 import sinon from 'sinon';
 
-describe('plugin-presence', function () {
+// SPARK-413317
+describe.skip('plugin-presence', function () {
   this.timeout(10000);
   describe('Presence', () => {
     let mccoy, spock;
 
-    beforeEach('create users', () => testUsers.create({count: 2})
-      .then((users) => {
+    beforeEach('create users', () =>
+      testUsers.create({count: 2}).then((users) => {
         [spock, mccoy] = users;
         spock.webex = new WebexCore({
           credentials: {
-            authorization: users[0].token
-          }
+            authorization: users[0].token,
+          },
         });
         mccoy.webex = new WebexCore({
           credentials: {
-            authorization: users[1].token
-          }
+            authorization: users[1].token,
+          },
         });
-      }));
+      })
+    );
 
-    beforeEach('register with wdm', () => Promise.all([
-      spock.webex.internal.device.register(),
-      mccoy.webex.internal.device.register()
-    ]));
+    beforeEach('register with wdm', () =>
+      Promise.all([spock.webex.internal.device.register(), mccoy.webex.internal.device.register()])
+    );
 
     beforeEach('register spock with mercury', () => spock.webex.internal.mercury.connect());
 
     afterEach('deregister spock with mercury', () => spock.webex.internal.mercury.disconnect());
 
     describe('#enable()', () => {
-      it('enables presence', () => spock.webex.internal.presence.enable()
-        .then((isEnabled) => {
-          assert.equal(isEnabled, true);
-        })
-        .then(() => spock.webex.internal.presence.isEnabled())
-        .then((isEnabled) => {
-          assert.equal(isEnabled, true);
-        }));
+      it('enables presence', () =>
+        spock.webex.internal.presence
+          .enable()
+          .then((isEnabled) => {
+            assert.equal(isEnabled, true);
+          })
+          .then(() => spock.webex.internal.presence.isEnabled())
+          .then((isEnabled) => {
+            assert.equal(isEnabled, true);
+          }));
     });
 
     describe('#disable()', () => {
-      it('disables presence', () => spock.webex.internal.presence.disable()
-        .then((isEnabled) => {
-          assert.equal(isEnabled, false);
-        })
-        .then(() => spock.webex.internal.presence.isEnabled())
-        .then((isEnabled) => {
-          assert.equal(isEnabled, false);
-        }));
+      it('disables presence', () =>
+        spock.webex.internal.presence
+          .disable()
+          .then((isEnabled) => {
+            assert.equal(isEnabled, false);
+          })
+          .then(() => spock.webex.internal.presence.isEnabled())
+          .then((isEnabled) => {
+            assert.equal(isEnabled, false);
+          }));
     });
 
     describe('#isEnabled()', () => {
-      it('returns true when presence is enabled', () => spock.webex.internal.presence.enable()
-        .then(() => spock.webex.internal.presence.isEnabled())
-        .then((isEnabled) => {
-          assert.equal(isEnabled, true);
-        }));
+      it('returns true when presence is enabled', () =>
+        spock.webex.internal.presence
+          .enable()
+          .then(() => spock.webex.internal.presence.isEnabled())
+          .then((isEnabled) => {
+            assert.equal(isEnabled, true);
+          }));
 
-      it('returns false when presence is disabled', () => spock.webex.internal.presence.disable()
-        .then(() => spock.webex.internal.presence.isEnabled())
-        .then((isEnabled) => {
-          assert.equal(isEnabled, false);
-        }));
+      it('returns false when presence is disabled', () =>
+        spock.webex.internal.presence
+          .disable()
+          .then(() => spock.webex.internal.presence.isEnabled())
+          .then((isEnabled) => {
+            assert.equal(isEnabled, false);
+          }));
     });
 
     describe('#get()', () => {
-      it('gets a person\'s status by id', () => spock.webex.internal.presence.get(mccoy.id)
-        .then((presenceResponse) => {
+      it("gets a person's status by id", () =>
+        spock.webex.internal.presence.get(mccoy.id).then((presenceResponse) => {
           assert.property(presenceResponse, 'subject');
           assert.equal(presenceResponse.subject, mccoy.id);
         }));
     });
 
     describe('#list()', () => {
-      it('returns an object with the status of all requested people', () => spock.webex.internal.presence.list([mccoy.id, spock.id])
-        .then((presenceResponse) => {
+      it('returns an object with the status of all requested people', () =>
+        spock.webex.internal.presence.list([mccoy.id, spock.id]).then((presenceResponse) => {
           assert.equal(presenceResponse.statusList.length, 2);
           assert.property(presenceResponse.statusList[0], 'subject');
           assert.equal(presenceResponse.statusList[0].subject, mccoy.id);
@@ -97,16 +106,18 @@ describe('plugin-presence', function () {
       describe('batching of presence requests', () => {
         let batchTestUsers;
 
-        beforeEach('create more users', () => testUsers.create({count: 6})
-          .then((users) => {
+        beforeEach('create more users', () =>
+          testUsers.create({count: 6}).then((users) => {
             batchTestUsers = users;
-          }));
+          })
+        );
 
         it('executes network requests for max limit', () => {
           spock.webex.internal.presence.config.batcherMaxCalls = 2;
           sinon.spy(spock.webex.internal.presence.batcher, 'submitHttpRequest');
 
-          return spock.webex.internal.presence.list(batchTestUsers.map((user) => user.id))
+          return spock.webex.internal.presence
+            .list(batchTestUsers.map((user) => user.id))
             .then((presenceResponse) => {
               assert.equal(presenceResponse.statusList.length, 6);
               assert.calledThrice(spock.webex.internal.presence.batcher.submitHttpRequest);
@@ -117,61 +128,87 @@ describe('plugin-presence', function () {
     });
 
     describe('#subscribe', () => {
-      afterEach(() => spock && spock.webex && spock.webex.internal.presence.unsubscribe([mccoy.id, spock.id]));
+      afterEach(
+        () =>
+          spock && spock.webex && spock.webex.internal.presence.unsubscribe([mccoy.id, spock.id])
+      );
 
-      it('subscribes to a person id and returns subscription status', () => spock.webex.internal.presence.subscribe(mccoy.id)
-        .then((presenceResponse) => {
+      it('subscribes to a person id and returns subscription status', () =>
+        spock.webex.internal.presence.subscribe(mccoy.id).then((presenceResponse) => {
           assert.property(presenceResponse, 'responses');
           assert.equal(presenceResponse.responses.length, 1);
           assert.equal(presenceResponse.responses[0].subject, mccoy.id);
         }));
 
       it('subscribes and returns subscription status of a list of people ids', () =>
-        spock.webex.internal.presence.subscribe([mccoy.id, spock.id])
-          .then((presenceResponse) => {
-            assert.property(presenceResponse, 'responses');
-            assert.equal(presenceResponse.responses.length, 2);
-            assert.equal(presenceResponse.responses[0].subject, mccoy.id);
-            assert.equal(presenceResponse.responses[1].subject, spock.id);
-          }));
+        spock.webex.internal.presence.subscribe([mccoy.id, spock.id]).then((presenceResponse) => {
+          assert.property(presenceResponse, 'responses');
+          assert.equal(presenceResponse.responses.length, 2);
+          assert.equal(presenceResponse.responses[0].subject, mccoy.id);
+          assert.equal(presenceResponse.responses[1].subject, spock.id);
+        }));
 
       // Note: The presence service no longer accepts setting status to "inactive".
       // Inactivity is now determined by a "last active time" of greater than 10 minutes.
-      it('should receive a mercury event for a subscribed person\'s change', () =>
-        spock.webex.internal.presence.subscribe(mccoy.id)
+      it("should receive a mercury event for a subscribed person's change", () =>
+        spock.webex.internal.presence
+          .subscribe(mccoy.id)
           // 'active' status
-          .then(() => Promise.all([
-            expectEvent(10000, 'event:apheleia.subscription_update', spock.webex.internal.mercury, 'spock should get the presence active event'),
-            mccoy.webex.internal.presence.setStatus('active', 1500)
-          ]))
-          .then(([event]) => assert.equal(event.data.status, 'active', 'mccoy presence event status should be active'))
+          .then(() =>
+            Promise.all([
+              expectEvent(
+                10000,
+                'event:apheleia.subscription_update',
+                spock.webex.internal.mercury,
+                'spock should get the presence active event'
+              ),
+              mccoy.webex.internal.presence.setStatus('active', 1500),
+            ])
+          )
+          .then(([event]) =>
+            assert.equal(
+              event.data.status,
+              'active',
+              'mccoy presence event status should be active'
+            )
+          )
           // 'dnd' status
-          .then(() => Promise.all([
-            expectEvent(10000, 'event:apheleia.subscription_update', spock.webex.internal.mercury, 'spock should get the presence dnd event'),
-            mccoy.webex.internal.presence.setStatus('dnd', 1500)
-          ]))
-          .then(([event]) => assert.equal(event.data.status, 'dnd', 'mccoy presence event status should be dnd')));
+          .then(() =>
+            Promise.all([
+              expectEvent(
+                10000,
+                'event:apheleia.subscription_update',
+                spock.webex.internal.mercury,
+                'spock should get the presence dnd event'
+              ),
+              mccoy.webex.internal.presence.setStatus('dnd', 1500),
+            ])
+          )
+          .then(([event]) =>
+            assert.equal(event.data.status, 'dnd', 'mccoy presence event status should be dnd')
+          ));
     });
 
     describe('#unsubscribe', () => {
       it('unsubscribes to presence updates of a single person id', () =>
-        spock.webex.internal.presence.unsubscribe(mccoy.id)
+        spock.webex.internal.presence
+          .unsubscribe(mccoy.id)
           .then((res) => assert.statusCode(res, 200)));
 
       it('unsubscribes to presence updates of a list of people ids', () =>
-        spock.webex.internal.presence.unsubscribe([mccoy.id, spock.id])
+        spock.webex.internal.presence
+          .unsubscribe([mccoy.id, spock.id])
           .then((res) => assert.statusCode(res, 200)));
     });
 
     describe('#setStatus', () => {
       it('sets the presence status of the current user', () =>
-        spock.webex.internal.presence.setStatus('dnd', 1500)
-          .then((statusResponse) => {
-            assert.property(statusResponse, 'subject');
-            assert.property(statusResponse, 'status');
-            assert.equal(statusResponse.subject, spock.id);
-            assert.equal(statusResponse.status, 'dnd');
-          }));
+        spock.webex.internal.presence.setStatus('dnd', 1500).then((statusResponse) => {
+          assert.property(statusResponse, 'subject');
+          assert.property(statusResponse, 'status');
+          assert.equal(statusResponse.subject, spock.id);
+          assert.equal(statusResponse.status, 'dnd');
+        }));
     });
   });
 });

package/test/unit/spec/presence-worker.js

@@ -18,22 +18,18 @@ describe('presence-worker', () => {
       webex = new MockWebex({
         children: {
           mercury: Mercury,
-          presence: Presence
-        }
+          presence: Presence,
+        },
       });
       worker = new PresenceWorker();
       worker.webex = webex;
     });
 
     describe('#initialize()', () => {
-      it('requires webex', () => assert.throws(
-        worker.initialize,
-        /Must initialize Presence Worker with webex!/
-      ));
-      it('requires webex internal', () => assert.throws(
-        () => worker.initialize({}),
-        /Must initialize Presence Worker with webex!/
-      ));
+      it('requires webex', () =>
+        assert.throws(worker.initialize, /Must initialize Presence Worker with webex!/));
+      it('requires webex internal', () =>
+        assert.throws(() => worker.initialize({}), /Must initialize Presence Worker with webex!/));
     });
 
     describe('#enqueue()', () => {
@@ -119,12 +115,11 @@ describe('presence-worker', () => {
       const boarding = {
         pam: true,
         jim: true,
-        dwight: true
+        dwight: true,
       };
 
       it('moves fetchers to flights', () => {
-        webex.internal.presence.list = sinon.stub()
-          .returns(Promise.resolve({statusList: []}));
+        webex.internal.presence.list = sinon.stub().returns(Promise.resolve({statusList: []}));
 
         worker.fetchers = boarding;
 
@@ -134,13 +129,10 @@ describe('presence-worker', () => {
       });
 
       it('calls presence.list', async () => {
-        const response = [
-          {subject: 'pam'},
-          {subject: 'jim'},
-          {subject: 'dwight'}
-        ];
+        const response = [{subject: 'pam'}, {subject: 'jim'}, {subject: 'dwight'}];
 
-        webex.internal.presence.list = sinon.stub()
+        webex.internal.presence.list = sinon
+          .stub()
           .returns(Promise.resolve({statusList: response}));
         webex.internal.presence.emitEvent = sinon.stub();
 
@@ -151,9 +143,10 @@ describe('presence-worker', () => {
         assert.calledWith(webex.internal.presence.list, Object.keys(boarding));
         assert.isEmpty(worker.flights);
         assert.deepEqual(Object.keys(worker.presences), Object.keys(boarding));
-        assert.calledWith(webex.internal.presence.emitEvent,
-          'updated',
-          {type: 'presence', payload: {statusList: response}});
+        assert.calledWith(webex.internal.presence.emitEvent, 'updated', {
+          type: 'presence',
+          payload: {statusList: response},
+        });
       });
     });
 
@@ -163,7 +156,7 @@ describe('presence-worker', () => {
         const scouts = {
           pam: now - 60001, // move them back a little over a minute
           jim: now - 60001,
-          dwight: now
+          dwight: now,
         };
 
         worker.campers = scouts;
@@ -180,11 +173,11 @@ describe('presence-worker', () => {
         const subbies = {
           pam: now,
           jim: now + 61000, // move forward a little over a minute
-          dwight: now
+          dwight: now,
         };
         const watching = {
           pam: 1,
-          jim: 1
+          jim: 1,
         };
 
         worker.watchers = watching;
@@ -200,7 +193,7 @@ describe('presence-worker', () => {
         const subbies = {
           pam: now + 600000, // move forward 10 minutes
           jim: now - 20000, // move back 20 seconds
-          dwight: now - 60000 // move back 1 minute
+          dwight: now - 60000, // move back 1 minute
         };
 
         worker.subscribers = subbies;
@@ -218,7 +211,7 @@ describe('presence-worker', () => {
         const presences = {
           pam: now - 300000, // 5 minutes ago
           jim: now - 600001, // little over 10 minutes ago
-          dwight: now - 1200000 // 20 minutes ago
+          dwight: now - 1200000, // 20 minutes ago
         };
 
         webex.internal.presence.emitEvent = sinon.stub();
@@ -226,30 +219,33 @@ describe('presence-worker', () => {
 
         worker.cleanPresences();
 
-        assert.calledWith(webex.internal.presence.emitEvent,
-          'updated',
-          {type: 'delete', payload: ['jim', 'dwight']});
+        assert.calledWith(webex.internal.presence.emitEvent, 'updated', {
+          type: 'delete',
+          payload: ['jim', 'dwight'],
+        });
       });
     });
 
     describe('#groundskeeper()', () => {
       it('renews subscriptions', async () => {
-        webex.internal.presence.subscribe = sinon.stub()
-          .returns(Promise.resolve({
+        webex.internal.presence.subscribe = sinon.stub().returns(
+          Promise.resolve({
             responses: [
               {
                 responseCode: 200,
                 subscriptionTtl: 600,
                 subject: 'pam',
                 status: {
-                  subject: 'pam'
-                }
+                  subject: 'pam',
+                },
               },
               {
                 responseCode: 500,
-                subject: 'jim'
-              }]
-          }));
+                subject: 'jim',
+              },
+            ],
+          })
+        );
         worker.checkCampers = sinon.stub().returns(['pam']);
         worker.checkSubscriptions = sinon.stub().returns(['jim']);
         worker.cleanPresences = sinon.stub();

package/test/unit/spec/presence.js

@@ -14,23 +14,30 @@ describe('plugin-presence', () => {
     beforeEach(() => {
       webex = new MockWebex({
         children: {
-          presence: Presence
-        }
+          presence: Presence,
+        },
       });
     });
 
     describe('#get()', () => {
-      it('requires a person id parameter', () => assert.isRejected(webex.internal.presence.get(), /A person id is required/));
+      it('requires a person id parameter', () =>
+        assert.isRejected(webex.internal.presence.get(), /A person id is required/));
     });
 
     describe('#list()', () => {
-      it('requires a parameter', () => assert.isRejected(webex.internal.presence.list(), /An array of person ids is required/));
+      it('requires a parameter', () =>
+        assert.isRejected(webex.internal.presence.list(), /An array of person ids is required/));
 
-      it('requires a person array parameter', () => assert.isRejected(webex.internal.presence.list('abc'), /An array of person ids is required/));
+      it('requires a person array parameter', () =>
+        assert.isRejected(
+          webex.internal.presence.list('abc'),
+          /An array of person ids is required/
+        ));
     });
 
     describe('#subscribe()', () => {
-      it('requires a person parameter', () => assert.isRejected(webex.internal.presence.subscribe(), /A person id is required/));
+      it('requires a person parameter', () =>
+        assert.isRejected(webex.internal.presence.subscribe(), /A person id is required/));
       it('subscription request called twice with batch of 100 ids', () => {
         const ids = [...Array(100).keys()];
 
@@ -38,7 +45,7 @@ describe('plugin-presence', () => {
           return Promise.resolve({
             statusCode: 204,
             body: [],
-            options
+            options,
           });
         };
         sinon.spy(webex, 'request');
@@ -49,11 +56,13 @@ describe('plugin-presence', () => {
     });
 
     describe('#unsubscribe()', () => {
-      it('requires a person parameter', () => assert.isRejected(webex.internal.presence.unsubscribe(), /A person id is required/));
+      it('requires a person parameter', () =>
+        assert.isRejected(webex.internal.presence.unsubscribe(), /A person id is required/));
     });
 
     describe('#setStatus()', () => {
-      it('requires a status', () => assert.isRejected(webex.internal.presence.setStatus(), /A status is required/));
+      it('requires a status', () =>
+        assert.isRejected(webex.internal.presence.setStatus(), /A status is required/));
     });
   });
 });