@webex/plugin-meetings 3.0.0-beta.1 → 3.0.0-beta.104

package/test/utils/testUtils.js

@@ -1,5 +1,3 @@
-import {assert} from '@webex/test-helper-chai';
-import {Defer} from '@webex/common';
 
 const max = 30000;
 const waitForSpy = (spy, event) => {
@@ -19,7 +17,7 @@ const waitForSpy = (spy, event) => {
           resolve(spy.args[0][0]);
         }
       }, 1000);
-    })
+    }),
   ]);
 };
 
@@ -40,7 +38,7 @@ const waitForStateChange = (meeting, state) => {
           resolve(meeting.locusInfo.parsedLocus.states);
         }
       }, 1000);
-    })
+    }),
   ]);
 };
 
@@ -59,44 +57,46 @@ const waitForCallEnded = (user, email) => {
           clearTimeout(timer);
           clearInterval(interval);
           resolve();
-        }
-        else {
+        } else {
           console.log('MEETING STILL EXISTS!', user.webex.meetings.getAllMeetings());
         }
       }, 3000);
-    })
+    }),
   ]);
 };
 
-const syncAndEndMeeting = (user) => user.webex.meetings.syncMeetings()
-  .then(() => {
-    const promise = [];
-    const meetings = user.webex.meetings.getAllMeetings();
+const syncAndEndMeeting = (user) =>
+  user.webex.meetings
+    .syncMeetings()
+    .then(() => {
+      const promise = [];
+      const meetings = user.webex.meetings.getAllMeetings();
 
-    if (Object.keys(meetings).length === 0) {
-      return Promise.resolve();
-    }
-    Object.keys(meetings)
-      .forEach((key) => {
+      if (Object.keys(meetings).length === 0) {
+        return Promise.resolve();
+      }
+      Object.keys(meetings).forEach((key) => {
         promise.push(meetings[key].leave());
       });
 
-    return Promise.all(promise);
-  })
-  .then(() => new Promise((resolve) => {
-    const interval = setInterval(() => {
-      if (Object.keys(user.webex.meetings.getAllMeetings()).length === 0) {
-        clearInterval(interval);
-        resolve();
-      }
-      else {
-        console.log('End Meetings before test failed');
-      }
-    }, 3000);
-  }))
-  .catch((e) => {
-    console.log('ERROR on syncMeeting', e);
-  });
+      return Promise.all(promise);
+    })
+    .then(
+      () =>
+        new Promise((resolve) => {
+          const interval = setInterval(() => {
+            if (Object.keys(user.webex.meetings.getAllMeetings()).length === 0) {
+              clearInterval(interval);
+              resolve();
+            } else {
+              console.log('End Meetings before test failed');
+            }
+          }, 3000);
+        })
+    )
+    .catch((e) => {
+      console.log('ERROR on syncMeeting', e);
+    });
 
 //
 const waitForEvents = (scopeEvents, timeout = max) => {
@@ -125,11 +125,12 @@ const waitForEvents = (scopeEvents, timeout = max) => {
               obj.user.memberId = value.meeting.locusInfo.parsedLocus.selfId;
             }
             if (obj.event === 'meeting:removed') {
-              console.log(`MEETING:REMOVED ${obj.user.name} ID ${obj.user.meeting.id} correlationID ${obj.user.meeting.correlationId}`);
+              console.log(
+                `MEETING:REMOVED ${obj.user.name} ID ${obj.user.meeting.id} correlationID ${obj.user.meeting.correlationId}`
+              );
               if (obj.user.meeting.id === value.meetingId) {
                 obj.user.meeting = null;
-              }
-              else {
+              } else {
                 console.log('MEETING EXISTING ', obj.user.webex.meetings.getAllMeetings());
                 reject(new Error(`Different Meeting Object ${value}`));
               }
@@ -142,8 +143,7 @@ const waitForEvents = (scopeEvents, timeout = max) => {
 
                 resolve(result);
               }
-            }
-            else if (result.length === scopeEvents.length) {
+            } else if (result.length === scopeEvents.length) {
               resolve(result);
               obj.scope.off(obj.event, handler);
               clearTimeout(timer);
@@ -152,12 +152,11 @@ const waitForEvents = (scopeEvents, timeout = max) => {
 
           obj.scope.on(obj.event, handler);
         });
-      }
-      catch (e) {
+      } catch (e) {
         console.error('waitForEvents', e);
         reject(e);
       }
-    })
+    }),
   ]);
 };
 
@@ -172,72 +171,36 @@ const delayedPromise = (promise) => {
     }),
     new Promise((resolve, reject) => {
       setTimeout(() => {
-        promise.then((res) => {
-          resolve(res);
-          clearTimeout(timer);
-        })
+        promise
+          .then((res) => {
+            resolve(res);
+            clearTimeout(timer);
+          })
           .catch((e) => {
             console.error('delayedPromise', e);
             reject(e);
           });
       }, 2000);
-    })
+    }),
   ]);
 };
 
