@100mslive/hms-video-store 0.2.82 → 0.2.83

package/src/test/fakeStore.ts

@@ -1,272 +0,0 @@
-import {
-  HMSMessageType,
-  HMSPeer,
-  HMSRoomState,
-  HMSSpeaker,
-  HMSStore,
-  HMSTrack,
-  HMSTrackID,
-  HMSTrackSource,
-  HMSTrackType,
-} from '../core';
-import { HMSSimulcastLayer } from '../core/hmsSDKStore/sdkTypes';
-import { HMSPlaylist, HMSPlaylistType, HMSRole } from '../core/schema';
-
-function makeTrack(
-  id: HMSTrackID,
-  type: HMSTrackType,
-  source: HMSTrackSource,
-  peerId: string,
-  enabled?: boolean,
-): HMSTrack {
-  return {
-    id: id,
-    source: source,
-    type: type,
-    enabled: !!enabled,
-    displayEnabled: true,
-    volume: type === 'audio' ? 10 : undefined,
-    layer: type === 'video' ? HMSSimulcastLayer.HIGH : undefined,
-    peerId: peerId,
-  };
-}
-
-export let localPeer: HMSPeer;
-export let remotePeerOne: HMSPeer;
-export let remotePeerTwo: HMSPeer;
-export let peerScreenSharing: HMSPeer;
-export let localVideo: HMSTrack;
-export let localAudio: HMSTrack;
-export let remoteVideo: HMSTrack;
-export let screenShare: HMSTrack;
-export let auxiliaryAudio: HMSTrack;
-export let localSpeaker: HMSSpeaker;
-export let screenshareAudio: HMSTrack;
-export let hostRole: HMSRole;
-export let speakerRole: HMSRole;
-export let playlist: HMSPlaylist<any>;
-
-export const ROLES = {
-  HOST: 'host', // allowed to turn any of video, audio and screen on. can make a viewer speaker
-  SPEAKER: 'speaker', // allowed to turn on audio and speak
-  VIEWER: 'viewer', // allowed to watch and listen to other people, can't publish, can be converted to speaker
-  NOSUBSCRIBE: 'nosubscribe', // allowed to publish but not subscribe to anything
-};
-
-export const makeFakeStore = (): HMSStore => {
-  const fakeStore: HMSStore = {
-    room: {
-      id: '123',
-      isConnected: true,
-      name: 'test room',
-      peers: ['1', '2', '3'],
-      localPeer: '1',
-      shareableLink: '',
-      hasWaitingRoom: false,
-      roomState: HMSRoomState.Disconnected,
-      recording: {
-        browser: {
-          running: false,
-        },
-        server: {
-          running: false,
-        },
-      },
-      rtmp: {
-        running: false,
-      },
-    },
-    peers: {
-      '1': {
-        id: '1',
-        name: 'test1',
-        roleName: ROLES.HOST,
-        isLocal: true,
-        videoTrack: '101',
-        audioTrack: '102',
-        auxiliaryTracks: [],
-        metadata: '{}',
-      },
-      '2': {
-        id: '2',
-        name: 'test2',
-        roleName: ROLES.HOST,
-        isLocal: false,
-        videoTrack: '103',
-        audioTrack: '104',
-        auxiliaryTracks: ['105', '106', '107'],
-        metadata: '{"hello":"world"}',
-      },
-      '3': {
-        id: '3',
-        name: 'test3',
-        roleName: ROLES.SPEAKER,
-        isLocal: false,
-        videoTrack: '105',
-        audioTrack: '106',
-        auxiliaryTracks: [],
-      },
-    },
-    tracks: {
-      '101': makeTrack('101', 'video', 'regular', '1'),
-      '102': makeTrack('102', 'audio', 'regular', '1'),
-      '103': makeTrack('103', 'video', 'regular', '2'),
-      '104': makeTrack('104', 'audio', 'regular', '2'),
-      '105': makeTrack('105', 'video', 'screen', '2'),
-      '106': makeTrack('106', 'audio', 'regular', '2'),
-      '107': makeTrack('107', 'audio', 'screen', '2'),
-    },
-    playlist: {
-      audio: {
-        list: {
-          audio1: {
-            url: 'https://test.com/link1',
-            type: HMSPlaylistType.audio,
-            name: 'audio1',
-            id: 'audio1',
-            playing: true,
-            selected: true,
-          },
-          audio2: {
-            url: 'https://test.com/link2',
-            type: HMSPlaylistType.audio,
-            name: 'audio2',
-            id: 'audio2',
-            playing: false,
-            selected: false,
-          },
-        },
-        selection: { id: 'audio1', hasNext: true, hasPrevious: false },
-        progress: 20,
-        volume: 100,
-        currentTime: 10,
-        playbackRate: 0.5,
-      },
-      video: {
-        list: {
-          video1: {
-            url: 'https://test.com/link1',
-            type: HMSPlaylistType.audio,
-            name: 'Video1',
-            id: 'video1',
-            playing: true,
-            selected: true,
-          },
-          video2: {
-            url: 'https://test.com/link2',
-            type: HMSPlaylistType.audio,
-            name: 'Video2',
-            id: 'video2',
-            playing: false,
-            selected: false,
-          },
-        },
-        selection: { id: 'video1', hasNext: true, hasPrevious: false },
-        progress: 30,
-        volume: 100,
-        currentTime: 20,
-        playbackRate: 1.0,
-      },
-    },
-    messages: {
-      byID: {
-        '201': {
-          id: '201',
-          sender: '1',
-          senderName: 'test1',
-          senderRole: ROLES.HOST,
-          read: true,
-          type: HMSMessageType.CHAT,
-          message: 'hello!',
-          time: new Date(),
-        },
-        '202': {
-          id: '202',
-          sender: '2',
-          senderName: 'test2',
-          senderRole: ROLES.HOST,
-          recipientPeer: '1',
-          read: false,
-          type: HMSMessageType.CHAT,
-          message: 'hi!',
-          time: new Date(),
-        },
-        '203': {
-          id: '203',
-          sender: '2',
-          senderName: 'test2',
-          senderRole: ROLES.HOST,
-          recipientRoles: [ROLES.HOST],
-          read: true,
-          type: HMSMessageType.CHAT,
-          message: 'hi!',
-          time: new Date(),
-        },
-      },
-      allIDs: ['201', '202', '203'],
-    },
-    speakers: {
-      '102': {
-        audioLevel: 75,
-        peerID: '1',
-        trackID: '102',
-      },
-    },
-    settings: {
-      audioInputDeviceId: 'testAudioIn',
-      audioOutputDeviceId: 'testAudioOut',
-      videoInputDeviceId: 'testVideoIn',
-    },
-    roleChangeRequests: [
-      {
-        requestedBy: '2',
-        roleName: 'speaker',
-        token: '123',
-      },
-    ],
-    roles: {
-      host: {
-        name: ROLES.HOST,
-        publishParams: { allowed: ['audio', 'video', 'screen'] },
-        subscribeParams: { subscribeToRoles: [ROLES.HOST, ROLES.SPEAKER] },
-        permissions: { changeRole: true, unmute: true },
-      } as HMSRole,
-      viewer: {
-        name: ROLES.VIEWER,
-        publishParams: {},
-        subscribeParams: { subscribeToRoles: [ROLES.HOST, ROLES.SPEAKER] },
-      } as HMSRole,
-      speaker: {
-        name: ROLES.SPEAKER,
-        publishParams: { allowed: ['audio'] },
-        subscribeParams: { subscribeToRoles: [ROLES.HOST, ROLES.SPEAKER] },
-      } as HMSRole,
-      nosubscribe: {
-        name: ROLES.NOSUBSCRIBE,
-        subscribeParams: {},
-      } as HMSRole,
-    },
-    devices: {
-      audioInput: [],
-      audioOutput: [],
-      videoInput: [],
-    },
-    errors: [],
-  };
-
-  localPeer = fakeStore.peers['1'];
-  remotePeerOne = fakeStore.peers['2'];
-  remotePeerTwo = fakeStore.peers['3'];
-  peerScreenSharing = fakeStore.peers['2'];
-  localVideo = fakeStore.tracks['101'];
-  localAudio = fakeStore.tracks['102'];
-  remoteVideo = fakeStore.tracks['103'];
-  screenShare = fakeStore.tracks['105'];
-  auxiliaryAudio = fakeStore.tracks['106'];
-  screenshareAudio = fakeStore.tracks['107'];
-  localSpeaker = fakeStore.speakers[localPeer.audioTrack!];
-  hostRole = fakeStore.roles['host'];
-  speakerRole = fakeStore.roles['speaker'];
-  playlist = fakeStore.playlist;
-  return fakeStore;
-};

