@webex/internal-plugin-board 3.0.0-beta.2 → 3.0.0-beta.21

package/test/integration/spec/board.js

@@ -18,7 +18,7 @@ function generateTonsOfContents(numOfContents) {
     for (let i = 0; i < numOfContents; i += 1) {
       contents.push({
         type: 'curve',
-        payload: JSON.stringify({id: i, type: 'curve'})
+        payload: JSON.stringify({id: i, type: 'curve'}),
       });
     }
     resolve(contents);
@@ -29,51 +29,66 @@ describe('plugin-board', () => {
   describe('service', () => {
     let board, conversation, fixture, participants;
 
-    before('create users', () => testUsers.create({count: 3})
-      .then((users) => {
+    before('create users', () =>
+      testUsers.create({count: 3}).then((users) => {
         participants = users;
 
-        return Promise.all(map(participants, (participant) => {
-          participant.webex = new WebexCore({
-            credentials: {
-              authorization: participant.token
-            }
-          });
-
-          return participant.webex.internal.device.register()
-            .then(() => participant.webex.internal.feature.setFeature('developer', 'files-acl-write', true));
-        }));
-      }));
-
-    before('create conversation', () => participants[0].webex.internal.conversation.create({
-      displayName: 'Test Board Conversation',
-      participants
-    })
-      .then((c) => {
-        conversation = c;
+        return Promise.all(
+          map(participants, (participant) => {
+            participant.webex = new WebexCore({
+              credentials: {
+                authorization: participant.token,
+              },
+            });
+
+            return participant.webex.internal.device
+              .register()
+              .then(() =>
+                participant.webex.internal.feature.setFeature('developer', 'files-acl-write', true)
+              );
+          })
+        );
+      })
+    );
+
+    before('create conversation', () =>
+      participants[0].webex.internal.conversation
+        .create({
+          displayName: 'Test Board Conversation',
+          participants,
+        })
+        .then((c) => {
+          conversation = c;
 
-        return conversation;
-      }));
+          return conversation;
+        })
+    );
 
-    before('create channel (board)', () => participants[0].webex.internal.board.createChannel(conversation)
-      .then((channel) => {
+    before('create channel (board)', () =>
+      participants[0].webex.internal.board.createChannel(conversation).then((channel) => {
         board = channel;
 
         return channel;
-      }));
+      })
+    );
 
-    before('load fixture image', () => fh.fetch('sample-image-small-one.png')
-      .then((fetchedFixture) => {
+    before('load fixture image', () =>
+      fh.fetch('sample-image-small-one.png').then((fetchedFixture) => {
         fixture = fetchedFixture;
 
         return fetchedFixture;
-      }));
+      })
+    );
 
-    after('disconnect mercury', () => Promise.all(map(participants, (participant) => participant.webex.internal.mercury.disconnect())));
+    after('disconnect mercury', () =>
+      Promise.all(
+        map(participants, (participant) => participant.webex.internal.mercury.disconnect())
+      )
+    );
 
     describe('#getChannel', () => {
-      it('gets the channel metadata', () => participants[0].webex.internal.board.getChannel(board)
-        .then((channel) => {
+      it('gets the channel metadata', () =>
+        participants[0].webex.internal.board.getChannel(board).then((channel) => {
           assert.property(channel, 'kmsResourceUrl');
           assert.property(channel, 'aclUrl');
 
@@ -81,17 +96,25 @@ describe('plugin-board', () => {
           assert.equal(channel.aclUrlLink, conversation.aclUrl);
           assert.notEqual(channel.kmsResourceUrl, conversation.kmsResourceObjectUrl);
           assert.notEqual(channel.aclUrl, conversation.aclUrl);
-          assert.notEqual(channel.defaultEncryptionKeyUrl, conversation.defaultActivityEncryptionKeyUrl);
+          assert.notEqual(
+            channel.defaultEncryptionKeyUrl,
+            conversation.defaultActivityEncryptionKeyUrl
+          );
         }));
     });
 
     describe('#_uploadImage()', () => {
       after(() => participants[0].webex.internal.board.deleteAllContent(board));
 
-      it('uploads image to webex files', () => participants[0].webex.internal.board._uploadImage(board, fixture)
-        .then((scr) => participants[1].webex.internal.encryption.download(scr))
-        .then((downloadedFile) => fh.isMatchingFile(downloadedFile, fixture)
-          .then((result) => assert.deepEqual(result, true))));
+      it('uploads image to webex files', () =>
+        participants[0].webex.internal.board
+          ._uploadImage(board, fixture)
+          .then((scr) => participants[1].webex.internal.encryption.download(scr))
+          .then((downloadedFile) =>
+            fh
+              .isMatchingFile(downloadedFile, fixture)
+              .then((result) => assert.deepEqual(result, true))
+          ));
     });
 
     describe('#setSnapshotImage()', () => {
@@ -100,7 +123,8 @@ describe('plugin-board', () => {
       it('uploads image to webex files and adds to channel', () => {
         let imageRes;
 
-        return participants[0].webex.internal.board.setSnapshotImage(board, fixture)
+        return participants[0].webex.internal.board
+          .setSnapshotImage(board, fixture)
           .then((res) => {
             imageRes = res.image;
             assert.isDefined(res.image, 'image field is included');
@@ -113,11 +137,15 @@ describe('plugin-board', () => {
             assert.deepEqual(imageRes, res.image);
 
             // ensure others can download the image
-            return participants[2].webex.internal.encryption.decryptScr(board.defaultEncryptionKeyUrl, res.image.scr);
+            return participants[2].webex.internal.encryption.decryptScr(
+              board.defaultEncryptionKeyUrl,
+              res.image.scr
+            );
           })
           .then((decryptedScr) => participants[2].webex.internal.encryption.download(decryptedScr))
-          .then((file) => fh.isMatchingFile(file, fixture)
-            .then((result) => assert.deepEqual(result, true)));
+          .then((file) =>
+            fh.isMatchingFile(file, fixture).then((result) => assert.deepEqual(result, true))
+          );
       });
     });
 
@@ -130,19 +158,25 @@ describe('plugin-board', () => {
 
       after(() => participants[0].webex.internal.board.deleteAllContent(board));
 
-      it('uploads image to webex files', () => participants[0].webex.internal.board.addImage(board, fixture, {displayName: fixture.name})
-        .then((fileContent) => {
-          testContent = fileContent[0].items[0];
-          assert.equal(testContent.type, 'FILE', 'content type should be image');
-          assert.property(testContent, 'contentUrl', 'content should contain contentId property');
-          assert.property(testContent, 'channelUrl', 'content should contain contentUrl property');
-          assert.property(testContent, 'metadata', 'content should contain metadata property');
-          assert.property(testContent, 'file', 'content should contain file property');
-          assert.property(testContent.file, 'scr', 'content file should contain scr property');
-        }));
+      it('uploads image to webex files', () =>
+        participants[0].webex.internal.board
+          .addImage(board, fixture, {displayName: fixture.name})
+          .then((fileContent) => {
+            testContent = fileContent[0].items[0];
+            assert.equal(testContent.type, 'FILE', 'content type should be image');
+            assert.property(testContent, 'contentUrl', 'content should contain contentId property');
+            assert.property(
+              testContent,
+              'channelUrl',
+              'content should contain contentUrl property'
+            );
+            assert.property(testContent, 'metadata', 'content should contain metadata property');
+            assert.property(testContent, 'file', 'content should contain file property');
+            assert.property(testContent.file, 'scr', 'content file should contain scr property');
+          }));
 
-      it('adds to presistence', () => participants[0].webex.internal.board.getContents(board)
-        .then((allContents) => {
+      it('adds to presistence', () =>
+        participants[0].webex.internal.board.getContents(board).then((allContents) => {
           const imageContent = find(allContents.items, {contentId: testContent.contentId});
 
           assert.isDefined(imageContent);
@@ -154,13 +188,23 @@ describe('plugin-board', () => {
           return imageContent.file.scr;
         }));
 
-      it('matches file file downloaded', () => participants[0].webex.internal.encryption.download(testScr)
-        .then((downloadedFile) => fh.isMatchingFile(downloadedFile, fixture)
-          .then((result) => assert.deepEqual(result, true))));
-
-      it('allows others to download image', () => participants[2].webex.internal.encryption.download(testScr)
-        .then((downloadedFile) => fh.isMatchingFile(downloadedFile, fixture)
-          .then((result) => assert.deepEqual(result, true))));
+      it('matches file file downloaded', () =>
+        participants[0].webex.internal.encryption
+          .download(testScr)
+          .then((downloadedFile) =>
+            fh
+              .isMatchingFile(downloadedFile, fixture)
+              .then((result) => assert.deepEqual(result, true))
+          ));
+
+      it('allows others to download image', () =>
+        participants[2].webex.internal.encryption
+          .download(testScr)
+          .then((downloadedFile) =>
+            fh
+              .isMatchingFile(downloadedFile, fixture)
+              .then((result) => assert.deepEqual(result, true))
+          ));
 
       describe('when image content has no metadata', () => {
         before(() => participants[0].webex.internal.board.deleteAllContent(board));
@@ -168,12 +212,21 @@ describe('plugin-board', () => {
         it('decrypts no meta', () => {
           let testContent, testScr;
 
-          return participants[0].webex.internal.board.addImage(board, fixture)
+          return participants[0].webex.internal.board
+            .addImage(board, fixture)
             .then((fileContent) => {
               testContent = fileContent[0].items[0];
               assert.equal(testContent.type, 'FILE', 'content type should be image');
-              assert.property(testContent, 'contentUrl', 'content should contain contentId property');
-              assert.property(testContent, 'channelUrl', 'content should contain contentUrl property');
+              assert.property(
+                testContent,
+                'contentUrl',
+                'content should contain contentId property'
+              );
+              assert.property(
+                testContent,
+                'channelUrl',
+                'content should contain contentUrl property'
+              );
               assert.property(testContent, 'file', 'content should contain file property');
               assert.property(testContent.file, 'scr', 'content file should contain scr property');
               assert.deepEqual(testContent.metadata, {});
@@ -190,16 +243,19 @@ describe('plugin-board', () => {
 
               return imageContent.file.scr;
             })
-            .then(() => participants[0].webex.internal.encryption.download(testScr)
-              .then((downloadedFile) => fh.isMatchingFile(downloadedFile, fixture))
-              .then((res) => assert.isTrue(res)));
+            .then(() =>
+              participants[0].webex.internal.encryption
+                .download(testScr)
+                .then((downloadedFile) => fh.isMatchingFile(downloadedFile, fixture))
+                .then((res) => assert.isTrue(res))
+            );
         });
       });
     });
 
     describe('#getChannels()', () => {
-      it('retrieves a newly created board for a specified conversation within a single page', () => participants[0].webex.internal.board.getChannels(conversation)
-        .then((getChannelsResp) => {
+      it('retrieves a newly created board for a specified conversation within a single page', () =>
+        participants[0].webex.internal.board.getChannels(conversation).then((getChannelsResp) => {
           const channelFound = find(getChannelsResp.items, {channelId: board.channelId});
 
           assert.isDefined(channelFound);
@@ -209,11 +265,14 @@ describe('plugin-board', () => {
       it('retrieves annotated board', () => {
         let annotatedBoard;
 
-        return participants[0].webex.internal.board.createChannel(conversation, {type: 'annotated'})
+        return participants[0].webex.internal.board
+          .createChannel(conversation, {type: 'annotated'})
           .then((res) => {
             annotatedBoard = res;
 
-            return participants[0].webex.internal.board.getChannels(conversation, {type: 'annotated'});
+            return participants[0].webex.internal.board.getChannels(conversation, {
+              type: 'annotated',
+            });
           })
           .then((getChannelsResp) => {
             const channelFound = find(getChannelsResp.items, {channelId: annotatedBoard.channelId});
@@ -231,59 +290,65 @@ describe('plugin-board', () => {
         let channelsReceived = [];
         let convo;
 
-        return participants[0].webex.internal.conversation.create({
-          displayName: `Test Get Channels Conversation ${uuid.v4()}`,
-          participants
-        })
-          .then((c) => {
-            convo = c;
-            const promises = [];
-
-            for (let i = 0; i < numChannelsToAdd; i += 1) {
-              promises.push(participants[0].webex.internal.board.createChannel(convo)
-                .then((channel) => {
-                  Reflect.deleteProperty(channel, 'kmsMessage');
-                  channelsCreated.push(channel);
-                }));
-            }
-
-            return Promise.all(promises);
-          })
-          // get boards, page 1
-          .then(() => participants[0].webex.internal.board.getChannels(convo, {
-            channelsLimit: pageLimit
-          }))
-          // get boards, page 2
-          .then((channelPage) => {
-            assert.lengthOf(channelPage.items, pageLimit);
-            assert.isTrue(channelPage.hasNext());
-            channelsReceived = channelsReceived.concat(channelPage.items);
-
-            return channelPage.next();
-          })
-          // get boards, page 3
-          .then((channelPage) => {
-            assert.lengthOf(channelPage.items, pageLimit);
-            assert.isTrue(channelPage.hasNext());
-            channelsReceived = channelsReceived.concat(channelPage.items);
+        return (
+          participants[0].webex.internal.conversation
+            .create({
+              displayName: `Test Get Channels Conversation ${uuid.v4()}`,
+              participants,
+            })
+            .then((c) => {
+              convo = c;
+              const promises = [];
+
+              for (let i = 0; i < numChannelsToAdd; i += 1) {
+                promises.push(
+                  participants[0].webex.internal.board.createChannel(convo).then((channel) => {
+                    Reflect.deleteProperty(channel, 'kmsMessage');
+                    channelsCreated.push(channel);
+                  })
+                );
+              }
+
+              return Promise.all(promises);
+            })
+            // get boards, page 1
+            .then(() =>
+              participants[0].webex.internal.board.getChannels(convo, {
+                channelsLimit: pageLimit,
+              })
+            )
+            // get boards, page 2
+            .then((channelPage) => {
+              assert.lengthOf(channelPage.items, pageLimit);
+              assert.isTrue(channelPage.hasNext());
+              channelsReceived = channelsReceived.concat(channelPage.items);
+
+              return channelPage.next();
+            })
+            // get boards, page 3
+            .then((channelPage) => {
+              assert.lengthOf(channelPage.items, pageLimit);
+              assert.isTrue(channelPage.hasNext());
+              channelsReceived = channelsReceived.concat(channelPage.items);
 
-            return channelPage.next();
-          })
-          .then((channelPage) => {
-            assert.lengthOf(channelPage, 2);
-            assert.isFalse(channelPage.hasNext());
-            channelsReceived = channelsReceived.concat(channelPage.items);
-
-            channelsCreated.sort((a, b) => a.createdTime - b.createdTime);
-            channelsReceived.sort((a, b) => a.createdTime - b.createdTime);
-
-            if (channelsCreated.length === channelsReceived.length) {
-              channelsReceived.forEach((channel, i) => {
-                delete channel.format;
-                assert.deepEqual(channel, channelsCreated[i]);
-              });
-            }
-          });
+              return channelPage.next();
+            })
+            .then((channelPage) => {
+              assert.lengthOf(channelPage, 2);
+              assert.isFalse(channelPage.hasNext());
+              channelsReceived = channelsReceived.concat(channelPage.items);
+
+              channelsCreated.sort((a, b) => a.createdTime - b.createdTime);
+              channelsReceived.sort((a, b) => a.createdTime - b.createdTime);
+
+              if (channelsCreated.length === channelsReceived.length) {
+                channelsReceived.forEach((channel, i) => {
+                  delete channel.format;
+                  assert.deepEqual(channel, channelsCreated[i]);
+                });
+              }
+            })
+        );
       });
     });
 
@@ -292,12 +357,15 @@ describe('plugin-board', () => {
 
       it('adds and gets contents from the specified board', () => {
         const contents = [{type: 'curve'}];
-        const data = [{
-          type: contents[0].type,
-          payload: JSON.stringify(contents[0])
-        }];
+        const data = [
+          {
+            type: contents[0].type,
+            payload: JSON.stringify(contents[0]),
+          },
+        ];
 
-        return participants[0].webex.internal.board.deleteAllContent(board)
+        return participants[0].webex.internal.board
+          .deleteAllContent(board)
           .then(() => participants[0].webex.internal.board.addContent(board, data))
           .then(() => participants[0].webex.internal.board.getContents(board))
           .then((contentPage) => {
@@ -310,12 +378,15 @@ describe('plugin-board', () => {
 
       it('allows other people to read contents', () => {
         const contents = [{type: 'curve', points: [1, 2, 3, 4]}];
-        const data = [{
-          type: contents[0].type,
-          payload: JSON.stringify(contents[0])
-        }];
+        const data = [
+          {
+            type: contents[0].type,
+            payload: JSON.stringify(contents[0]),
+          },
+        ];
 
-        return participants[0].webex.internal.board.addContent(board, data)
+        return participants[0].webex.internal.board
+          .addContent(board, data)
           .then(() => participants[1].webex.internal.board.getContents(board))
           .then((contentPage) => {
             assert.equal(contentPage.length, data.length);
@@ -331,12 +402,15 @@ describe('plugin-board', () => {
 
       it('allows other people to write contents', () => {
         const contents = [{type: 'curve', points: [1, 2, 3, 4]}];
-        const data = [{
-          type: contents[0].type,
-          payload: JSON.stringify(contents[0])
-        }];
+        const data = [
+          {
+            type: contents[0].type,
+            payload: JSON.stringify(contents[0]),
+          },
+        ];
 
-        return participants[2].webex.internal.board.addContent(board, data)
+        return participants[2].webex.internal.board
+          .addContent(board, data)
           .then(() => participants[1].webex.internal.board.getContents(board))
           .then((contentPage) => {
             assert.equal(contentPage.length, data.length);
@@ -348,15 +422,18 @@ describe('plugin-board', () => {
         const numberOfContents = 30;
         let tonsOfContents;
 
-        before('generate contents', () => generateTonsOfContents(numberOfContents)
-          .then((res) => {
+        before('generate contents', () =>
+          generateTonsOfContents(numberOfContents).then((res) => {
             tonsOfContents = res;
-          }));
+          })
+        );
 
-        beforeEach('create contents', () => participants[0].webex.internal.board.addContent(board, tonsOfContents));
+        beforeEach('create contents', () =>
+          participants[0].webex.internal.board.addContent(board, tonsOfContents)
+        );
 
-        it('using the default page limit', () => participants[0].webex.internal.board.getContents(board)
-          .then((res) => {
+        it('using the default page limit', () =>
+          participants[0].webex.internal.board.getContents(board).then((res) => {
             assert.lengthOf(res, numberOfContents);
             assert.isFalse(res.hasNext());
 
@@ -365,17 +442,19 @@ describe('plugin-board', () => {
             }
           }));
 
-        it('using a client defined page limit', () => participants[0].webex.internal.board.getContents(board, {contentsLimit: 25})
-          .then((res) => {
-            assert.lengthOf(res, 25);
-            assert.isTrue(res.hasNext());
+        it('using a client defined page limit', () =>
+          participants[0].webex.internal.board
+            .getContents(board, {contentsLimit: 25})
+            .then((res) => {
+              assert.lengthOf(res, 25);
+              assert.isTrue(res.hasNext());
 
-            return res.next();
-          })
-          .then((res) => {
-            assert.lengthOf(res, numberOfContents - 25);
-            assert.isFalse(res.hasNext());
-          }));
+              return res.next();
+            })
+            .then((res) => {
+              assert.lengthOf(res, numberOfContents - 25);
+              assert.isFalse(res.hasNext());
+            }));
       });
     });
 
@@ -387,25 +466,26 @@ describe('plugin-board', () => {
         const contents = [
           {
             id: uuid.v4(),
-            type: 'file'
+            type: 'file',
           },
           {
             id: uuid.v4(),
-            type: 'string'
-          }
+            type: 'string',
+          },
         ];
         const data = [
           {
             type: contents[0].type,
-            payload: JSON.stringify(contents[0])
+            payload: JSON.stringify(contents[0]),
           },
           {
             type: contents[1].type,
-            payload: JSON.stringify(contents[1])
-          }
+            payload: JSON.stringify(contents[1]),
+          },
         ];
 
-        return participants[0].webex.internal.board.addContent(channel, data)
+        return participants[0].webex.internal.board
+          .addContent(channel, data)
           .then(() => participants[0].webex.internal.board.deleteAllContent(channel))
           .then(() => participants[0].webex.internal.board.getContents(channel))
           .then((res) => {
@@ -424,20 +504,23 @@ describe('plugin-board', () => {
         const data = [
           {
             type: 'STRING',
-            payload: JSON.stringify({id: uuid.v4()})
+            payload: JSON.stringify({id: uuid.v4()}),
           },
           {
             type: 'FILE',
-            payload: JSON.stringify({id: uuid.v4()})
-          }
+            payload: JSON.stringify({id: uuid.v4()}),
+          },
         ];
         const contentsToKeep = [];
 
-        return participants[0].webex.internal.board.addContent(channel, data)
+        return participants[0].webex.internal.board
+          .addContent(channel, data)
           .then(([firstPageRes]) => {
             contentsToKeep.push(firstPageRes.items[1]);
           })
-          .then(() => participants[0].webex.internal.board.deletePartialContent(channel, contentsToKeep))
+          .then(() =>
+            participants[0].webex.internal.board.deletePartialContent(channel, contentsToKeep)
+          )
           .then(() => participants[0].webex.internal.board.getContents(channel))
           .then((page) => {
             assert.lengthOf(page, 1);
@@ -453,50 +536,69 @@ describe('plugin-board', () => {
       it('does not allow board user to create board', () => {
         let currentConvo;
 
-        return participants[0].webex.internal.conversation.create({
-          displayName: 'Test Board Member Leave Conversation',
-          participants
-        })
+        return participants[0].webex.internal.conversation
+          .create({
+            displayName: 'Test Board Member Leave Conversation',
+            participants,
+          })
           .then((c) => {
             currentConvo = c;
 
             return participants[1].webex.internal.conversation.leave(currentConvo);
           })
-          .then(() => assert.isRejected(participants[1].webex.internal.board.createChannel(currentConvo)));
+          .then(() =>
+            assert.isRejected(participants[1].webex.internal.board.createChannel(currentConvo))
+          );
       });
 
       it('does not allow board creator to access and decrypt contents', () => {
         let currentConvo;
         let currentBoard;
         const encryptedBoardContent = {};
-        const data = [{
-          type: 'curve',
-          payload: JSON.stringify({type: 'curve'})
-        }];
-
-        return participants[1].webex.internal.conversation.create({
-          displayName: 'Test Board Creator Leave Conversation',
-          participants
-        })
-          .then((c) => {
-            currentConvo = c;
+        const data = [
+          {
+            type: 'curve',
+            payload: JSON.stringify({type: 'curve'}),
+          },
+        ];
 
-            return participants[1].webex.internal.board.createChannel(currentConvo);
-          })
-          .then((b) => {
-            currentBoard = b;
+        return (
+          participants[1].webex.internal.conversation
+            .create({
+              displayName: 'Test Board Creator Leave Conversation',
+              participants,
+            })
+            .then((c) => {
+              currentConvo = c;
 
-            return participants[1].webex.internal.conversation.leave(currentConvo);
-          })
-          .then(() => participants[0].webex.internal.board.encryptContents(currentBoard.defaultEncryptionKeyUrl, data))
-          .then((encryptedData) => {
-            encryptedBoardContent.items = encryptedData;
+              return participants[1].webex.internal.board.createChannel(currentConvo);
+            })
+            .then((b) => {
+              currentBoard = b;
 
-            return assert.isRejected(participants[1].webex.internal.board.getContents(currentBoard));
-          })
-          // ensure keys aren't cached
-          .then(() => participants[1].webex.unboundedStorage.clear())
-          .then(() => assert.isRejected(participants[1].webex.internal.board.decryptContents(encryptedBoardContent)));
+              return participants[1].webex.internal.conversation.leave(currentConvo);
+            })
+            .then(() =>
+              participants[0].webex.internal.board.encryptContents(
+                currentBoard.defaultEncryptionKeyUrl,
+                data
+              )
+            )
+            .then((encryptedData) => {
+              encryptedBoardContent.items = encryptedData;
+
+              return assert.isRejected(
+                participants[1].webex.internal.board.getContents(currentBoard)
+              );
+            })
+            // ensure keys aren't cached
+            .then(() => participants[1].webex.unboundedStorage.clear())
+            .then(() =>
+              assert.isRejected(
+                participants[1].webex.internal.board.decryptContents(encryptedBoardContent)
+              )
+            )
+        );
       });
     });
 
@@ -504,44 +606,63 @@ describe('plugin-board', () => {
       it('deletes channel', () => {
         let newChannel;
 
-        return participants[1].webex.internal.board.createChannel(conversation)
+        return participants[1].webex.internal.board
+          .createChannel(conversation)
           .then((res) => {
             newChannel = res;
 
             return participants[1].webex.internal.board.deleteChannel(conversation, newChannel);
           })
-          .then(() => assert.isRejected(participants[1].webex.internal.board.getChannel(newChannel)));
+          .then(() =>
+            assert.isRejected(participants[1].webex.internal.board.getChannel(newChannel))
+          );
       });
 
       describe('when preventDeleteActiveChannel is enabled', () => {
         it('does not delete when a channel is being used', () => {
           let activeChannel;
 
-          return participants[1].webex.internal.board.createChannel(conversation)
+          return participants[1].webex.internal.board
+            .createChannel(conversation)
             .then((res) => {
               activeChannel = res;
-              const data = [{
-                type: 'curve',
-                payload: JSON.stringify({type: 'curve'})
-              }];
+              const data = [
+                {
+                  type: 'curve',
+                  payload: JSON.stringify({type: 'curve'}),
+                },
+              ];
 
               // this will mark the channel as being used
               return participants[0].webex.internal.board.addContent(activeChannel, data);
             })
-            .then(() => assert.isRejected(participants[1].webex.internal.board.deleteChannel(conversation, activeChannel, {preventDeleteActiveChannel: true})))
+            .then(() =>
+              assert.isRejected(
+                participants[1].webex.internal.board.deleteChannel(conversation, activeChannel, {
+                  preventDeleteActiveChannel: true,
+                })
+              )
+            )
             .then(() => participants[1].webex.internal.board.getChannel(activeChannel));
         });
 
         it('deletes inactive channel', () => {
           let inActiveChannel;
 
-          return participants[1].webex.internal.board.createChannel(conversation)
+          return participants[1].webex.internal.board
+            .createChannel(conversation)
             .then((res) => {
               inActiveChannel = res;
 
-              return participants[1].webex.internal.board.deleteChannel(conversation, inActiveChannel, {preventDeleteActiveChannel: true});
+              return participants[1].webex.internal.board.deleteChannel(
+                conversation,
+                inActiveChannel,
+                {preventDeleteActiveChannel: true}
+              );
             })
-            .then(() => assert.isRejected(participants[1].webex.internal.board.getChannel(inActiveChannel)));
+            .then(() =>
+              assert.isRejected(participants[1].webex.internal.board.getChannel(inActiveChannel))
+            );
         });
       });
     });
@@ -550,19 +671,24 @@ describe('plugin-board', () => {
       it('locks a channel for deletion which rejects any incoming activities', () => {
         let newChannel;
 
-        return participants[1].webex.internal.board.createChannel(conversation)
+        return participants[1].webex.internal.board
+          .createChannel(conversation)
           .then((res) => {
             newChannel = res;
 
             return participants[1].webex.internal.board.lockChannelForDeletion(newChannel);
           })
           .then(() => {
-            const data = [{
-              type: 'curve',
-              payload: JSON.stringify({type: 'curve'})
-            }];
+            const data = [
+              {
+                type: 'curve',
+                payload: JSON.stringify({type: 'curve'}),
+              },
+            ];
 
-            return assert.isRejected(participants[0].webex.internal.board.addContent(newChannel, data));
+            return assert.isRejected(
+              participants[0].webex.internal.board.addContent(newChannel, data)
+            );
           });
       });
     });
@@ -571,19 +697,20 @@ describe('plugin-board', () => {
       it('keeps a channel status as active', () => {
         let newChannel;
 
-        return participants[1].webex.internal.board.createChannel(conversation)
+        return participants[1].webex.internal.board
+          .createChannel(conversation)
           .then((res) => {
             newChannel = res;
 
             return participants[1].webex.internal.board.keepActive(newChannel);
           })
-          .then(() => assert.isRejected(participants[0].webex.internal.board.deleteChannel(
-            conversation,
-            newChannel,
-            {
-              preventDeleteActiveChannel: true
-            }
-          )));
+          .then(() =>
+            assert.isRejected(
+              participants[0].webex.internal.board.deleteChannel(conversation, newChannel, {
+                preventDeleteActiveChannel: true,
+              })
+            )
+          );
       });
     });
   });