utils.js

import {assert} from '@webex/test-helper-chai';
import sinon from 'sinon';
import {CapabilityState, WebCapabilities} from '@webex/web-capabilities';

import Trigger from '@webex/plugin-meetings/src/common/events/trigger-proxy';
import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
import MeetingsUtil from '@webex/plugin-meetings/src/meetings/util';
import {EVENT_TRIGGERS} from '@webex/plugin-meetings/src/constants';
import Metrics from '@webex/plugin-meetings/src/metrics';
import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';

describe('plugin-meetings', () => {
  beforeEach(() => {
    sinon.stub(Metrics, 'sendBehavioralMetric');
  });
  afterEach(() => {
    sinon.restore();
  });
  describe('Meetings utils function', () => {
    describe('#parseDefaultSiteFromMeetingPreferences', () => {
      it('should return the default true site from user preferences', () => {
        const userPreferences = {
          sites: [
            {
              siteUrl: 'site1-example.webex.com',
              default: false,
            },
            {
              siteUrl: 'site2-example.webex.com',
              default: false,
            },
            {
              siteUrl: 'go.webex.com',
              default: true,
            },
            {
              siteUrl: 'site3-example.webex.com',
              default: false,
            },
          ],
        };

        assert.equal(
          MeetingsUtil.parseDefaultSiteFromMeetingPreferences(userPreferences),
          'go.webex.com'
        );
      });

      it('should take the first site if none are default', () => {
        const userPreferences = {
          sites: [
            {
              siteUrl: 'site1-example.webex.com',
              default: false,
            },
            {
              siteUrl: 'site2-example.webex.com',
              default: false,
            },
            {
              siteUrl: 'site3-example.webex.com',
              default: false,
            },
          ],
        };

        assert.equal(
          MeetingsUtil.parseDefaultSiteFromMeetingPreferences(userPreferences),
          'site1-example.webex.com'
        );
      });

      it('should work fine if sites an empty array', () => {
        const userPreferences = {
          sites: [],
        };

        assert.equal(MeetingsUtil.parseDefaultSiteFromMeetingPreferences(userPreferences), '');
      });
    });

    describe('#getThisDevice', () => {
      it('return null if no devices in self', () => {
        const newLocus = {};
        assert.equal(MeetingsUtil.getThisDevice(newLocus, '123'), null);
      });
      it('return null if no matched device in self', () => {
        const newLocus = {
          self: {
            devices: [{state: 'JOINED', url: '456'}]
          }
        };
        assert.equal(MeetingsUtil.getThisDevice(newLocus, '123'), null);
      });
      it('return the device match with current device', () => {
        const newLocus = {
          self: {
            devices: [{state: 'JOINED', url: '123'}]
          }
        };
        assert.deepEqual(MeetingsUtil.getThisDevice(newLocus, '123'), {state: 'JOINED', url: '123'});
      })
    });

    describe('#isBreakoutLocusDTO', () => {
      it('returns false is no breakout in locus.controls', () => {
        const newLocus = {
          controls: {}
        };

        assert.equal(MeetingsUtil.isBreakoutLocusDTO(newLocus), false);
      });

      it('returns is breakout locus DTO if sessionType is BREAKOUT', () => {
        const newLocus = {
          controls: {
            breakout: {
              sessionType: 'BREAKOUT',
            },
          },
        };
        assert.equal(MeetingsUtil.isBreakoutLocusDTO(newLocus), true);
      });

      it('returns is not breakout locus DTO if sessionType is MAIN', () => {
        const newLocus = {
          controls: {
            breakout: {
              sessionType: 'MAIN',
            },
          },
        };
        assert.equal(MeetingsUtil.isBreakoutLocusDTO(newLocus), false);
      });
    });

    describe('#joinedOnThisDevice', () => {
      it('return false if no devices in self', () => {
        const newLocus = {};
        assert.equal(MeetingsUtil.joinedOnThisDevice(null, newLocus, '123'), false);
      });
      it('return true if joined on this device', () => {
        const newLocus = {
          self: {
            devices: [{state: 'JOINED', correlationId: '111', url: '123'}]
          }
        };
        const meeting = {
          correlationId: '111'
        };

        assert.equal(MeetingsUtil.joinedOnThisDevice(meeting, newLocus, '123'), true);
      });
      it('return true if selfMoved on this device', () => {
        const newLocus = {
          self: {
            devices: [{state: 'LEFT', reason: 'MOVED', correlationId: '111', url: '123'}]
          }
        };
        const meeting = {
          correlationId: '111'
        };

        assert.equal(MeetingsUtil.joinedOnThisDevice(meeting, newLocus, '123'), true);
      });
    });

    describe("#handleRoapMercury", () => {
      let envelope;
      let meetingCollection;
      let roapMessageReceived;
      let handleTurnDiscoveryResponse;
      let meeting;

      beforeEach(() => {
        roapMessageReceived = sinon.stub();
        handleTurnDiscoveryResponse = sinon.stub();

        meeting = {
          id: 'meeting-id',
          roapMessageReceived,
          roap: {
            turnDiscovery: {handleTurnDiscoveryResponse}
          }
        };
        envelope = {
          data: {
            message:{
              seq: "seq",
              messageType: 'messageType',
              tieBreaker: 'tieBreaker',
              errorType: 'errorType',
              errorCause: 'errorCause',
              sdps: [{id:'sdp-1'}]
            },
            correlationId: 'correlationId',
            eventType: 'locus.message.roap',
          }
        };
        meetingCollection = {
          getByKey: () => meeting
        };
      });

      it('it sends the correct behaviour metric', () => {
        MeetingsUtil.handleRoapMercury(envelope, meetingCollection);
        assert.calledWith(Metrics.sendBehavioralMetric, BEHAVIORAL_METRICS.ROAP_MERCURY_EVENT_RECEIVED,  {
          correlation_id: 'correlationId',
          seq: "seq",
          message_type: 'messageType',
          error_type: 'errorType',
          error_cause: 'errorCause',
        })
        assert.calledWith(roapMessageReceived, {
          seq: "seq",
          messageType: 'messageType',
          errorType: 'errorType',
          tieBreaker: 'tieBreaker',
          errorCause: 'errorCause',
          sdp: {id:'sdp-1'}
        })

      });

      it('calls handleTurnDiscoveryResponse for TURN_DISCOVERY_RESPONSE', () => {
        envelope.data.message.messageType = 'TURN_DISCOVERY_RESPONSE';
        delete envelope.data.message.sdps;
        MeetingsUtil.handleRoapMercury(envelope, meetingCollection);
        assert.calledWith(meeting.roap.turnDiscovery.handleTurnDiscoveryResponse, {
          seq: "seq",
          messageType: 'TURN_DISCOVERY_RESPONSE',
          errorType: 'errorType',
          tieBreaker: 'tieBreaker',
          errorCause: 'errorCause',
        }, 'from mercury')
      });
    })
  });

  describe('#isValidBreakoutLocus', () => {
    it('returns false if is not breakout locus', () => {
      const newLocus = {
        controls: {}
      };

      assert.equal(MeetingsUtil.isValidBreakoutLocus(newLocus), false);
    });

    it('returns false if fullState is inactive', () => {
      const newLocus = {
        controls: {
          breakout: {
            sessionType: 'BREAKOUT',
          },
        },
        fullState: {
          state: 'INACTIVE'
        }
      };
      assert.equal(MeetingsUtil.isValidBreakoutLocus(newLocus), false);
    });

    it('returns false if self is not joined', () => {
      const newLocus = {
        controls: {
          breakout: {
            sessionType: 'BREAKOUT',
          },
        },
        fullState: {
          state: 'ACTIVE'
        },
        self: {
          state: 'LEFT'
        }
      };
      assert.equal(MeetingsUtil.isValidBreakoutLocus(newLocus), false);
    });

    it('returns true if self is JOINED and fullState is active', () => {
      const newLocus = {
        controls: {
          breakout: {
            sessionType: 'BREAKOUT',
          },
        },
        fullState: {
          state: 'ACTIVE'
        },
        self: {
          state: 'JOINED'
        }
      };
      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');
    });
  });

  describe('#getCorrelationIdForDevice', () => {
    it('should return correlationId if device with matching url is found', () => {
      const locusSelf = {
        devices: [
          {url: 'deviceUrl1', correlationId: 'correlationId1'},
          {url: 'deviceUrl2', correlationId: 'correlationId2'},
        ],
      };

      const correlationId = MeetingsUtil.getCorrelationIdForDevice('deviceUrl1', locusSelf);
      assert.equal(correlationId, 'correlationId1');
    });

    it('should return false if no device with matching url is found', () => {
      const locusSelf = {
        devices: [
          {url: 'deviceUrl1', correlationId: 'correlationId1'},
          {url: 'deviceUrl2', correlationId: 'correlationId2'},
        ],
      };

      const correlationId = MeetingsUtil.getCorrelationIdForDevice('deviceUrl3', locusSelf);
      assert.equal(correlationId, false);
    });

    it('should return false if device with matching url has no correlationId', () => {
      const locusSelf = {
        devices: [{url: 'deviceUrl1'}, {url: 'deviceUrl2', correlationId: 'correlationId2'}],
      };

      const correlationId = MeetingsUtil.getCorrelationIdForDevice('deviceUrl1', locusSelf);
      assert.equal(correlationId, false);
    });

    it('should return false if locusSelf has no devices', () => {
      const locusSelf = {};

      const correlationId = MeetingsUtil.getCorrelationIdForDevice('deviceUrl1', locusSelf);
      assert.equal(correlationId, false);
    });

    it('should return false if locusSelf is null or undefined', () => {
      let correlationId = MeetingsUtil.getCorrelationIdForDevice('deviceUrl1', null);
      assert.equal(correlationId, false);

      correlationId = MeetingsUtil.getCorrelationIdForDevice('deviceUrl1', undefined);
      assert.equal(correlationId, false);
    });
  });

  describe('#checkH264Support', () => {
    let isCapableOfReceivingVideoCodecStub;
    let triggerStub;
    let loggerErrorStub;
    let loggerLogStub;

    beforeEach(() => {
      isCapableOfReceivingVideoCodecStub = sinon.stub(
        WebCapabilities,
        'isCapableOfReceivingVideoCodec'
      );
      triggerStub = sinon.stub(Trigger, 'trigger');
      loggerErrorStub = sinon.stub(LoggerProxy.logger, 'error');
      loggerLogStub = sinon.stub(LoggerProxy.logger, 'log');
    });

    it('returns immediately without codec check when disableNotifications is true', async () => {
      await MeetingsUtil.checkH264Support.call({}, {disableNotifications: true});

      assert.notCalled(isCapableOfReceivingVideoCodecStub);
      assert.notCalled(triggerStub);
    });

    it('triggers MEDIA_CODEC_LOADED when H.264 is capable', async () => {
      isCapableOfReceivingVideoCodecStub.returns(CapabilityState.CAPABLE);

      await MeetingsUtil.checkH264Support.call({});

      assert.calledWith(isCapableOfReceivingVideoCodecStub, 'video/H264');
      assert.calledWith(
        triggerStub,
        {},
        {file: 'meetings/util', function: 'checkH264Support'},
        EVENT_TRIGGERS.MEDIA_CODEC_LOADED
      );
    });

    it('triggers MEDIA_CODEC_MISSING and schedules retry when H.264 is not capable', async () => {
      const clock = sinon.useFakeTimers();
      isCapableOfReceivingVideoCodecStub.returns(CapabilityState.NOT_CAPABLE);

      await MeetingsUtil.checkH264Support.call({});

      assert.calledWith(
        triggerStub,
        {},
        {file: 'meetings/util', function: 'checkH264Support'},
        EVENT_TRIGGERS.MEDIA_CODEC_MISSING
      );
      triggerStub.resetHistory();
      isCapableOfReceivingVideoCodecStub.resetHistory();

      await clock.tick(5000);

      assert.called(isCapableOfReceivingVideoCodecStub);
      clock.restore();
    });

    it('logs error and stops retrying when past maxDuration', async () => {
      const clock = sinon.useFakeTimers();
      isCapableOfReceivingVideoCodecStub.returns(CapabilityState.NOT_CAPABLE);

      const firstCheckTime = 1;
      await clock.tick(firstCheckTime);
      await MeetingsUtil.checkH264Support.call({}, {firstChecked: firstCheckTime});
      await clock.tick(300000);

      assert.calledWith(
        loggerErrorStub,
        'Meetings:util#checkH264Support --> Timed out waiting for H264 codec to load.'
      );
      clock.restore();
    });

    it('does not re-trigger MEDIA_CODEC_MISSING on retries when codec remains not capable', async () => {
      const clock = sinon.useFakeTimers();
      isCapableOfReceivingVideoCodecStub.returns(CapabilityState.NOT_CAPABLE);

      await MeetingsUtil.checkH264Support.call({});
      const missingTriggerCount = triggerStub.getCalls().filter(
        (call) => call.args[2] === EVENT_TRIGGERS.MEDIA_CODEC_MISSING
      ).length;
      assert.equal(missingTriggerCount, 1, 'MEDIA_CODEC_MISSING should be triggered only once');

      triggerStub.resetHistory();
      await clock.tick(5000);

      const missingTriggerCountAfterRetry = triggerStub.getCalls().filter(
        (call) => call.args[2] === EVENT_TRIGGERS.MEDIA_CODEC_MISSING
      ).length;
      assert.equal(
        missingTriggerCountAfterRetry,
        0,
        'MEDIA_CODEC_MISSING should not be re-triggered on retry'
      );
      clock.restore();
    });

    it('triggers MEDIA_CODEC_LOADED when codec becomes available on retry', async () => {
      const clock = sinon.useFakeTimers();
      isCapableOfReceivingVideoCodecStub
        .onFirstCall()
        .returns(CapabilityState.NOT_CAPABLE)
        .onSecondCall()
        .returns(CapabilityState.CAPABLE);

      await MeetingsUtil.checkH264Support.call({});
      assert.calledWith(
        triggerStub,
        {},
        {file: 'meetings/util', function: 'checkH264Support'},
        EVENT_TRIGGERS.MEDIA_CODEC_MISSING
      );

      triggerStub.resetHistory();
      await clock.tick(5000);

      assert.calledWith(
        triggerStub,
        {},
        {file: 'meetings/util', function: 'checkH264Support'},
        EVENT_TRIGGERS.MEDIA_CODEC_LOADED
      );
      clock.restore();
    });

    it('logs loaded message when H.264 codec is capable', async () => {
      isCapableOfReceivingVideoCodecStub.returns(CapabilityState.CAPABLE);

      await MeetingsUtil.checkH264Support.call({});

      assert.calledWith(
        loggerLogStub,
        'Meetings:util#checkH264Support --> H264 codec loaded successfully.'
      );
    });

    it('logs missing message when H.264 codec is not capable on first check', async () => {
      const clock = sinon.useFakeTimers();
      isCapableOfReceivingVideoCodecStub.returns(CapabilityState.NOT_CAPABLE);

      await MeetingsUtil.checkH264Support.call({});

      assert.calledWith(
        loggerLogStub,
        'Meetings:util#checkH264Support --> H264 codec is missing.'
      );
      clock.restore();
    });
  });
});