@webex/media-helpers 3.0.0-bnr.3 → 3.0.0-bnr.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/media-helpers",
-  "version": "3.0.0-bnr.3",
+  "version": "3.0.0-bnr.4",
   "description": "",
   "license": "Cisco EULA (https://www.cisco.com/c/en/us/products/end-user-license-agreement.html)",
   "main": "dist/index.js",
@@ -23,8 +23,8 @@
     ]
   },
   "devDependencies": {
-    "@webex/test-helper-chai": "3.0.0-bnr.3",
-    "@webex/test-helper-mock-webex": "3.0.0-bnr.3",
+    "@webex/test-helper-chai": "workspace:^",
+    "@webex/test-helper-mock-webex": "workspace:^",
     "sinon": "^9.2.4"
   }
 }

package/test/unit/spec/webrtc-core.js

@@ -1,45 +1,115 @@
-import {assert} from '@webex/test-helper-chai';
+import {assert, expect} from '@webex/test-helper-chai';
 import sinon from 'sinon';
-import {LocalCameraTrack, LocalMicrophoneTrack} from '@webex/media-helpers';
+import {LocalCameraTrack, LocalMicrophoneTrack, LocalMicrophoneTrackEvents, LocalCameraTrackEvents, LocalDisplayTrack, createCameraTrack, createMicrophoneTrack, createDisplayTrack} from '@webex/media-helpers';
+import * as wcmetracks from '@webex/internal-media-core';
 
 describe('media-helpers', () => {
   describe('webrtc-core', () => {
 
     const classesToTest = [
-      {className: LocalCameraTrack, title: 'LocalCameraTrack'},
-      {className: LocalMicrophoneTrack, title: 'LocalMicrophoneTrack'},
+      {className: LocalCameraTrack, title: 'LocalCameraTrack', event: LocalCameraTrackEvents, createFn: createCameraTrack, spyFn: 'createCameraTrack'},
+      {className: LocalMicrophoneTrack, title: 'LocalMicrophoneTrack', event: LocalMicrophoneTrackEvents, createFn: createMicrophoneTrack, spyFn: 'createMicrophoneTrack'},
     ];
 
-    classesToTest.forEach(({className, title}) =>
-      describe(title, () => {
-        const fakeStream = {
-          getTracks: sinon.stub().returns([{
-            label: 'fake track',
-            id: 'fake track id',
-          }])
-        };
-        const track = new className(fakeStream);
+    classesToTest.forEach(({className, title, event, createFn, spyFn}) =>
+    describe(title, () => {
+      const fakeStream = {
+        getTracks: sinon.stub().returns([{
+          label: 'fake track',
+          id: 'fake track id',
+          enabled: true,
+        }])
+      };
+      const track = new className(fakeStream);
+
+      afterEach(() => {
+        sinon.restore();
+      });
+
+      it('by default allows unmuting', async () => {
+        assert.equal(track.isUnmuteAllowed(), true);
+        await track.setMuted(false);
+      })
+
+      it('rejects setMute(false) if unmute is not allowed', async () => {
+        track.setUnmuteAllowed(false);
+
+        assert.equal(track.isUnmuteAllowed(), false);
+        const fn = () => track.setMuted(false);
+        expect(fn).to.throw(/Unmute is not allowed/);
+      });
 
-        it('by default allows unmuting', async () => {
-          assert.equal(track.isUnmuteAllowed(), true);
-          await track.setMuted(false);
-        })
+      it('resolves setMute(false) if unmute is allowed', async () => {
+        track.setUnmuteAllowed(true);
 
-        it('rejects setMute(false) if unmute is not allowed', async () => {
-          track.setUnmuteAllowed(false);
+        assert.equal(track.isUnmuteAllowed(), true);
+        await track.setMuted(false);
+      });
 
-          assert.equal(track.isUnmuteAllowed(), false);
-          await assert.isRejected(track.setMuted(false), Error, 'Unmute is not allowed');
+      describe('#setServerMuted', () => {
+
+        afterEach(() => {
+          sinon.restore();
         });
 
-        it('resolves setMute(false) if unmute is allowed', async () => {
-          track.setUnmuteAllowed(true);
+        const checkSetServerMuted = async (startMute, setMute, expectedCalled) => {
+          await track.setMuted(startMute);
 
-          assert.equal(track.isUnmuteAllowed(), true);
-          await track.setMuted(false);
-        })
+          assert.equal(track.muted, startMute);
+
+          const handler = sinon.fake();
+          track.on(event.ServerMuted, handler);
+
+          await track.setServerMuted(setMute, 'remotelyMuted');
+
+          assert.equal(track.muted, setMute);
+          if (expectedCalled) {
+            assert.calledOnceWithExactly(handler, {muted: setMute, reason: 'remotelyMuted'});
+          } else {
+            assert.notCalled(handler);
+          }
+        };
+
+        it('tests true to false', async () => {
+          await checkSetServerMuted(true, false, true);
+        });
+  
+        it('tests false to true', async () => {
+          await checkSetServerMuted(false, true, true);
+        });
+  
+        it('tests true to true', async () => {
+          await checkSetServerMuted(true, true, false);
+        });
+  
+        it('tests false to false', async () => {
+          await checkSetServerMuted(false, false, false);
+        });
+      });
+
+      describe('#wcmeCreateMicrophoneTrack, #wcmeCreateCameraTrack', () => {
+        it('checks creating tracks', async () => {
+          const constraints = {devideId: 'abc'};
+  
+          const spy = sinon.stub(wcmetracks, spyFn).returns('something');
+          const result = createFn(constraints);
+  
+          assert.equal(result, 'something');
+          assert.calledOnceWithExactly(spy, className, constraints);
+        });
+      });
+
+    })
+  );
+
+  describe('createDisplayTrack', () => {
+    it('checks createDisplayTrack', async () => {
+      const spy = sinon.stub(wcmetracks, 'createDisplayTrack').returns('something');
+      const result = createDisplayTrack();
+      assert.equal(result, 'something');
+      assert.calledOnceWithExactly(spy, LocalDisplayTrack);
+    });
 
-      })
-    )
   });
-});
+ });
+});