@100mslive/hms-video-store 0.2.82-alpha.1 → 0.2.82-alpha.13

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

@@ -1,105 +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,78 +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);
-  });
-});

package/src/test/unit/selectors.test.ts

@@ -1,316 +0,0 @@
-import {
-  auxiliaryAudio,
-  hostRole,
-  localAudio,
-  localPeer,
-  localSpeaker,
-  localVideo,
-  makeFakeStore,
-  peerScreenSharing,
-  remoteVideo,
-  screenShare,
-  screenshareAudio,
-  playlist,
-  remotePeerTwo,
-  remotePeerOne,
-} from '../fakeStore';
-import {
-  HMSStore,
-  selectCameraStreamByPeerID,
-  selectDominantSpeaker,
-  selectHMSMessages,
-  selectHMSMessagesCount,
-  selectIsConnectedToRoom,
-  selectIsLocalAudioEnabled,
-  selectIsLocalScreenShared,
-  selectIsLocalVideoDisplayEnabled,
-  selectIsLocalVideoEnabled,
-  selectIsPeerAudioEnabled,
-  selectIsPeerVideoEnabled,
-  selectIsSomeoneScreenSharing,
-  selectLocalAudioTrackID,
-  selectLocalMediaSettings,
-  selectLocalPeer,
-  selectLocalPeerID,
-  selectLocalVideoTrackID,
-  selectPeerAudioByID,
-  selectPeerByID,
-  selectPeerScreenSharing,
-  selectPeersScreenSharing,
-  selectPeersWithAudioStatus,
-  selectRemotePeers,
-  selectRoom,
-  selectAuxiliaryAudioByPeerID,
-  selectScreenShareByPeerID,
-  selectSpeakers,
-  selectUnreadHMSMessagesCount,
-  selectScreenShareAudioByPeerID,
-  selectAudioVolumeByPeerID,
-  selectAudioTrackVolume,
-  selectIsLocallyMutedByPeerID,
-  selectIsAudioLocallyMuted,
-  selectVideoTrackByPeerID,
-  selectAudioTrackByPeerID,
-  selectTrackAudioByID,
-  selectSimulcastLayerByTrack,
-  selectDegradedTracks,
-  selectPermissions,
-  selectRoomState,
-  HMSRoomState,
-  selectIsInPreview,
-  selectRoomStarted,
-  selectMessagesByPeerID,
-  selectMessagesByRole,
-  selectBroadcastMessages,
-  selectMessagesUnreadCountByRole,
-  selectBroadcastMessagesUnreadCount,
-  selectMessagesUnreadCountByPeerID,
-  selectAudioPlaylist,
-  selectVideoPlaylist,
-  selectPeersByRole,
-  selectPeers,
-  selectPeerMetadata,
-} from '../../core';
-
-let fakeStore: HMSStore;
-
-// start from a new fake store for every test
-beforeEach(() => {
-  fakeStore = makeFakeStore();
-});
-describe('test primitive selectors', () => {
-  test('selectRoom', () => {
-    expect(selectRoom(fakeStore)).toBe(fakeStore.room);
-  });
-
-  test('selectIsConnectedToRoom false', () => {
-    fakeStore.room.isConnected = false;
-    expect(selectIsConnectedToRoom(fakeStore)).toBe(false);
-  });
-
-  test('selectIsConnectedToRoom true', () => {
-    fakeStore.room.isConnected = true;
-    expect(selectIsConnectedToRoom(fakeStore)).toBe(true);
-  });
-
-  test('room state disconnected', () => {
-    expect(selectRoomState(fakeStore)).toBe(HMSRoomState.Disconnected);
-    expect(selectIsInPreview(fakeStore)).toBe(false);
-    expect(selectRoomStarted(fakeStore)).toBe(false);
-  });
-
-  test('room state preview/connected', () => {
-    fakeStore.room.roomState = HMSRoomState.Preview;
-    expect(selectIsInPreview(fakeStore)).toBe(true);
-    expect(selectRoomStarted(fakeStore)).toBe(true);
-  });
-
-  test('selectLocal things', () => {
-    expect(selectLocalMediaSettings(fakeStore)).toBe(fakeStore.settings);
-    expect(selectLocalPeer(fakeStore)).toBe(localPeer);
-    expect(selectLocalPeerID(fakeStore)).toBe(localPeer.id);
-    expect(selectLocalVideoTrackID(fakeStore)).toBe(localPeer.videoTrack);
-    expect(selectLocalAudioTrackID(fakeStore)).toBe(localPeer.audioTrack);
-    localAudio.enabled = true;
-    expect(selectIsLocalAudioEnabled(fakeStore)).toBe(true);
-    localAudio.enabled = false;
-    expect(selectIsLocalAudioEnabled(fakeStore)).toBe(false);
-    localVideo.enabled = true;
-    expect(selectIsLocalVideoEnabled(fakeStore)).toBe(true);
-    localVideo.enabled = false;
-    expect(selectIsLocalVideoEnabled(fakeStore)).toBe(false);
-    expect(selectIsLocalScreenShared(fakeStore)).toBe(false);
-    localVideo.displayEnabled = true;
-    expect(selectIsLocalVideoDisplayEnabled(fakeStore)).toBe(true);
-    expect(selectPermissions(fakeStore)?.mute).toBe(hostRole.permissions.mute);
-    expect(selectPermissions(fakeStore)?.unmute).toBe(hostRole.permissions.unmute);
-  });
-});
-
-describe('secondary selectors', () => {
-  test('screenshare related', () => {
-    expect(selectIsSomeoneScreenSharing(fakeStore)).toBe(true);
-    expect(selectPeerScreenSharing(fakeStore)).toBe(peerScreenSharing);
-    expect(selectPeersScreenSharing(fakeStore)).toEqual([peerScreenSharing]);
-  });
-
-  test('messages related', () => {
-    expect(selectHMSMessagesCount(fakeStore)).toBe(3);
-    expect(selectUnreadHMSMessagesCount(fakeStore)).toBe(1);
-    expect(selectHMSMessages(fakeStore)).toEqual([
-      fakeStore.messages.byID['201'],
-      fakeStore.messages.byID['202'],
-      fakeStore.messages.byID['203'],
-    ]);
-  });
-
-  test('speakers', () => {
-    expect(selectSpeakers(fakeStore)).toBe(fakeStore.speakers);
-    fakeStore.speakers[peerScreenSharing.audioTrack!] = {
-      audioLevel: 10,
-      peerID: peerScreenSharing.id,
-      trackID: peerScreenSharing.audioTrack!,
-    };
-    expect(selectDominantSpeaker(fakeStore)).toBe(localPeer);
-  });
-
-  test('remote peers', () => {
-    expect(selectRemotePeers(fakeStore)).toEqual([remotePeerOne, remotePeerTwo]);
-  });
-
-  test('some track degraded', () => {
-    remoteVideo.degraded = true;
-    screenShare.degraded = true;
-    expect(selectDegradedTracks(fakeStore)).toContain(remoteVideo);
-    expect(selectDegradedTracks(fakeStore)).toContain(screenShare);
-  });
-
-  test('audio playlist related', () => {
-    const list = Object.values(playlist.audio.list);
-    expect(selectAudioPlaylist.list(fakeStore)).toEqual(list);
-    expect(selectAudioPlaylist.progress(fakeStore)).toBe(20);
-    expect(selectAudioPlaylist.currentTime(fakeStore)).toBe(10);
-    expect(selectAudioPlaylist.playbackRate(fakeStore)).toBe(0.5);
-    expect(selectAudioPlaylist.selection(fakeStore)).toEqual({
-      id: list[0].id,
-      hasNext: true,
-      hasPrevious: false,
-    });
-    expect(selectAudioPlaylist.selectedItem(fakeStore)).toEqual(list[0]);
-  });
-
-  test('video playlist related', () => {
-    const list = Object.values(playlist.video.list);
-    expect(selectVideoPlaylist.list(fakeStore)).toEqual(list);
-    expect(selectVideoPlaylist.progress(fakeStore)).toBe(30);
-    expect(selectVideoPlaylist.currentTime(fakeStore)).toBe(20);
-    expect(selectVideoPlaylist.playbackRate(fakeStore)).toBe(1.0);
-    expect(selectVideoPlaylist.selection(fakeStore)).toEqual({
-      id: list[0].id,
-      hasNext: true,
-      hasPrevious: false,
-    });
-    expect(selectVideoPlaylist.selectedItem(fakeStore)).toEqual(list[0]);
-  });
-});
-
-describe('by ID selectors', () => {
-  test('select peer by id', () => {
-    expect(selectPeerByID(localPeer.id)(fakeStore)).toBe(localPeer);
-    expect(selectPeerByID(peerScreenSharing.id)(fakeStore)).toBe(peerScreenSharing);
-  });
-
-  test('select peer AV enabled', () => {
-    localAudio.enabled = false;
-    localVideo.enabled = true;
-    expect(selectIsPeerAudioEnabled(localPeer.id)(fakeStore)).toBe(false);
-    expect(selectIsPeerVideoEnabled(localPeer.id)(fakeStore)).toBe(true);
-  });
-
-  test('selectVideoTrack', () => {
-    expect(selectVideoTrackByPeerID(localPeer.id)(fakeStore)).toBe(localVideo);
-    expect(selectCameraStreamByPeerID(localPeer.id)(fakeStore)).toBe(localVideo);
-    expect(selectScreenShareByPeerID(peerScreenSharing.id)(fakeStore)).toBe(screenShare);
-  });
-
-  test('selectAudioTrack', () => {
-    expect(selectAudioTrackByPeerID(localPeer.id)(fakeStore)).toBe(localAudio);
-  });
-
-  test('selectAuxiliaryAudio', () => {
-    expect(selectAuxiliaryAudioByPeerID(peerScreenSharing.id)(fakeStore)).toBe(auxiliaryAudio);
-  });
-
-  test('selectScreenshareAudio', () => {
-    expect(selectScreenShareAudioByPeerID(peerScreenSharing.id)(fakeStore)).toBe(screenshareAudio);
-  });
-
-  test('selectTrackAudioByID', () => {
-    expect(selectTrackAudioByID(localAudio.id)(fakeStore)).toBe(localSpeaker.audioLevel);
-  });
-
-  test('selectPeerAudioByID', () => {
-    expect(selectPeerAudioByID(localPeer.id)(fakeStore)).toBe(localSpeaker.audioLevel);
-  });
-
-  test('selectAudioVolumeByPeerID', () => {
-    expect(selectAudioVolumeByPeerID(localPeer.id)(fakeStore)).toBe(localAudio.volume);
-  });
-
-  test('selectAudioVolumeByTrackID', () => {
-    expect(selectAudioTrackVolume(localPeer.audioTrack)(fakeStore)).toBe(localAudio.volume);
-  });
-
-  test('selectLocallyMutedByPeerID', () => {
-    expect(selectIsLocallyMutedByPeerID(localPeer.id)(fakeStore)).toBe(false);
-  });
-
-  test('selectLocallyMutedByTrackID', () => {
-    expect(selectIsAudioLocallyMuted(localPeer.audioTrack)(fakeStore)).toBe(false);
-  });
-
-  test('selectSimulcastLayerByTrack', () => {
-    const peer = selectRemotePeers(fakeStore);
-    const track = selectVideoTrackByPeerID(peer[0].id)(fakeStore);
-    expect(selectSimulcastLayerByTrack(track?.id)(fakeStore)).toBe(track?.layer);
-  });
-
-  test('selectMessagesByPeerID', () => {
-    const peer = selectRemotePeers(fakeStore);
-    const messages = selectMessagesByPeerID(peer[0].id)(fakeStore);
-    expect(messages).toEqual([fakeStore.messages.byID['202']]);
-  });
-
-  test('selectMessagesByRole', () => {
-    const peer = selectRemotePeers(fakeStore);
-    const messages = selectMessagesByRole(peer[0].roleName)(fakeStore);
-    expect(messages).toEqual([fakeStore.messages.byID['203']]);
-  });
-
-  test('selectBroadcastMessages', () => {
-    const messages = selectBroadcastMessages(fakeStore);
-    expect(messages).toEqual([fakeStore.messages.byID['201']]);
-  });
-
-  test('selectMessagesUnreadCountByRole', () => {
-    const peer = selectRemotePeers(fakeStore);
-    const messages = selectMessagesUnreadCountByRole(peer[0].roleName)(fakeStore);
-    expect(messages).toBe(0);
-  });
-
-  test('selectMessagesUnreadCountByPeerID', () => {
-    const peer = selectRemotePeers(fakeStore);
-    const messages = selectMessagesUnreadCountByPeerID(peer[0].id)(fakeStore);
-    expect(messages).toBe(1);
-  });
-
-  test('selectBroadcastMessagesUnreadCount', () => {
-    const messages = selectBroadcastMessagesUnreadCount(fakeStore);
-    expect(messages).toBe(0);
-  });
-
-  test('selectPeersByRole', () => {
-    expect(selectPeersByRole('speaker')(fakeStore)).toEqual([remotePeerTwo]);
-    // If role is not present
-    expect(selectPeersByRole('incognito')(fakeStore)).toEqual([]);
-  });
-
-  test('selectPeerMetadata', () => {
-    const peers = selectPeers(fakeStore);
-    const metadata1 = selectPeerMetadata(peers[0].id)(fakeStore);
-    expect(metadata1).toEqual({});
-    const metadata2 = selectPeerMetadata(peers[1].id)(fakeStore);
-    expect(metadata2).toEqual({ hello: 'world' });
-  });
-});
-
-describe('derived selectors', () => {
-  test('select peer with audio status', () => {
-    localAudio.enabled = true;
-    expect(selectPeersWithAudioStatus(fakeStore)).toEqual([
-      { peer: localPeer, isAudioEnabled: true },
-      { peer: peerScreenSharing, isAudioEnabled: false },
-      { peer: remotePeerTwo, isAudioEnabled: false },
-    ]);
-  });
-});