package/src/test/fixtures.ts

@@ -1,22 +0,0 @@
-import { HMSPeer, HMSTrack, HMSTrackType } from '../core';
-
-let counter = 100;
-
-export const makeFakeTrack = (type?: HMSTrackType): HMSTrack => {
-  return {
-    enabled: false,
-    id: String(counter++),
-    type: type || 'video',
-  };
-};
-
-export const makeFakePeer = (): HMSPeer => {
-  return {
-    audioTrack: '',
-    auxiliaryTracks: [],
-    id: String(counter++),
-    isLocal: false,
-    name: 'test',
-    videoTrack: '',
-  };
-};

package/src/test/unit/HMSNotifications.test.ts

@@ -1,123 +0,0 @@
-import {
-  HMSNotificationSeverity,
-  HMSPeer,
-  HMSReactiveStore,
-  HMSStore,
-  HMSTrack,
-  HMSException,
-} from '../../core';
-import {
-  PEER_NOTIFICATION_TYPES,
-  TRACK_NOTIFICATION_TYPES,
-} from '../../core/hmsSDKStore/common/mapping';
-import { HMSNotifications } from '../../core/hmsSDKStore/HMSNotifications';
-import * as sdkTypes from '../../core/hmsSDKStore/sdkTypes';
-import { makeFakeStore } from '../fakeStore';
-import { makeFakePeer, makeFakeTrack } from '../fixtures';
-
-let notifications: HMSNotifications;
-let peer: HMSPeer;
-let track: HMSTrack;
-let fakeStore: HMSStore;
-let cb: jest.Mock;
-let unsub: () => void;
-beforeEach(() => {
-  const store = HMSReactiveStore.createNewHMSStore();
-  notifications = new HMSNotifications(store);
-  cb = jest.fn(val => val);
-  unsub = notifications.onNotification(cb);
-  peer = makeFakePeer();
-  track = makeFakeTrack();
-  fakeStore = makeFakeStore();
-});
-
-function makeException(name: string): HMSException {
-  return {
-    name: name,
-  } as HMSException;
-}
-
-describe('hms notifications tests', () => {
-  test('when unhandled peer event on Notification not to be called', () => {
-    notifications.sendPeerUpdate(sdkTypes.HMSPeerUpdate.BECAME_DOMINANT_SPEAKER, peer);
-    expect(cb.mock.calls.length).toBe(0);
-  });
-
-  test('when peer joined on Notification to be called', () => {
-    notifications.sendPeerUpdate(sdkTypes.HMSPeerUpdate.PEER_JOINED, peer);
-    expect(cb.mock.calls.length).toBe(1);
-    expect(cb.mock.results[0].value.type).toBe(
-      PEER_NOTIFICATION_TYPES[sdkTypes.HMSPeerUpdate.PEER_JOINED],
-    );
-    expect(cb.mock.results[0].value.data).toBe(peer);
-    expect(cb.mock.results[0].value.severity).toBe(HMSNotificationSeverity.INFO);
-  });
-
-  test('when peer left on Notification to be called', () => {
-    notifications.sendPeerUpdate(sdkTypes.HMSPeerUpdate.PEER_LEFT, peer);
-    expect(cb.mock.calls.length).toBe(1);
-    expect(cb.mock.results[0].value.type).toBe(
-      PEER_NOTIFICATION_TYPES[sdkTypes.HMSPeerUpdate.PEER_LEFT],
-    );
-    expect(cb.mock.results[0].value.data).toBe(peer);
-    expect(cb.mock.results[0].value.severity).toBe(HMSNotificationSeverity.INFO);
-  });
-
-  test('when unhandled track event on Notification not to be called', () => {
-    notifications.sendTrackUpdate(sdkTypes.HMSTrackUpdate.TRACK_DESCRIPTION_CHANGED, track.id);
-    expect(cb.mock.calls.length).toBe(0);
-  });
-
-  test('when track added on Notification to be called', () => {
-    notifications.sendTrackUpdate(sdkTypes.HMSTrackUpdate.TRACK_ADDED, track.id);
-    expect(cb.mock.calls.length).toBe(1);
-    expect(cb.mock.results[0].value.type).toBe(
-      TRACK_NOTIFICATION_TYPES[sdkTypes.HMSTrackUpdate.TRACK_ADDED],
-    );
-    expect(cb.mock.results[0].value.severity).toBe(HMSNotificationSeverity.INFO);
-  });
-
-  test('when track removed on Notification to be called', () => {
-    notifications.sendTrackUpdate(sdkTypes.HMSTrackUpdate.TRACK_REMOVED, track.id);
-    expect(cb.mock.calls.length).toBe(1);
-    expect(cb.mock.results[0].value.type).toBe(
-      TRACK_NOTIFICATION_TYPES[sdkTypes.HMSTrackUpdate.TRACK_REMOVED],
-    );
-    expect(cb.mock.results[0].value.severity).toBe(HMSNotificationSeverity.INFO);
-  });
-
-  test('when new message received on Notification to be called', () => {
-    const message = fakeStore.messages.byID['201'];
-    notifications.sendMessageReceived(message);
-    expect(cb.mock.calls.length).toBe(1);
-    expect(cb.mock.results[0].value.data).toBe(message);
-    expect(cb.mock.results[0].value.severity).toBe(HMSNotificationSeverity.INFO);
-  });
-
-  test('when error received on Notification to be called', () => {
-    const error = makeException('Test');
-    notifications.sendError(error);
-    expect(cb.mock.calls.length).toBe(1);
-    expect(cb.mock.results[0].value.data).toBe(error);
-    expect(cb.mock.results[0].value.severity).toBe(HMSNotificationSeverity.ERROR);
-  });
-
-  test('when reconnected received on Notification to be called', () => {
-    notifications.sendReconnected();
-    expect(cb.mock.calls.length).toBe(1);
-  });
-
-  test('when reconnecting received on Notification to be called', () => {
-    const error = makeException('Test');
-    notifications.sendReconnecting(error);
-    expect(cb.mock.calls.length).toBe(1);
-    expect(cb.mock.results[0].value.data).toBe(error);
-    expect(cb.mock.results[0].value.severity).toBe(HMSNotificationSeverity.ERROR);
-  });
-
-  test('when unsubscribed on Notification not to be called', () => {
-    unsub();
-    notifications.sendReconnected();
-    expect(cb.mock.calls.length).toBe(0);
-  });
-});

