@webex/plugin-meetings 3.7.0-next.9 → 3.7.0-wxcc.1

package/test/unit/spec/meeting/utils.js

@@ -26,7 +26,7 @@ describe('plugin-meetings', () => {
       webex.meetings.reachability = {
         getReachabilityReportToAttachToRoap: sinon.stub().resolves({}),
         getClientMediaPreferences: sinon.stub().resolves({}),
-      };  
+      };
 
       const logger = {
         info: sandbox.stub(),
@@ -165,21 +165,6 @@ describe('plugin-meetings', () => {
           assert(LoggerProxy.logger.log.called, 'log called');
         });
       });
-
-      describe('#handleDeviceLogging', () => {
-        it('should not log if called without devices', () => {
-          MeetingUtil.handleDeviceLogging();
-          assert(!LoggerProxy.logger.log.called, 'log not called');
-        });
-
-        it('should log device settings', () => {
-          const mockDevices = [{deviceId: 'device-1'}, {deviceId: 'device-2'}];
-
-          assert(MeetingUtil.handleDeviceLogging, 'is defined');
-          MeetingUtil.handleDeviceLogging(mockDevices);
-          assert(LoggerProxy.logger.log.called, 'log called');
-        });
-      });
     });
 
     describe('addSequence', () => {
@@ -424,17 +409,17 @@ describe('plugin-meetings', () => {
         const FAKE_CLIENT_MEDIA_PREFERENCES = {
           id: 'fake client media preferences',
         };
-  
+
         webex.meetings.reachability.getReachabilityReportToAttachToRoap.resolves(FAKE_REACHABILITY_REPORT);
         webex.meetings.reachability.getClientMediaPreferences.resolves(FAKE_CLIENT_MEDIA_PREFERENCES);
-        
+
         sinon
           .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV4')
           .get(() => true);
         sinon
           .stub(webex.internal.device.ipNetworkDetector, 'supportsIpV6')
           .get(() => true);
-          
+
         await MeetingUtil.joinMeeting(meeting, {
           reachability: 'reachability',
           roapMessage: 'roapMessage',
@@ -484,6 +469,17 @@ describe('plugin-meetings', () => {
         assert.calledOnce(meeting.meetingRequest.joinMeeting);
       });
 
+      it('should not attach reachability if there is no roap message', async () => {
+        await MeetingUtil.joinMeeting(meeting, {});
+
+        assert.notCalled(webex.meetings.reachability.getReachabilityReportToAttachToRoap);
+        assert.calledOnce(meeting.meetingRequest.joinMeeting);
+
+        const parameter = meeting.meetingRequest.joinMeeting.getCall(0).args[0];
+        assert.isUndefined(parameter.reachability);
+        assert.isUndefined(parameter.roapMessage);
+      });
+
       it('should handle failed clientMediaPreferences retrieval', async () => {
         webex.meetings.reachability.getClientMediaPreferences.rejects(new Error('fake error'));
         meeting.isMultistream = true;
@@ -775,6 +771,13 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('canStartBreakout', () => {
+      it('works as expected', () => {
+        assert.deepEqual(MeetingUtil.canStartBreakout(['DISABLE_BREAKOUT_START']), false);
+        assert.deepEqual(MeetingUtil.canStartBreakout([]), true);
+      });
+    });
+
     describe('canBroadcastMessageToBreakout', () => {
       it('works as expected', () => {
         assert.deepEqual(

package/test/unit/spec/meeting-info/meetinginfov2.js

@@ -18,7 +18,8 @@ import MeetingInfo, {
   MeetingInfoV2CaptchaError,
   MeetingInfoV2AdhocMeetingError,
   MeetingInfoV2PolicyError,
-  MeetingInfoV2WebinarRegistrationError,
+  MeetingInfoV2JoinWebinarError,
+  MeetingInfoV2JoinForbiddenError,
 } from '@webex/plugin-meetings/src/meeting-info/meeting-info-v2';
 import MeetingInfoUtil from '@webex/plugin-meetings/src/meeting-info/utilv2';
 import Metrics from '@webex/plugin-meetings/src/metrics';
@@ -895,9 +896,14 @@ describe('plugin-meetings', () => {
           {errorCode: 403021},
           {errorCode: 403022},
           {errorCode: 403024},
+          {errorCode: 403137},
+          {errorCode: 423007},
+          {errorCode: 403026},
+          {errorCode: 403037},
+          {errorCode: 403137},
         ],
         ({errorCode}) => {
-          it(`should throw a MeetingInfoV2WebinarRegistrationError for error code ${errorCode}`, async () => {
+          it(`should throw a MeetingInfoV2JoinWebinarError for error code ${errorCode}`, async () => {
             const message = 'a message';
             const meetingInfoData = {meetingInfo: {registrationUrl: 'registrationUrl'}};
 
@@ -909,7 +915,7 @@ describe('plugin-meetings', () => {
               await meetingInfo.createAdhocSpaceMeeting(conversationUrl, installedOrgID);
               assert.fail('createAdhocSpaceMeeting should have thrown, but has not done that');
             } catch (err) {
-              assert.instanceOf(err, MeetingInfoV2WebinarRegistrationError);
+              assert.instanceOf(err, MeetingInfoV2JoinWebinarError);
               assert.deepEqual(err.message, `${message}, code=${errorCode}`);
               assert.equal(err.wbxAppApiCode, errorCode);
               assert.deepEqual(err.meetingInfo, meetingInfoData);
@@ -917,7 +923,43 @@ describe('plugin-meetings', () => {
               assert(Metrics.sendBehavioralMetric.calledOnce);
               assert.calledWith(
                 Metrics.sendBehavioralMetric,
-                BEHAVIORAL_METRICS.WEBINAR_REGISTRATION_ERROR,
+                BEHAVIORAL_METRICS.JOIN_WEBINAR_ERROR,
+                {code: errorCode}
+              );
+
+            }
+          });
+        }
+      );
+
+      forEach(
+        [
+          {errorCode: 403003},
+        ],
+        ({errorCode}) => {
+          it(`should throw a MeetingInfoV2JoinForbiddenError for error code ${errorCode}`, async () => {
+            const message = 'a message';
+            const meetingInfoData = 'meeting info';
+
+            webex.request = sinon.stub().rejects({
+              statusCode: 403,
+              body: {message, code: errorCode, data: {meetingInfo: meetingInfoData}},
+            });
+            try {
+              await meetingInfo.fetchMeetingInfo('1234323', DESTINATION_TYPE.MEETING_ID, 'abc', {
+                id: '999',
+                code: 'aabbcc11',
+              });
+            } catch (err) {
+              assert.instanceOf(err, MeetingInfoV2JoinForbiddenError);
+              assert.deepEqual(err.message, `${message}, code=${errorCode}`);
+              assert.equal(err.wbxAppApiCode, errorCode);
+              assert.deepEqual(err.meetingInfo, meetingInfoData);
+
+              assert(Metrics.sendBehavioralMetric.calledOnce);
+              assert.calledWith(
+                Metrics.sendBehavioralMetric,
+                BEHAVIORAL_METRICS.JOIN_FORBIDDEN_ERROR,
                 {code: errorCode}
               );
 

package/test/unit/spec/meeting-info/utilv2.js

@@ -345,5 +345,22 @@ describe('plugin-meetings', () => {
         );
       });
     });
+
+    describe('#isMeetingLink', () => {
+      it('should return true for valid join meeting link with MTID', () => {
+        const result = MeetingInfoUtil.isMeetingLink('https://cisco.webex.com/cisco/j.php?MTID=m9fe0afd8c435e892afcce9ea25b97046');
+        expect(result).to.be.true;
+      });
+
+      it('should return true for valid join meeting link without cisco domain', () => {
+        const result = MeetingInfoUtil.isMeetingLink('https://test.webex.com/test/j.php?MTID=m9fe0afd8c435e892afcce9ea25b97046');
+        expect(result).to.be.true;
+      });
+
+      it('should return false for an invalid meeting link', () => {
+        const result = MeetingInfoUtil.isMeetingLink('https://test.webex.com/test/j.php?MiD=m9fe0afd8c435e892afcce9ea25b97046');
+        expect(result).to.be.false;
+      });
+    });
   });
 });

package/test/unit/spec/meetings/index.js

@@ -37,11 +37,13 @@ import {
   LOCUSINFO,
   EVENT_TRIGGERS,
   DESTINATION_TYPE,
+  INITIAL_REGISTRATION_STATUS,
 } from '../../../../src/constants';
 import CaptchaError from '@webex/plugin-meetings/src/common/errors/captcha-error';
 import {forEach} from 'lodash';
 import PasswordError from '@webex/plugin-meetings/src/common/errors/password-error';
 import PermissionError from '@webex/plugin-meetings/src/common/errors/permission';
+import JoinForbiddenError from '@webex/plugin-meetings/src/common/errors/join-forbidden-error';
 import {NoiseReductionEffect, VirtualBackgroundEffect} from '@webex/media-helpers';
 import NoMeetingInfoError from '../../../../src/common/errors/no-meeting-info';
 
@@ -267,6 +269,33 @@ describe('plugin-meetings', () => {
       });
     });
 
+    describe('#_setLogUploadIntervalMultiplicationFactor', () => {
+      it('should have _setLogUploadIntervalMultiplicationFactor', () => {
+        assert.equal(typeof webex.meetings._setLogUploadIntervalMultiplicationFactor, 'function');
+      });
+
+      describe('success', () => {
+        it('should update the config', () => {
+          const someValue = 1.23;
+
+          webex.meetings._setLogUploadIntervalMultiplicationFactor(someValue);
+          assert.equal(webex.meetings.config.logUploadIntervalMultiplicationFactor, someValue);
+        });
+      });
+
+      describe('failure', () => {
+        it('should not accept non-number input', () => {
+          const logUploadIntervalMultiplicationFactor = webex.meetings.config.logUploadIntervalMultiplicationFactor;
+
+          webex.meetings._setLogUploadIntervalMultiplicationFactor('test');
+          assert.equal(
+            webex.meetings.config.logUploadIntervalMultiplicationFactor,
+            logUploadIntervalMultiplicationFactor
+          );
+        });
+      });
+    });
+
     describe('#_toggleUnifiedMeetings', () => {
       it('should have toggleUnifiedMeetings', () => {
         assert.equal(typeof webex.meetings._toggleUnifiedMeetings, 'function');
@@ -375,21 +404,21 @@ describe('plugin-meetings', () => {
           assert.isTrue(webex.meetings.registered);
         });
 
-        it('rejects when SDK canAuthorize is false', () => {
+        it('rejects when SDK canAuthorize is false', async () => {
           webex.canAuthorize = false;
-          assert.isRejected(webex.meetings.register());
+          await assert.isRejected(webex.meetings.register());
         });
 
-        it('rejects when device.register fails', () => {
+        it('rejects when device.register fails', async () => {
           webex.canAuthorize = true;
           webex.internal.device.register = sinon.stub().returns(Promise.reject());
-          assert.isRejected(webex.meetings.register());
+          await assert.isRejected(webex.meetings.register());
         });
 
-        it('rejects when mercury.connect fails', () => {
+        it('rejects when mercury.connect fails', async () => {
           webex.canAuthorize = true;
           webex.internal.mercury.connect = sinon.stub().returns(Promise.reject());
-          assert.isRejected(webex.meetings.register());
+          await assert.isRejected(webex.meetings.register());
         });
 
         it('resolves immediately if already registered', async () => {
@@ -420,6 +449,100 @@ describe('plugin-meetings', () => {
             includeDetails: CatalogDetails.features,
           });
         });
+
+        it('updates registration status as expected', async () => {
+          const clock = sinon.useFakeTimers();
+
+          const delay = (secs) => () =>
+            new Promise((resolve) => {
+              setTimeout(resolve, secs * 1000);
+            });
+
+          let i = 1;
+          sinon.stub(webex.meetings, 'fetchUserPreferredWebexSite').callsFake(delay(i++));
+          MeetingsUtil.checkH264Support.callsFake(delay(i++));
+          webex.meetings.startReachability.callsFake(delay(i++));
+          webex.internal.device.register.callsFake(delay(i++));
+          sinon.stub(webex.meetings, 'getGeoHint').callsFake(delay(i++));
+          webex.internal.mercury.connect.callsFake(delay(i++));
+
+          webex.canAuthorize = true;
+          webex.meetings.registered = false;
+
+          const registerPromise = webex.meetings.register({
+            includeDetails: CatalogDetails.features,
+          });
+
+          await clock.tick(1000);
+          await webex.meetings.fetchUserPreferredWebexSite;
+          assert.deepEqual(webex.meetings.registrationStatus, {
+            fetchWebexSite: true,
+            getGeoHint: false,
+            startReachability: false,
+            deviceRegister: false,
+            mercuryConnect: false,
+            checkH264Support: false,
+          });
+
+          await clock.tick(1000);
+          await MeetingsUtil.checkH264Support;
+          assert.deepEqual(webex.meetings.registrationStatus, {
+            fetchWebexSite: true,
+            getGeoHint: false,
+            startReachability: false,
+            deviceRegister: false,
+            mercuryConnect: false,
+            checkH264Support: true,
+          });
+
+          await clock.tick(1000);
+          await webex.meetings.startReachability;
+          assert.deepEqual(webex.meetings.registrationStatus, {
+            fetchWebexSite: true,
+            getGeoHint: false,
+            startReachability: true,
+            deviceRegister: false,
+            mercuryConnect: false,
+            checkH264Support: true,
+          });
+
+          await clock.tick(1000);
+          await webex.internal.device.register;
+          assert.deepEqual(webex.meetings.registrationStatus, {
+            fetchWebexSite: true,
+            getGeoHint: false,
+            startReachability: true,
+            deviceRegister: true,
+            mercuryConnect: false,
+            checkH264Support: true,
+          });
+
+          await clock.tick(1000);
+          await webex.meetings.getGeoHint;
+          assert.deepEqual(webex.meetings.registrationStatus, {
+            fetchWebexSite: true,
+            getGeoHint: true,
+            startReachability: true,
+            deviceRegister: true,
+            mercuryConnect: false,
+            checkH264Support: true,
+          });
+
+          await clock.tick(6000);
+          await webex.internal.mercury.connect;
+          assert.deepEqual(webex.meetings.registrationStatus, {
+            fetchWebexSite: true,
+            getGeoHint: true,
+            startReachability: true,
+            deviceRegister: true,
+            mercuryConnect: true,
+            checkH264Support: true,
+          });
+
+          await registerPromise;
+
+          clock.restore();
+        });
       });
 
       describe('#unregister', () => {
@@ -440,27 +563,36 @@ describe('plugin-meetings', () => {
           });
         });
 
-        it('rejects when device.unregister fails', () => {
+        it('rejects when device.unregister fails', async () => {
           webex.meetings.registered = true;
           webex.internal.device.unregister = sinon.stub().returns(Promise.reject());
-          assert.isRejected(webex.meetings.unregister());
+          await assert.isRejected(webex.meetings.unregister());
         });
 
-        it('rejects when mercury.disconnect fails', () => {
+        it('rejects when mercury.disconnect fails', async () => {
           webex.meetings.registered = true;
           webex.internal.mercury.disconnect = sinon.stub().returns(Promise.reject());
-          assert.isRejected(webex.meetings.unregister());
+          await assert.isRejected(webex.meetings.unregister());
         });
 
-        it('resolves immediately if already registered', (done) => {
+        it('resolves immediately if not registered', (done) => {
           webex.meetings.registered = false;
           webex.meetings.unregister().then(() => {
-            assert.notCalled(webex.internal.device.register);
-            assert.notCalled(webex.internal.mercury.connect);
+            assert.notCalled(webex.internal.device.unregister);
+            assert.notCalled(webex.internal.mercury.disconnect);
             assert.isFalse(webex.meetings.registered);
             done();
           });
         });
+
+        it('resets registration status', (done) => {
+          webex.meetings.registered = true;
+          webex.meetings.registrationStatus = {foo: 'bar'};
+          webex.meetings.unregister().then(() => {
+            assert.deepEqual(webex.meetings.registrationStatus, INITIAL_REGISTRATION_STATUS);
+            done();
+          });
+        });
       });
 
       describe('virtual background effect', () => {
@@ -1921,6 +2053,11 @@ describe('plugin-meetings', () => {
                 debugLogMessage:
                   'Meetings:index#createMeeting --> Debug PermissionError: Not allowed to execute the function, some properties on server, or local client state do not allow you to complete this action. fetching /meetingInfo for creation.',
               },
+              {
+                error: new JoinForbiddenError(),
+                debugLogMessage:
+                  'Meetings:index#createMeeting --> Debug JoinForbiddenError: Meeting join forbidden. fetching /meetingInfo for creation.',
+              },
               {
                 error: new Error(),
                 infoLogMessage: true,

package/test/unit/spec/meetings/utils.js

@@ -290,4 +290,14 @@ describe('plugin-meetings', () => {
       assert.equal(MeetingsUtil.isValidBreakoutLocus(newLocus), true);
     });
   });
+
+  describe('#getMediaServer', () => {
+    it('returns the contents of o-line lower cased', () => {
+      const sdp1 = 'v=0\r\no=homer 0 1 IN IP4 23.89.67.81\r\ns=-\r\nc=IN IP4 23.89.67.81\r\nb=TIAS:128000\r\nt=0 0\r\na=ice-lite\r\n'
+      assert.equal(MeetingsUtil.getMediaServer(sdp1), 'homer');
+
+      const sdp2 = 'v=0\r\no=HOMER 0 1 IN IP4 23.89.67.81\r\ns=-\r\nc=IN IP4 23.89.67.81\r\nb=TIAS:128000\r\nt=0 0\r\na=ice-lite\r\n'
+      assert.equal(MeetingsUtil.getMediaServer(sdp2), 'homer');
+    });
+  })
 });

package/test/unit/spec/member/util.js

@@ -5,13 +5,13 @@ import {_SEND_RECEIVE_, _RECEIVE_ONLY_} from '../../../../src/constants';
 
 describe('plugin-meetings', () => {
   describe('isHandRaised', () => {
-    it('throws error when there is no participant', () => {
+    it('throws an error when there is no participant', () => {
       assert.throws(() => {
         MemberUtil.isHandRaised();
       }, 'Raise hand could not be processed, participant is undefined.');
     });
 
-    it('returns false when controls is not there', () => {
+    it('returns false when controls are not present', () => {
       const participant = {};
 
       assert.isFalse(MemberUtil.isHandRaised(participant));
@@ -51,7 +51,7 @@ describe('plugin-meetings', () => {
   });
 
   describe('MemberUtil.canReclaimHost', () => {
-    it('throws error when there is no participant', () => {
+    it('throws an error when there is no participant', () => {
       assert.throws(() => {
         MemberUtil.canReclaimHost();
       }, 'canReclaimHostRole could not be processed, participant is undefined.');
@@ -352,8 +352,49 @@ describe('plugin-meetings', () => {
     });
   });
 
+  describe('MemberUtil.isBrb', () => {
+    it('returns true when brb is enabled', () => {
+      const participant = {
+        controls: {
+          brb: {
+            enabled: true,
+          },
+        },
+      };
+
+      assert.isTrue(MemberUtil.isBrb(participant));
+    });
+
+    it('returns false when brb is disabled', () => {
+      const participant = {
+        controls: {
+          brb: {
+            enabled: false,
+          },
+        },
+      };
+
+      assert.isFalse(MemberUtil.isBrb(participant));
+    });
+
+
+    it('returns false when brb is not present', () => {
+      const participant = {
+        controls: {},
+      };
+
+      assert.isFalse(MemberUtil.isBrb(participant));
+    });
+
+    it('returns false when controls is not present', () => {
+      const participant = {};
+
+      assert.isFalse(MemberUtil.isBrb(participant));
+    });
+  });
+
   describe('MemberUtil.isBreakoutsSupported', () => {
-    it('throws error when there is no participant', () => {
+    it('throws an error when there is no participant', () => {
       assert.throws(() => {
         MemberUtil.isBreakoutsSupported();
       }, 'Breakout support could not be processed, participant is undefined.');
@@ -377,7 +418,7 @@ describe('plugin-meetings', () => {
   });
 
   describe('MemberUtil.isLiveAnnotationSupported', () => {
-    it('throws error when there is no participant', () => {
+    it('throws an error when there is no participant', () => {
       assert.throws(() => {
         MemberUtil.isLiveAnnotationSupported();
       }, 'LiveAnnotation support could not be processed, participant is undefined.');
@@ -401,7 +442,7 @@ describe('plugin-meetings', () => {
   });
 
   describe('MemberUtil.isInterpretationSupported', () => {
-    it('throws error when there is no participant', () => {
+    it('throws an error when there is no participant', () => {
       assert.throws(() => {
         MemberUtil.isInterpretationSupported();
       }, 'Interpretation support could not be processed, participant is undefined.');
@@ -432,7 +473,7 @@ describe('plugin-meetings', () => {
   };
 
   describe('MemberUtil.isAudioMuted', () => {
-    it('throws error when there is no participant', () => {
+    it('throws an error when there is no participant', () => {
       assert.throws(() => {
         MemberUtil.isAudioMuted();
       }, 'Audio could not be processed, participant is undefined.');
@@ -475,7 +516,7 @@ describe('plugin-meetings', () => {
   });
 
   describe('MemberUtil.isVideoMuted', () => {
-    it('throws error when there is no participant', () => {
+    it('throws an error when there is no participant', () => {
       assert.throws(() => {
         MemberUtil.isVideoMuted();
       }, 'Video could not be processed, participant is undefined.');
@@ -519,7 +560,7 @@ describe('plugin-meetings', () => {
 });
 
 describe('extractMediaStatus', () => {
-  it('throws error when there is no participant', () => {
+  it('throws an error when there is no participant', () => {
     assert.throws(() => {
       MemberUtil.extractMediaStatus()
     }, 'Media status could not be extracted, participant is undefined.');
@@ -529,7 +570,7 @@ describe('extractMediaStatus', () => {
     const participant = {
       status: {}
     };
-    
+
     const mediaStatus = MemberUtil.extractMediaStatus(participant)
 
     assert.deepEqual(mediaStatus, {audio: undefined, video: undefined});
@@ -542,7 +583,7 @@ describe('extractMediaStatus', () => {
         videoStatus: 'SENDRECV'
       }
     };
-    
+
     const mediaStatus = MemberUtil.extractMediaStatus(participant)
 
     assert.deepEqual(mediaStatus, {audio: 'RECVONLY', video: 'SENDRECV'});

package/test/unit/spec/multistream/remoteMedia.ts

@@ -249,14 +249,18 @@ describe('RemoteMedia', () => {
 
     forEach(
       [
-        {height: 134, fs: 60},
-        {height: 135, fs: 240},
-        {height: 269, fs: 240},
-        {height: 270, fs: 920},
-        {height: 539, fs: 920},
-        {height: 540, fs: 3600},
+        {height: 90, fs: 60}, // 90p
+        {height: 98, fs: 60},
+        {height: 99, fs: 240}, // 180p
+        {height: 180, fs: 240},
+        {height: 197, fs: 240},
+        {height: 198, fs: 920}, // 360p
+        {height: 360, fs: 920},
+        {height: 395, fs: 920},
+        {height: 396, fs: 3600}, // 720p
         {height: 720, fs: 3600},
-        {height: 721, fs: 8192},
+        {height: 721, fs: 8192}, // 1080p
+        {height: 1080, fs: 8192},
       ],
       ({height, fs}) => {
         it(`sets the max fs to ${fs} correctly when height is ${height}`, () => {

package/test/unit/spec/roap/index.ts

@@ -251,6 +251,53 @@ describe('Roap', () => {
       );
     });
 
+    it('handles the case when there is some other (not an answer) roap message type in the http response', async () => {
+      const roapError = {
+        seq: 1,
+        messageType: 'ERROR',
+        sdps: [],
+        errorType: 'error type',
+        errorCause: 'error cause',
+        headers: ['header1', 'header2'],
+      };
+      const fakeMediaConnections = [
+        {
+          remoteSdp: JSON.stringify({
+            roapMessage: roapError,
+          }),
+        },
+      ];
+
+      sendRoapStub.resolves({
+        mediaConnections: fakeMediaConnections,
+        locus: fakeLocus,
+      });
+
+      const result = await roap.sendRoapMediaRequest({
+        meeting,
+        sdp: 'sdp',
+        reconnect: false,
+        seq: 1,
+        tieBreaker: 4294967294,
+      });
+
+      assert.calledOnce(sendRoapStub);
+      assert.calledOnceWithExactly(meeting.updateMediaConnections, fakeMediaConnections);
+      assert.deepEqual(result, {
+        locus: fakeLocus,
+        roapAnswer: undefined,
+      });
+      assert.calledOnceWithExactly(
+        Metrics.sendBehavioralMetric,
+        BEHAVIORAL_METRICS.ROAP_HTTP_RESPONSE_MISSING,
+        {
+          correlationId: meeting.correlationId,
+          messageType: 'ANSWER',
+          isMultistream: meeting.isMultistream,
+        }
+      );
+    });
+
     describe('does not crash when http response is missing things', () => {
       [
         {mediaConnections: undefined, title: 'mediaConnections are undefined'},