@webex/plugin-memberships 3.0.0-beta.8 → 3.0.0-beta.81

package/test/integration/spec/memberships.js

@@ -8,11 +8,7 @@ import '@webex/plugin-memberships';
 import '@webex/plugin-people';
 import '@webex/plugin-rooms';
 import WebexCore from '@webex/webex-core';
-import {
-  SDK_EVENT,
-  hydraTypes,
-  constructHydraId
-} from '@webex/common';
+import {SDK_EVENT, hydraTypes, constructHydraId} from '@webex/common';
 import {assert} from '@webex/test-helper-chai';
 import sinon from 'sinon';
 import testUsers from '@webex/test-helper-test-users';
@@ -24,37 +20,39 @@ describe('plugin-memberships', function () {
 
   let webex, user, actor;
 
-  before(() => testUsers.create({count: 1})
-    .then(([u]) => {
+  before(() =>
+    testUsers.create({count: 1}).then(([u]) => {
       user = u;
       webex = new WebexCore({credentials: user.token});
-      webex.people.get('me')
-        .then((person) => {
-          actor = person;
-          debug('SDK User (Actor) for tests:');
-          debug(`- name: ${actor.displayName}`);
-          debug(`-   id: ${actor.id}`);
-        });
-    }));
+      webex.people.get('me').then((person) => {
+        actor = person;
+        debug('SDK User (Actor) for tests:');
+        debug(`- name: ${actor.displayName}`);
+        debug(`-   id: ${actor.id}`);
+      });
+    })
+  );
 
   describe('#memberships', () => {
     let user1;
 
-    before(() => testUsers.create({count: 1})
-      .then((users) => {
+    before(() =>
+      testUsers.create({count: 1}).then((users) => {
         user1 = users[0];
         debug('User that memberships are created for:');
         debug(`- name: ${user1.displayName}`);
         debug(`-   id: ${constructHydraId(hydraTypes.PEOPLE, user1.id)}`);
-      }));
+      })
+    );
 
     let room;
 
-    beforeEach(() => webex.rooms.create({title: 'Webex Test Room'})
-      .then((r) => {
+    beforeEach(() =>
+      webex.rooms.create({title: 'Webex Test Room'}).then((r) => {
         debug('Created Cisco Test Room');
         room = r;
-      }));
+      })
+    );
 
     afterEach(() => {
       webex.memberships.stopListening();
@@ -62,19 +60,21 @@ describe('plugin-memberships', function () {
       webex.memberships.off('updated');
       webex.memberships.off('deleted');
       webex.memberships.off('seen');
-      webex.rooms.remove(room)
-        .catch((e) =>
-          webex.logger.error(`Failed to clean up after unit test: ${e}`));
+      webex.rooms
+        .remove(room)
+        .catch((e) => webex.logger.error(`Failed to clean up after unit test: ${e}`));
     });
 
     describe('#create()', () => {
-      it('creates a membership by user id', () => webex.memberships.create({
-        roomId: room.id,
-        personId: user1.id
-      })
-        .then((membership) => {
-          assert.isMembership(membership);
-        }));
+      it('creates a membership by user id', () =>
+        webex.memberships
+          .create({
+            roomId: room.id,
+            personId: user1.id,
+          })
+          .then((membership) => {
+            assert.isMembership(membership);
+          }));
 
       it('creates a membership by user email', () => {
         const created = new Promise((resolve) => {
@@ -84,17 +84,19 @@ describe('plugin-memberships', function () {
           });
         });
 
-        return webex.memberships.listen()
-          .then(() => webex.memberships.create({
-            roomId: room.id,
-            personEmail: user1.email
-          })
+        return webex.memberships.listen().then(() =>
+          webex.memberships
+            .create({
+              roomId: room.id,
+              personEmail: user1.email,
+            })
             .then(async (membership) => {
               validateMembership(membership);
               const event = await created;
 
               validateMembershipEvent(event, membership, actor);
-            }));
+            })
+        );
       });
 
       it('creates a membership and sets moderator status', () => {
@@ -112,9 +114,11 @@ describe('plugin-memberships', function () {
             debug('membership:updated event handler for moderator test called');
 
             if (event.data.personId === actor.id) {
-              debug('Setting a member to moderator implicitly sets the ' +
-                'caller of the API to moderator as well. In this test we ' +
-                'will ignore this event');
+              debug(
+                'Setting a member to moderator implicitly sets the ' +
+                  'caller of the API to moderator as well. In this test we ' +
+                  'will ignore this event'
+              );
 
               return;
             }
@@ -122,12 +126,13 @@ describe('plugin-memberships', function () {
           });
         });
 
-        return webex.memberships.listen()
-          .then(() => webex.memberships.create({
-            roomId: room.id,
-            personId: user1.id,
-            isModerator: true
-          })
+        return webex.memberships.listen().then(() =>
+          webex.memberships
+            .create({
+              roomId: room.id,
+              personId: user1.id,
+              isModerator: true,
+            })
             .then(async (m) => {
               const membership = m;
 
@@ -143,7 +148,8 @@ describe('plugin-memberships', function () {
               // We expect the isModerator status to be false on create
               membership.isModerator = true;
               validateMembershipEvent(event2, membership, actor);
-            }));
+            })
+        );
       });
 
       it('creates a space and memberships simultaniously', () => {
@@ -159,24 +165,27 @@ describe('plugin-memberships', function () {
           });
         });
 
-        return webex.memberships.listen()
-          // Cleanup current room, we need to catch the event when it's created.
-          .then(() => webex.rooms.remove(room))
-          // Create a room to trigger created event.
-          .then(() => webex.rooms.create({title: 'Webex Test Room'}))
-          // Store new room object and get the memberships of the room.
-          .then((r) => {
-            room = r;
+        return (
+          webex.memberships
+            .listen()
+            // Cleanup current room, we need to catch the event when it's created.
+            .then(() => webex.rooms.remove(room))
+            // Create a room to trigger created event.
+            .then(() => webex.rooms.create({title: 'Webex Test Room'}))
+            // Store new room object and get the memberships of the room.
+            .then((r) => {
+              room = r;
 
-            return webex.memberships.list({roomId: room.id});
-          })
-          // validate data
-          .then(async ({items: [membership]}) => {
-            const event = await created;
+              return webex.memberships.list({roomId: room.id});
+            })
+            // validate data
+            .then(async ({items: [membership]}) => {
+              const event = await created;
 
-            validateMembership(membership, false);
-            validateMembershipEvent(event, membership, actor);
-          });
+              validateMembership(membership, false);
+              validateMembershipEvent(event, membership, actor);
+            })
+        );
       });
     });
 
@@ -185,25 +194,24 @@ describe('plugin-memberships', function () {
 
       before(() =>
         // this could be in parallel once KMS always sends new keys
-        webex.rooms.create({title: 'Membership A'})
-          .then((room) => Promise.all([
-            room,
-            webex.rooms.create({title: 'Membership B'})
-          ]))
+        webex.rooms
+          .create({title: 'Membership A'})
+          .then((room) => Promise.all([room, webex.rooms.create({title: 'Membership B'})]))
           .then((rooms) => {
             const room = rooms[0];
 
             return webex.memberships.create({
               roomId: room.id,
-              personId: user1.id
+              personId: user1.id,
             });
           })
           .then((m) => {
             membership = m;
-          }));
+          })
+      );
 
-      it('retrieves a single membership', () => webex.memberships.get(membership)
-        .then((m) => {
+      it('retrieves a single membership', () =>
+        webex.memberships.get(membership).then((m) => {
           assert.deepEqual(m, membership);
         }));
     });
@@ -213,22 +221,21 @@ describe('plugin-memberships', function () {
 
       before(() =>
         // this could be in parallel once KMS always sends new keys
-        webex.rooms.create({title: 'Membership A'})
-          .then((room) => Promise.all([
-            room,
-            webex.rooms.create({title: 'Membership B'})
-          ]))
+        webex.rooms
+          .create({title: 'Membership A'})
+          .then((room) => Promise.all([room, webex.rooms.create({title: 'Membership B'})]))
           .then((rooms) => {
             room = rooms[0];
 
             return webex.memberships.create({
               roomId: room.id,
-              personId: user1.id
+              personId: user1.id,
             });
-          }));
+          })
+      );
 
-      it('retrieves all memberships for a room', () => webex.memberships.list({roomId: room.id})
-        .then((memberships) => {
+      it('retrieves all memberships for a room', () =>
+        webex.memberships.list({roomId: room.id}).then((memberships) => {
           assert.isDefined(memberships);
           assert.isAbove(memberships.length, 0);
           for (const membership of memberships) {
@@ -240,7 +247,8 @@ describe('plugin-memberships', function () {
       it('retrieves a bounded set of memberships for a room', () => {
         const spy = sinon.spy();
 
-        return webex.memberships.list({roomId: room.id, max: 1})
+        return webex.memberships
+          .list({roomId: room.id, max: 1})
           .then((memberships) => {
             assert.lengthOf(memberships, 1);
 
@@ -254,38 +262,42 @@ describe('plugin-memberships', function () {
               }
 
               return Promise.resolve();
-            }(memberships));
+            })(memberships);
           })
           .then(() => {
             assert.calledTwice(spy);
           });
       });
 
-      it('retrieves all room memberships for a user', () => webex.memberships.list({
-        personId: user.id,
-        roomId: room.id
-      })
-        .then((memberships) => {
-          const membership = memberships.items[0];
-
-          return webex.memberships.list({
-            personEmail: user.email
+      it('retrieves all room memberships for a user', () =>
+        webex.memberships
+          .list({
+            personId: user.id,
+            roomId: room.id,
           })
-            .then((memberships) => {
-              assert.isDefined(memberships);
-              assert.isAbove(memberships.length, 0);
-              for (const membership of memberships) {
-                assert.isMembership(membership);
-                assert.equal(membership.personEmail, user.email);
-              }
-              assert.deepInclude(memberships.items, membership);
-            });
-        }));
+          .then((memberships) => {
+            const membership = memberships.items[0];
+
+            return webex.memberships
+              .list({
+                personEmail: user.email,
+              })
+              .then((memberships) => {
+                assert.isDefined(memberships);
+                assert.isAbove(memberships.length, 0);
+                for (const membership of memberships) {
+                  assert.isMembership(membership);
+                  assert.equal(membership.personEmail, user.email);
+                }
+                assert.deepInclude(memberships.items, membership);
+              });
+          }));
 
       it('retrieves a bounded set of memberships for a user', () => {
         const spy = sinon.spy();
 
-        return webex.memberships.list({personId: user.id, max: 1})
+        return webex.memberships
+          .list({personId: user.id, max: 1})
           .then((memberships) => {
             assert.lengthOf(memberships, 1);
 
@@ -300,7 +312,7 @@ describe('plugin-memberships', function () {
               }
 
               return Promise.resolve();
-            }(memberships));
+            })(memberships);
           })
           .then(() => {
             assert.isAbove(spy.callCount, 0);
@@ -316,56 +328,65 @@ describe('plugin-memberships', function () {
         user1.webex = new WebexCore({credentials: user1.token});
 
         // Setup a space with both users
-        return webex.rooms.create({title: 'Membership A'})
-          .then((room) => Promise.all([
-            room,
-            webex.rooms.create({title: 'Membership B'})
-          ]))
+        return webex.rooms
+          .create({title: 'Membership A'})
+          .then((room) => Promise.all([room, webex.rooms.create({title: 'Membership B'})]))
           .then((rooms) => {
             room = rooms[0];
 
             return webex.memberships.create({
               roomId: room.id,
-              personId: user1.id
+              personId: user1.id,
             });
           });
       });
 
-      it('retrieves memberships with read status for a room that has not been visited', () => webex.memberships.listWithReadStatus({roomId: room.id})
-        .then((memberships) => {
+      it('retrieves memberships with read status for a room that has not been visited', () =>
+        webex.memberships.listWithReadStatus({roomId: room.id}).then((memberships) => {
           assert.isDefined(memberships);
           assert.equal(memberships.items.length, 2);
           for (const membership of memberships.items) {
             if (membership.personId !== actor.id) {
-              assert.notExists(membership.lastSeenId,
-                'no lastSeenId for a room that has never been visited');
-              assert.notExists(membership.lastSeenDate,
-                'no lastSeenDate for a room that has never been visited');
+              assert.notExists(
+                membership.lastSeenId,
+                'no lastSeenId for a room that has never been visited'
+              );
+              assert.notExists(
+                membership.lastSeenDate,
+                'no lastSeenDate for a room that has never been visited'
+              );
             }
             assert.equal(membership.roomId, room.id);
           }
         }));
 
-      it('validates read status activity after other user posts a message', () => user1.webex.messages.create({
-        roomId: room.id,
-        text: 'Message to create activity for other member'
-      })
-        .then(() => webex.memberships.listWithReadStatus({roomId: room.id})
-          .then((memberships) => {
-            assert.isDefined(memberships);
-            assert.equal(memberships.items.length, 2);
-            for (const membership of memberships.items) {
-              assert.exists(membership.lastSeenId,
-                'lastSeenId exists in a room that has been visited');
-              assert.exists(membership.lastSeenDate,
-                'lastSeenDate exists in a room that has been visited');
-              assert.equal(membership.roomId, room.id);
-              // listWithReadStatus does not include created
-              // fudge it here so we can validate all the other fields
-              membership.created = 'foo';
-              assert.isMembership(membership);
-            }
-          })));
+      it('validates read status activity after other user posts a message', () =>
+        user1.webex.messages
+          .create({
+            roomId: room.id,
+            text: 'Message to create activity for other member',
+          })
+          .then(() =>
+            webex.memberships.listWithReadStatus({roomId: room.id}).then((memberships) => {
+              assert.isDefined(memberships);
+              assert.equal(memberships.items.length, 2);
+              for (const membership of memberships.items) {
+                assert.exists(
+                  membership.lastSeenId,
+                  'lastSeenId exists in a room that has been visited'
+                );
+                assert.exists(
+                  membership.lastSeenDate,
+                  'lastSeenDate exists in a room that has been visited'
+                );
+                assert.equal(membership.roomId, room.id);
+                // listWithReadStatus does not include created
+                // fudge it here so we can validate all the other fields
+                membership.created = 'foo';
+                assert.isMembership(membership);
+              }
+            })
+          ));
     });
 
     describe('#update()', () => {
@@ -393,61 +414,72 @@ describe('plugin-memberships', function () {
           });
         });
 
-
-        return webex.memberships.listen()
+        return webex.memberships
+          .listen()
           .then(() => webex.rooms.listen())
-          .then(() => webex.rooms.create({title: 'Membership E'})
-            .then((r) => {
-              room = r;
-              debug(`Room under test ID: ${room.id}`);
-
-              // First get the SDK users membership
-              return webex.memberships.list({
-                roomId: room.id,
-                personId: actor.id
-              });
-            })
-            .then((membershipList) => {
-              assert.isArray(membershipList.items,
-                'membership list not returned after room creation');
-              assert.equal(membershipList.items.length, 1,
-                'SDK Test user not a member of room just created');
-              sdkMember = membershipList.items[0];
-
-              validateMembership(sdkMember);
-              sdkMember.isModerator = true;
-
-              // Then update the SDK user to a moderator
-              return webex.memberships.update(sdkMember);
-            })
-            .then(async (m) => {
-              debug('SDK User is now moderator.  Wait for events');
-              validateMembership(m, true);
-              const event = await updated;
-
-              validateMembershipEvent(event, m, actor);
-              const roomUpdatedEvent = await roomUpdated;
+          .then(() =>
+            webex.rooms
+              .create({title: 'Membership E'})
+              .then((r) => {
+                room = r;
+                debug(`Room under test ID: ${room.id}`);
+
+                // First get the SDK users membership
+                return webex.memberships.list({
+                  roomId: room.id,
+                  personId: actor.id,
+                });
+              })
+              .then((membershipList) => {
+                assert.isArray(
+                  membershipList.items,
+                  'membership list not returned after room creation'
+                );
+                assert.equal(
+                  membershipList.items.length,
+                  1,
+                  'SDK Test user not a member of room just created'
+                );
+                sdkMember = membershipList.items[0];
+
+                validateMembership(sdkMember);
+                sdkMember.isModerator = true;
+
+                // Then update the SDK user to a moderator
+                return webex.memberships.update(sdkMember);
+              })
+              .then(async (m) => {
+                debug('SDK User is now moderator.  Wait for events');
+                validateMembership(m, true);
+                const event = await updated;
 
-              return Promise.resolve(roomUpdatedEvent);
-            })
-            .then((roomUpdatedEvent) => {
-            // Check that the expected rooms:updated event matches
-            // what we expect when a room is first moderated
-              validateRoomsUpdatedEvent(roomUpdatedEvent, room,
-                /* expected value of isLocked */ true);
+                validateMembershipEvent(event, m, actor);
+                const roomUpdatedEvent = await roomUpdated;
 
-              // Finally, create the user for our test
-              return webex.memberships.create({
-                roomId: room.id,
-                personId: user1.id
-              });
-            })
-            .then((m) => {
-              debug('User 1 Membership created in Membership E');
-              membership = m;
-              validateMembership(membership);
-            })
-            .catch((e) => debug(`membership failed: ${e}`)));
+                return Promise.resolve(roomUpdatedEvent);
+              })
+              .then((roomUpdatedEvent) => {
+                // Check that the expected rooms:updated event matches
+                // what we expect when a room is first moderated
+                validateRoomsUpdatedEvent(
+                  roomUpdatedEvent,
+                  room,
+                  /* expected value of isLocked */ true
+                );
+
+                // Finally, create the user for our test
+                return webex.memberships.create({
+                  roomId: room.id,
+                  personId: user1.id,
+                });
+              })
+              .then((m) => {
+                debug('User 1 Membership created in Membership E');
+                membership = m;
+                validateMembership(membership);
+              })
+              .catch((e) => debug(`membership failed: ${e}`))
+          );
       });
 
       after(() => {
@@ -474,7 +506,8 @@ describe('plugin-memberships', function () {
 
         sdkMember.isModerator = false;
 
-        return webex.rooms.listen()
+        return webex.rooms
+          .listen()
           .then(() => webex.memberships.listen())
           .then(() => webex.memberships.update(sdkMember))
           .then(async (m) => {
@@ -495,8 +528,9 @@ describe('plugin-memberships', function () {
             debug('Validating rooms:updated event...');
             debug(`roomId: ${room.id}, event.data.id: ${roomUpdatedEvent.data.id}`);
 
-            return Promise.resolve(validateRoomsUpdatedEvent(roomUpdatedEvent,
-              room, /* expected isLocked value */ false));
+            return Promise.resolve(
+              validateRoomsUpdatedEvent(roomUpdatedEvent, room, /* expected isLocked value */ false)
+            );
           })
           .catch((e) => debug(`after logic for #update()' failed: ${e}`));
       });
@@ -512,19 +546,19 @@ describe('plugin-memberships', function () {
           });
         });
 
-        return webex.memberships.listen()
-          .then(() => webex.memberships.update(membership)
-            .then(async (m) => {
-              debug('membership updated');
-              assert.deepEqual(m, membership);
-              validateMembership(membership, true);
-              const event = await updated;
+        return webex.memberships.listen().then(() =>
+          webex.memberships.update(membership).then(async (m) => {
+            debug('membership updated');
+            assert.deepEqual(m, membership);
+            validateMembership(membership, true);
+            const event = await updated;
 
-              validateMembershipEvent(event, membership, actor);
-            }));
+            validateMembershipEvent(event, membership, actor);
+          })
+        );
       });
 
-      it('revokes a member\'s moderator status', () => {
+      it("revokes a member's moderator status", () => {
         assert.isTrue(membership.isModerator);
         membership.isModerator = false;
 
@@ -535,19 +569,18 @@ describe('plugin-memberships', function () {
           });
         });
 
-        return webex.memberships.listen()
-          .then(() => webex.memberships.update(membership)
-            .then(async (m) => {
-              assert.deepEqual(m, membership);
-              validateMembership(membership, false);
-              const event = await updated;
+        return webex.memberships.listen().then(() =>
+          webex.memberships.update(membership).then(async (m) => {
+            assert.deepEqual(m, membership);
+            validateMembership(membership, false);
+            const event = await updated;
 
-              validateMembershipEvent(event, membership, actor);
-            }));
+            validateMembershipEvent(event, membership, actor);
+          })
+        );
       });
     });
 
-
     describe('#updateLastSeen()', () => {
       let actor1, message;
 
@@ -557,7 +590,8 @@ describe('plugin-memberships', function () {
         // and another can mark it as read
         user1.webex = new WebexCore({credentials: user1.token});
 
-        return user1.webex.people.get('me')
+        return user1.webex.people
+          .get('me')
           .then((person) => {
             actor1 = person;
 
@@ -568,17 +602,20 @@ describe('plugin-memberships', function () {
 
             return webex.memberships.create({
               roomId: room.id,
-              personId: actor1.id
+              personId: actor1.id,
             });
           })
-          .then(() => webex.messages.create({
-            roomId: room.id,
-            text: 'This is a test message'
-          })
-            .then((m) => {
-              message = m;
-              assert.isMessage(message);
-            }));
+          .then(() =>
+            webex.messages
+              .create({
+                roomId: room.id,
+                text: 'This is a test message',
+              })
+              .then((m) => {
+                message = m;
+                assert.isMessage(message);
+              })
+          );
       });
 
       it('marks a message as read and verifies membership:updated event', () => {
@@ -591,18 +628,21 @@ describe('plugin-memberships', function () {
 
         debug(`${user1.displayName} marked message as read...`);
 
-        return webex.memberships.listen()
-          .then(() => user1.webex.memberships.updateLastSeen(message)
-            .then(async (m) => {
-              debug('membership seen');
-              validateMembership(m);
-              const event = await seenPromise;
-
-              debug(`...${user.displayName} got the membership:seen event.`);
-              assert.equal(event.data.lastSeenId, message.id,
-                'message:seen lastSeenID matches id of message that was acknlowledged');
-              validateMembershipEvent(event, m, actor1, actor);
-            }));
+        return webex.memberships.listen().then(() =>
+          user1.webex.memberships.updateLastSeen(message).then(async (m) => {
+            debug('membership seen');
+            validateMembership(m);
+            const event = await seenPromise;
+
+            debug(`...${user.displayName} got the membership:seen event.`);
+            assert.equal(
+              event.data.lastSeenId,
+              message.id,
+              'message:seen lastSeenID matches id of message that was acknlowledged'
+            );
+            validateMembershipEvent(event, m, actor1, actor);
+          })
+        );
       });
     });
 
@@ -613,22 +653,24 @@ describe('plugin-memberships', function () {
       // We create it by sending a message to the test user
       before(() =>
         // Ensure that room is a one-on-one object
-        webex.messages.create({
-          toPersonId: user1.id,
-          text: 'This message will create a 1-1 space'
-        })
+        webex.messages
+          .create({
+            toPersonId: user1.id,
+            text: 'This message will create a 1-1 space',
+          })
           .then((message) => {
             roomId = message.roomId;
 
             // Get the test users membership
             return webex.memberships.list({
               roomId,
-              personId: user.id
+              personId: user.id,
             });
           })
           .then((memberships) => {
             membership = memberships.items[0];
-          }));
+          })
+      );
 
       it('hides a space and validates the membership is updated', () => {
         const updatedEventPromise = new Promise((resolve) => {
@@ -638,40 +680,51 @@ describe('plugin-memberships', function () {
           });
         });
 
-        return webex.memberships.listen()
-          .then(() => {
-            debug(`Hiding my membership in 1-1 space with ID: ${roomId}...`);
-            membership.isRoomHidden = true;
-
-            return webex.memberships.update(membership)
-              .then(async (m) => {
-                debug('memberships.update() request returned OK.  Waiting for memberships:updated event');
-                assert(m.isRoomHidden, 'membership returned from meberships.update() did not have isRoomHidden set to true');
-                const event = await updatedEventPromise;
+        return webex.memberships.listen().then(() => {
+          debug(`Hiding my membership in 1-1 space with ID: ${roomId}...`);
+          membership.isRoomHidden = true;
 
-                assert(event.data.isRoomHidden, 'memberships:updated event did not have isRoomHidden set to true');
-                validateMembershipEvent(event, m, actor);
-              })
-              .catch((e) => assert.fail(`Updating room to hidden failed: ${e.message}`));
-          });
+          return webex.memberships
+            .update(membership)
+            .then(async (m) => {
+              debug(
+                'memberships.update() request returned OK.  Waiting for memberships:updated event'
+              );
+              assert(
+                m.isRoomHidden,
+                'membership returned from meberships.update() did not have isRoomHidden set to true'
+              );
+              const event = await updatedEventPromise;
+
+              assert(
+                event.data.isRoomHidden,
+                'memberships:updated event did not have isRoomHidden set to true'
+              );
+              validateMembershipEvent(event, m, actor);
+            })
+            .catch((e) => assert.fail(`Updating room to hidden failed: ${e.message}`));
+        });
       });
     });
 
     describe('#remove()', () => {
       let membership;
 
-      before(() => webex.rooms.create({title: 'Membership F'})
-        .then((r) => {
-          room = r;
+      before(() =>
+        webex.rooms
+          .create({title: 'Membership F'})
+          .then((r) => {
+            room = r;
 
-          return webex.memberships.create({
-            roomId: room.id,
-            personId: user1.id
-          });
-        })
-        .then((m) => {
-          membership = m;
-        }));
+            return webex.memberships.create({
+              roomId: room.id,
+              personId: user1.id,
+            });
+          })
+          .then((m) => {
+            membership = m;
+          })
+      );
 
       it('deletes a single membership', () => {
         const deletedEventPromise = new Promise((resolve) => {
@@ -681,11 +734,13 @@ describe('plugin-memberships', function () {
           });
         });
 
-        return webex.memberships.listen()
-          .then(() => webex.memberships.remove(membership)
-            .catch((reason) => {
+        return webex.memberships
+          .listen()
+          .then(() =>
+            webex.memberships.remove(membership).catch((reason) => {
               webex.logger.error('Failed to delete membership', reason);
-            }))
+            })
+          )
           .then(async (body) => {
             debug('member deleted');
             assert.notOk(body);
@@ -712,10 +767,8 @@ describe('plugin-memberships', function () {
 function validateMembership(membership, isModerator = false) {
   assert.isDefined(membership);
   if ('isModerator' in membership) {
-    assert.equal(membership.isModerator, isModerator,
-      'unexpected isModerator status');
-  }
-  else {
+    assert.equal(membership.isModerator, isModerator, 'unexpected isModerator status');
+  } else {
     // moderator status not returned for membership:seen events
     assert.exists(membership.lastSeenId);
     // fudge the moderator field so we can do the general check
@@ -735,41 +788,47 @@ function validateMembership(membership, isModerator = false) {
  * @returns {void}
  */
 function validateMembershipEvent(event, membership, actor, creator = actor) {
-  assert.isTrue(event.resource === SDK_EVENT.EXTERNAL.RESOURCE.MEMBERSHIPS,
-    'not a membership event');
+  assert.isTrue(
+    event.resource === SDK_EVENT.EXTERNAL.RESOURCE.MEMBERSHIPS,
+    'not a membership event'
+  );
   assert.isDefined(event.event, 'membership event type not set');
   assert.isDefined(event.created, 'event listener created date not set');
-  assert.equal(event.createdBy, creator.id,
-    'event listener createdBy not set to our actor');
-  assert.equal(event.orgId, actor.orgId,
-    'event listener orgId not === to our actor\'s');
+  assert.equal(event.createdBy, creator.id, 'event listener createdBy not set to our actor');
+  assert.equal(event.orgId, actor.orgId, "event listener orgId not === to our actor's");
   assert.equal(event.ownedBy, 'creator', 'event listener not owned by creator');
   assert.equal(event.status, 'active', 'event listener status not active');
-  assert.equal(event.actorId, actor.id,
-    'event actorId not equal to our actor\'s id');
+  assert.equal(event.actorId, actor.id, "event actorId not equal to our actor's id");
 
   // Ensure event data matches data returned from function call
   // Skip this until we figure out how conversations converts the internal test user UUID
-  assert.equal(event.data.id, membership.id,
-    'event/membership.id not equal');
-  assert.equal(event.data.roomId, membership.roomId,
-    'event/membership.roomId not equal');
-  assert.equal(event.data.personId, membership.personId,
-    'event/membership.personId not equal');
-  assert.equal(event.data.personOrgId, membership.personOrgId,
-    'event/membership.personId not equal');
-  assert.equal(event.data.personEmail, membership.personEmail,
-    'event/membership.personEmail not equal');
-  assert.equal(event.data.personDisplayName, membership.personDisplayName,
-    'event/membership.personDisplayName not equal');
-  assert.equal(event.data.roomType, membership.roomType,
-    'event/membership.roomType not equal');
-  assert.equal(event.data.isHidden, membership.isHidden,
-    'event/membership.isHidden not equal');
+  assert.equal(event.data.id, membership.id, 'event/membership.id not equal');
+  assert.equal(event.data.roomId, membership.roomId, 'event/membership.roomId not equal');
+  assert.equal(event.data.personId, membership.personId, 'event/membership.personId not equal');
+  assert.equal(
+    event.data.personOrgId,
+    membership.personOrgId,
+    'event/membership.personId not equal'
+  );
+  assert.equal(
+    event.data.personEmail,
+    membership.personEmail,
+    'event/membership.personEmail not equal'
+  );
+  assert.equal(
+    event.data.personDisplayName,
+    membership.personDisplayName,
+    'event/membership.personDisplayName not equal'
+  );
+  assert.equal(event.data.roomType, membership.roomType, 'event/membership.roomType not equal');
+  assert.equal(event.data.isHidden, membership.isHidden, 'event/membership.isHidden not equal');
   if (event.event !== 'seen') {
     // moderator status not returned on membership:seen events
-    assert.equal(event.data.isModerator, membership.isModerator,
-      'event/membership.isModerator not equal');
+    assert.equal(
+      event.data.isModerator,
+      membership.isModerator,
+      'event/membership.isModerator not equal'
+    );
   }
   debug(`membership:${event.event} event validated`);
 }
@@ -787,12 +846,9 @@ function validateMembershipEvent(event, membership, actor, creator = actor) {
 function validateRoomsUpdatedEvent(event, room, isLocked) {
   const {data} = event;
 
-  assert((room.id === data.id),
-    'rooms:updated event did not have the expected roomId');
-  assert((room.type === data.type),
-    'rooms:updated event did not have the expected room type');
-  assert((data.isLocked === isLocked),
-    'rooms:updated did not have expected isLocked value');
+  assert(room.id === data.id, 'rooms:updated event did not have the expected roomId');
+  assert(room.type === data.type, 'rooms:updated event did not have the expected room type');
+  assert(data.isLocked === isLocked, 'rooms:updated did not have expected isLocked value');
 
   debug(`rooms:${event.event} event validated`);
 }