package/src/test/unit/reactiveStore.test.ts

@@ -1,129 +0,0 @@
-import { HMSReactiveStore, HMSStore, IHMSStore, selectLocalPeer, selectPeers } from '../../core';
-import { localPeer, makeFakeStore } from '../fakeStore';
-
-let store: IHMSStore;
-let fakeData: HMSStore;
-let cb: jest.Mock;
-let initialState: HMSStore;
-
-beforeEach(() => {
-  store = HMSReactiveStore.createNewHMSStore();
-  cb = jest.fn(val => val);
-  fakeData = makeFakeStore();
-  store.setState(store => {
-    Object.assign(store, fakeData);
-  });
-  initialState = store.getState();
-});
-
-const expectCalls = (n: number) => {
-  expect(cb.mock.calls.length).toBe(n);
-};
-const expectOneCall = () => {
-  expectCalls(1);
-};
-const expectTwoCalls = () => {
-  expectCalls(2);
-};
-
-const expectCallArgs = <T>(arg1: T, arg2?: T) => {
-  expect(cb.mock.calls[0][0]).toBe(arg1);
-  expect(cb.mock.calls[0][1]).toBe(arg2);
-};
-const expectCallArgs2 = <T>(arg1: T, arg2?: T) => {
-  expect(cb.mock.calls[1][0]).toBe(arg1);
-  expect(cb.mock.calls[1][1]).toBe(arg2);
-};
-
-const doUnrelatedChange = () => {
-  store.setState(draft => {
-    draft.room.isConnected = !draft.room.isConnected;
-  });
-};
-
-describe('test reactive store', () => {
-  const expectStoreChanged = () => {
-    expect(store.getState()).not.toBe(initialState);
-  };
-
-  const expectNoCalls = () => {
-    expectCalls(0);
-  };
-
-  test('getState works', () => {
-    expect(store.getState()).toEqual(fakeData);
-  });
-
-  it('sends both old and new to subscriber', () => {
-    store.subscribe(cb, selectLocalPeer);
-    const oldPeer = store.getState(selectLocalPeer);
-    store.setState(draft => {
-      draft.peers[localPeer.id].name = 'test2';
-    });
-    const newPeer = store.getState(selectLocalPeer);
-    expect(newPeer).not.toBe(oldPeer);
-    expectStoreChanged();
-    expectOneCall();
-    expectCallArgs(newPeer, oldPeer);
-  });
-
-  it('does not notify on no changes or unrelated changes', () => {
-    store.subscribe(cb, selectLocalPeer);
-    const oldPeer = store.getState(selectLocalPeer);
-    store.setState(draft => {
-      draft.peers[localPeer.id].name = oldPeer.name;
-    });
-    doUnrelatedChange();
-    expectStoreChanged();
-    const newPeer = store.getState(selectLocalPeer);
-    expect(newPeer).toBe(oldPeer);
-    expectNoCalls();
-  });
-
-  it('does not notify on unrelated changes for derived selectors', () => {
-    store.subscribe(cb, selectPeers);
-    doUnrelatedChange();
-    expectStoreChanged();
-    expectNoCalls();
-  });
-
-  it('triggers on listening to whole state without selector', () => {
-    store.subscribe(cb);
-    doUnrelatedChange();
-    expectStoreChanged();
-    expectOneCall();
-  });
-});
-
-describe('store with trigger on subscribe', () => {
-  beforeEach(() => {
-    HMSReactiveStore.makeStoreTriggerOnSubscribe(store);
-  });
-
-  it('triggers on subscribe', () => {
-    store.subscribe(cb, selectLocalPeer);
-    const peer = store.getState(selectLocalPeer);
-    expectOneCall();
-    expectCallArgs(peer);
-  });
-
-  it('does not trigger again on unrelated change', () => {
-    store.subscribe(cb, selectLocalPeer);
-    const peer = store.getState(selectLocalPeer);
-    doUnrelatedChange();
-    expectOneCall();
-    expectCallArgs(peer);
-  });
-
-  it('triggers on subscribe and a change', () => {
-    store.subscribe(cb, selectLocalPeer);
-    const oldPeer = store.getState(selectLocalPeer);
-    store.setState(draft => {
-      draft.peers[localPeer.id].name = 'test2';
-    });
-    const newPeer = store.getState(selectLocalPeer);
-    expectTwoCalls();
-    expectCallArgs(oldPeer);
-    expectCallArgs2(newPeer, oldPeer);
-  });
-});