package/src/test/unit/selectorsByReference.test.ts

@@ -1,23 +0,0 @@
-import { localAudio, localVideo, makeFakeStore } from '../fakeStore';
-import { HMSStore, selectIsLocalVideoPluginPresent, selectIsLocalAudioPluginPresent } from '../../core';
-
-let fakeStore: HMSStore;
-
-// start from a new fake store for every test
-beforeEach(() => {
-  fakeStore = makeFakeStore();
-});
-describe('test selectors by reference', () => {
-  test('select is plugin present', () => {
-    localVideo.plugins = ['plugin1', 'plugin2'];
-    localAudio.plugins = ['plugin1', 'plugin2'];
-
-    expect(selectIsLocalVideoPluginPresent('plugin1')(fakeStore)).toBe(true);
-    expect(selectIsLocalVideoPluginPresent('plugin2')(fakeStore)).toBe(true);
-    expect(selectIsLocalVideoPluginPresent('plugin3')(fakeStore)).toBe(false);
-
-    expect(selectIsLocalAudioPluginPresent('plugin1')(fakeStore)).toBe(true);
-    expect(selectIsLocalAudioPluginPresent('plugin2')(fakeStore)).toBe(true);
-    expect(selectIsLocalAudioPluginPresent('plugin3')(fakeStore)).toBe(false);
-  });
-});