-const delayedTest = (callback, timeout) => new Promise((resolve) => {
-  setTimeout(() => {
-    callback();
-    resolve();
-  }, timeout);
-});
-
-const addMedia = (user) => {
-  const mediaReadyPromises = {
-    local: new Defer(),
-    remoteAudio: new Defer(),
-    remoteVideo: new Defer(),
-  };
-  const mediaReady = (media) => {
-    if (!media) {
-      return;
-    }
-    if (mediaReadyPromises[media.type]) {
-      mediaReadyPromises[media.type].resolve();
-    }
-  };
+const delayedTest = (callback, timeout) =>
+  new Promise((resolve) => {
+    setTimeout(() => {
+      callback();
+      resolve();
+    }, timeout);
+  });
 
-  user.meeting.on('media:ready', mediaReady);
 
-  return user.meeting.getMediaStreams({
-    sendAudio: true,
-    sendVideo: true,
-    sendShare: false
-  })
-    .then(([localStream, localShare]) => user.meeting.addMedia({
-      mediaSettings: {
-        sendAudio: true,
-        sendVideo: true,
-        sendShare: false,
-        receiveShare: true,
-        receiveAudio: true,
-        receiveVideo: true
-      },
-      localShare,
-      localStream
-    }))
-    .then(() => Promise.all(Object.values(mediaReadyPromises).map((defer) => defer.promise)))
-    .then(() => {
-      assert.exists(user.meeting.mediaProperties.audioTrack, 'audioTrack not present');
-      assert.exists(user.meeting.mediaProperties.videoTrack, 'videoTrack not present');
-    });
-};
 
-const waitUntil = (waitTime) => new Promise((resolve) => {
-  setTimeout(() => {
-    resolve();
-  }, waitTime);
-});
+const waitUntil = (waitTime) =>
+  new Promise((resolve) => {
+    setTimeout(() => {
+      resolve();
+    }, waitTime);
+  });
 
 const flushPromises = () => new Promise(setImmediate);
 