package/src/test/unit/roleSelectors.test.ts

@@ -1,85 +0,0 @@
-import {
-  HMSStore,
-  selectAvailableRoleNames,
-  selectRolesMap,
-  selectLocalPeerRole,
-  selectRoleByRoleName,
-  selectRoleChangeRequest,
-  selectIsAllowedToPublish,
-  selectIsAllowedToSubscribe,
-} from '../../core';
-import {
-  hostRole,
-  localPeer,
-  makeFakeStore,
-  remotePeerOne,
-  ROLES,
-  speakerRole,
-} from '../fakeStore';
-
-let fakeStore: HMSStore;
-
-// start from a new fake store for every test
-beforeEach(() => {
-  fakeStore = makeFakeStore();
-});
-
-describe('test role related selectors', () => {
-  test('select roles', () => {
-    const storeRoles = selectRolesMap(fakeStore);
-    expect(storeRoles.host).not.toBeUndefined();
-    expect(storeRoles.speaker).not.toBeUndefined();
-    expect(storeRoles.viewer).not.toBeUndefined();
-    expect(storeRoles.student).toBeUndefined();
-
-    const roleNames = selectAvailableRoleNames(fakeStore);
-    expect(roleNames).toContain(ROLES.SPEAKER);
-    expect(roleNames).toContain(ROLES.HOST);
-    expect(roleNames).toContain(ROLES.VIEWER);
-    expect(roleNames).not.toContain('student');
-  });
-
-  test('select local peer role', () => {
-    expect(selectLocalPeerRole(fakeStore)).toBe(hostRole);
-  });
-
-  test('selectRole change request', () => {
-    const req = selectRoleChangeRequest(fakeStore);
-    expect(req?.requestedBy).toBe(remotePeerOne);
-    expect(req?.role.name).toBe(ROLES.SPEAKER);
-    expect(req?.role).toBe(speakerRole);
-    expect(req?.token).toBe('123');
-  });
-
-  test('select role by name', () => {
-    const storeHost = selectRoleByRoleName(ROLES.HOST)(fakeStore);
-    expect(storeHost).not.toBeUndefined();
-    expect(storeHost).toBe(hostRole);
-  });
-
-  test('publish params', () => {
-    localPeer.roleName = ROLES.SPEAKER;
-    const allowed = selectIsAllowedToPublish(fakeStore);
-    expect(allowed.audio).toBe(true);
-    expect(allowed.video).toBe(false);
-    expect(allowed.screen).toBe(false);
-  });
-
-  test('publish params viewer', () => {
-    localPeer.roleName = ROLES.VIEWER;
-    const allowed = selectIsAllowedToPublish(fakeStore);
-    expect(allowed.audio).toBe(false);
-    expect(allowed.video).toBe(false);
-    expect(allowed.screen).toBe(false);
-  });
-
-  test('is subscription allowed true', () => {
-    localPeer.roleName = ROLES.SPEAKER;
-    expect(selectIsAllowedToSubscribe(fakeStore)).toBe(true);
-  });
-
-  test('is subscription allowed false', () => {
-    localPeer.roleName = ROLES.NOSUBSCRIBE;
-    expect(selectIsAllowedToSubscribe(fakeStore)).toBe(false);
-  });
-});