@@ -259,7 +222,10 @@ const getCircularReplacer = () => {
 
 // this function is meant to be used as the "match" callback with waitForEvents()
 // when you want to wait for a particular users's status to reach a certain value
-const checkParticipantUpdatedStatus = (user, expectedStatus) => (event) => !!event.delta.updated.find((member) => user.meeting.members.selfId === member.id && member.status === expectedStatus);
+const checkParticipantUpdatedStatus = (user, expectedStatus) => (event) =>
+  !!event.delta.updated.find(
+    (member) => user.meeting.members.selfId === member.id && member.status === expectedStatus
+  );
 
 export default {
   waitForSpy,
@@ -269,10 +235,8 @@ export default {
   waitForEvents,
   checkParticipantUpdatedStatus,
   delayedPromise,
-  addMedia,
   waitUntil,
   delayedTest,
   flushPromises,
-  getCircularReplacer
+  getCircularReplacer,
 };
-

package/test/utils/webex-config.js

@@ -8,29 +8,29 @@ const SCOPE = [
   'spark:memberships_read',
   'spark:memberships_write',
   'spark:messages_read',
-  'spark:messages_write'
+  'spark:messages_write',
 ].join(' ');
 
 const Config = {
-  version: (() => process.env.BUILD_VERSION || -1),
-  appType: (() => {
+  version: () => process.env.BUILD_VERSION || -1,
+  appType: () => {
     const type = 'Web';
 
     return type;
-  }),
+  },
   clientId: process.env.WEBEX_CLIENT_ID,
-  clientSecret: process.env.WEBEX_CLIENT_SECRET
+  clientSecret: process.env.WEBEX_CLIENT_SECRET,
 };
 
 Config.allowedOutboundTags = {
-  'webex-mention': ['data-object-type', 'data-object-id', 'data-group-type', 'data-object-url']
+  'webex-mention': ['data-object-type', 'data-object-id', 'data-group-type', 'data-object-url'],
 };
 
 Config.webex = {
   maxReconnectAttempts: 5,
   conversation: {
     allowedInboundTags: Config.allowedInboundTags,
-    allowedOutboundTags: Config.allowedOutboundTags
+    allowedOutboundTags: Config.allowedOutboundTags,
   },
   credentials: {
     clientType: 'confidential',
@@ -39,39 +39,43 @@ Config.webex = {
       client_id: Config.clientId,
       client_secret: Config.clientSecret,
       redirect_uri: process.env.LAUNCH_URL,
-      scope: SCOPE
-    }
+      scope: SCOPE,
+    },
   },
   encryption: {
-    decryptionFailureMessage: 'This message cannot be decrypted'
+    decryptionFailureMessage: 'This message cannot be decrypted',
   },
   logger: {
-    level: process.env.NODE_ENV === 'test' ? 'error' : 'error'
+    level: process.env.NODE_ENV === 'test' ? 'error' : 'error',
   },
   meetings: {
     metrics: {
-      autoSendMQA: true
+      autoSendMQA: true,
     },
     autoUploadLogs: false,
     reconnection: {
-      enabled: true
+      enabled: true,
+    },
+    enableRtx: true,
+    experimental: {
+      enableMediaNegotiatedEvent: true,
+      enableUnifiedMeetings: true,
     },
-    enableRtx: true
   },
   people: {
-    showAllTypes: true
+    showAllTypes: true,
   },
   metrics: {
     appVersion: Config.version,
-    appType: Config.appType
+    appType: Config.appType,
   },
   support: {
     appVersion: Config.version,
     appType: Config.appType,
-    languageCode: 'en'
+    languageCode: 'en',
   },
   trackingIdPrefix: 'ITCLIENT',
-  trackingIdSuffix: 'imu:false_imi:true'
+  trackingIdSuffix: 'imu:false_imi:true',
 };
 
 module.exports = Config;

package/test/utils/webex-test-users.js

@@ -8,6 +8,7 @@ const config = require('./webex-config');
 
 // Include the plugins which you feel will be used by the webex instance
 require('@webex/internal-plugin-mercury');
+require('@webex/internal-plugin-llm');
 require('@webex/internal-plugin-user');
 require('@webex/internal-plugin-device');
 require('@webex/internal-plugin-conversation');
@@ -16,64 +17,70 @@ require('@webex/plugin-people');
 require('@webex/plugin-rooms');
 require('@webex/plugin-meetings');
 
-const generateTestUsers = (options) => testUser.create({count: options.count})
-  .then(async (userSet) => {
-    if (userSet.length !== options.count) {
-      return Promise.reject(new Error('Test users not created'));
-    }
+const generateTestUsers = (options = {}) => {
+  options.config = options.config || {};
+  options.config.orgId = options.config.orgId || process.env.WEBEX_CONVERGED_ORG_ID;
 
-    // Pause for 5 seconds for CI
-    await new Promise((done) => setTimeout(done, 5000));
+  return testUser.create(options)
+    .then(async (userSet) => {
+      if (userSet.length !== options.count) {
+        return Promise.reject(new Error('Test users not created'));
+      }
 
-    const userRegisterPromises = [];
+      // Pause for 5 seconds for CI
+      await new Promise((done) => setTimeout(done, 5000));
 
-    userSet.forEach((user) => {
-      // eslint-disable-next-line no-param-reassign
-      user.webex = new WebexCore({
-        config: config.webex,
-        credentials: {
-          authorization: user.token
-        },
-        meetings: {
-          autoUploadLogs: false
-        }
-      });
+      const userRegisterPromises = [];
 
-      user.webex.internal.support.submitLogs = sinon.stub().returns(Promise.resolve());
+      userSet.forEach((user) => {
+        // eslint-disable-next-line no-param-reassign
+        user.webex = new WebexCore({
+          config: config.webex,
+          credentials: {
+            authorization: user.token,
+          },
+          meetings: {
+            autoUploadLogs: false,
+          },
+        });
 
-      userRegisterPromises.push(user.webex.meetings.register());
-    });
+        user.webex.internal.support.submitLogs = sinon.stub().returns(Promise.resolve());
 
-    return Promise.all(userRegisterPromises)
-      .then(() => userSet);
-  })
-  .catch((error) => {
-    console.error('#generateTestUsers=>ERROR', error);
-  });
+        userRegisterPromises.push(user.webex.meetings.register());
+      });
 
-const reserveCMR = (user) => user.webex.request({
-  method: 'POST',
-  uri: 'https://whistler-prod.allnint.ciscospark.com/api/v1/reservations',
-  headers: {
-    authorization: `Bearer ${user.webex.credentials.supertoken.access_token}`,
-    'cisco-no-http-redirect': null,
-    'spark-user-agent': null,
-    trackingid: `ITCLIENT_ ${user.id} _0_imi:true`
-  },
-  body: {
-    resourceType: 'CMR_3',
-    reservedBy: 'SDK_TEST_USER',
-    requestMetaData: {
-      emailAddress: user.emailAddress,
-      loginType: 'loginGuest'
-    }
-  }
-})
-  .then((res) => {
-    console.log('SUCCESS ', res);
-  });
+      return Promise.all(userRegisterPromises).then(() => userSet);
+    })
+    .catch((error) => {
+      console.error('#generateTestUsers=>ERROR', error);
+    });
+};
+
+const reserveCMR = (user) =>
+  user.webex
+    .request({
+      method: 'POST',
+      uri: 'https://whistler-prod.allnint.ciscospark.com/api/v1/reservations',
+      headers: {
+        authorization: `Bearer ${user.webex.credentials.supertoken.access_token}`,
+        'cisco-no-http-redirect': null,
+        'spark-user-agent': null,
+        trackingid: `ITCLIENT_ ${user.id} _0_imi:true`,
+      },
+      body: {
+        resourceType: 'CMR_3',
+        reservedBy: 'SDK_TEST_USER',
+        requestMetaData: {
+          emailAddress: user.emailAddress,
+          loginType: 'loginGuest',
+        },
+      },
+    })
+    .then((res) => {
+      console.log('SUCCESS ', res);
+    });
 
 module.exports = {
   generateTestUsers,
-  reserveCMR
+  reserveCMR,
 };

package/tsconfig.json

@@ -0,0 +1,6 @@
+{
+    "extends": "../../../tsconfig.json",
+    "include": [
+        "src"
+    ],
+}