@webex/media-helpers 3.0.0-beta.87

package/LICENSE

@@ -0,0 +1,2 @@
+All contents are licensed under the Cisco EULA
+(https://www.cisco.com/c/en/us/products/end-user-license-agreement.html)

package/README.md

@@ -0,0 +1,34 @@
+# @webex/media-helpers
+
+[![standard-readme compliant](https://img.shields.io/badge/readme%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
+
+> Media helpers
+
+This is an internal Cisco Webex plugin. As such, it does not strictly adhere to semantic versioning. Use at your own risk. If you're not working on one of our first party clients, please look at our [developer api](https://developer.webex.com/) and stick to our public plugins.
+
+- [@webex/media-helpers](#webexmedia-helpers)
+  - [Install](#install)
+  - [Usage](#usage)
+  - [Maintainers](#maintainers)
+  - [Contribute](#contribute)
+  - [License](#license)
+
+## Install
+
+```bash
+npm install --save @webex/media-helpers
+```
+
+## Usage
+
+## Maintainers
+
+This package is maintained by [Cisco Webex for Developers](https://developer.webex.com/).
+
+## Contribute
+
+Pull requests welcome. Please see [CONTRIBUTING.md](https://github.com/webex/webex-js-sdk/blob/master/CONTRIBUTING.md) for more details.
+
+## License
+
+© 2016-2022 Cisco and/or its affiliates. All Rights Reserved.

package/dist/index.js

@@ -0,0 +1,68 @@
+"use strict";
+
+var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+_Object$defineProperty(exports, "LocalCameraTrack", {
+  enumerable: true,
+  get: function get() {
+    return _webrtcCore.LocalCameraTrack;
+  }
+});
+_Object$defineProperty(exports, "LocalCameraTrackEvents", {
+  enumerable: true,
+  get: function get() {
+    return _webrtcCore.LocalCameraTrackEvents;
+  }
+});
+_Object$defineProperty(exports, "LocalDisplayTrack", {
+  enumerable: true,
+  get: function get() {
+    return _webrtcCore.LocalDisplayTrack;
+  }
+});
+_Object$defineProperty(exports, "LocalMicrophoneTrack", {
+  enumerable: true,
+  get: function get() {
+    return _webrtcCore.LocalMicrophoneTrack;
+  }
+});
+_Object$defineProperty(exports, "LocalMicrophoneTrackEvents", {
+  enumerable: true,
+  get: function get() {
+    return _webrtcCore.LocalMicrophoneTrackEvents;
+  }
+});
+_Object$defineProperty(exports, "LocalTrack", {
+  enumerable: true,
+  get: function get() {
+    return _webrtcCore.LocalTrack;
+  }
+});
+_Object$defineProperty(exports, "LocalTrackEvents", {
+  enumerable: true,
+  get: function get() {
+    return _webrtcCore.LocalTrackEvents;
+  }
+});
+_Object$defineProperty(exports, "createCameraTrack", {
+  enumerable: true,
+  get: function get() {
+    return _webrtcCore.createCameraTrack;
+  }
+});
+_Object$defineProperty(exports, "createDisplayTrack", {
+  enumerable: true,
+  get: function get() {
+    return _webrtcCore.createDisplayTrack;
+  }
+});
+_Object$defineProperty(exports, "createMicrophoneTrack", {
+  enumerable: true,
+  get: function get() {
+    return _webrtcCore.createMicrophoneTrack;
+  }
+});
+var _webrtcCore = require("./webrtc-core");
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export {\n  LocalTrack,\n  LocalDisplayTrack,\n  LocalTrackEvents,\n  type TrackMuteEvent,\n  type ServerMuteReason,\n  LocalMicrophoneTrackEvents,\n  LocalCameraTrackEvents,\n  LocalMicrophoneTrack,\n  LocalCameraTrack,\n  createMicrophoneTrack,\n  createCameraTrack,\n  createDisplayTrack,\n} from './webrtc-core';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA"}

package/dist/webrtc-core.js

@@ -0,0 +1,185 @@
+"use strict";
+
+var _Reflect$construct = require("@babel/runtime-corejs2/core-js/reflect/construct");
+var _Object$defineProperty = require("@babel/runtime-corejs2/core-js/object/define-property");
+var _interopRequireDefault = require("@babel/runtime-corejs2/helpers/interopRequireDefault");
+_Object$defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.LocalCameraTrackEvents = exports.LocalCameraTrack = void 0;
+_Object$defineProperty(exports, "LocalDisplayTrack", {
+  enumerable: true,
+  get: function get() {
+    return _internalMediaCore.LocalDisplayTrack;
+  }
+});
+exports.LocalMicrophoneTrackEvents = exports.LocalMicrophoneTrack = void 0;
+_Object$defineProperty(exports, "LocalTrack", {
+  enumerable: true,
+  get: function get() {
+    return _internalMediaCore.LocalTrack;
+  }
+});
+_Object$defineProperty(exports, "LocalTrackEvents", {
+  enumerable: true,
+  get: function get() {
+    return _internalMediaCore.LocalTrackEvents;
+  }
+});
+exports.createMicrophoneTrack = exports.createDisplayTrack = exports.createCameraTrack = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/createClass"));
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/assertThisInitialized"));
+var _get2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/get"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/inherits"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/getPrototypeOf"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs2/helpers/defineProperty"));
+var _internalMediaCore = require("@webex/internal-media-core");
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = _Reflect$construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !_Reflect$construct) return false; if (_Reflect$construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(_Reflect$construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+// server forced the client to be unmuted
+// these events are in addition to WCME events. This will be properly typed once webrtc-core event types inheritance is fixed
+var LocalMicrophoneTrackEvents; // these events are in addition to WCME events. This will be properly typed once webrtc-core event types inheritance is fixed
+exports.LocalMicrophoneTrackEvents = LocalMicrophoneTrackEvents;
+(function (LocalMicrophoneTrackEvents) {
+  LocalMicrophoneTrackEvents["ServerMuted"] = "muted:byServer";
+})(LocalMicrophoneTrackEvents || (exports.LocalMicrophoneTrackEvents = LocalMicrophoneTrackEvents = {}));
+var LocalCameraTrackEvents;
+exports.LocalCameraTrackEvents = LocalCameraTrackEvents;
+(function (LocalCameraTrackEvents) {
+  LocalCameraTrackEvents["ServerMuted"] = "muted:byServer";
+})(LocalCameraTrackEvents || (exports.LocalCameraTrackEvents = LocalCameraTrackEvents = {}));
+var LocalMicrophoneTrack = /*#__PURE__*/function (_WcmeLocalMicrophoneT) {
+  (0, _inherits2.default)(LocalMicrophoneTrack, _WcmeLocalMicrophoneT);
+  var _super = _createSuper(LocalMicrophoneTrack);
+  function LocalMicrophoneTrack() {
+    var _this;
+    (0, _classCallCheck2.default)(this, LocalMicrophoneTrack);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "unmuteAllowed", true);
+    return _this;
+  }
+  (0, _createClass2.default)(LocalMicrophoneTrack, [{
+    key: "setUnmuteAllowed",
+    value:
+    /**
+     * @internal
+     */
+    function setUnmuteAllowed(allowed) {
+      this.unmuteAllowed = allowed;
+    }
+
+    /**
+     * @returns true if user is allowed to unmute the track, false otherwise
+     */
+  }, {
+    key: "isUnmuteAllowed",
+    value: function isUnmuteAllowed() {
+      return this.unmuteAllowed;
+    }
+  }, {
+    key: "setMuted",
+    value: function setMuted(muted) {
+      if (!muted) {
+        if (!this.isUnmuteAllowed()) {
+          throw new Error('Unmute is not allowed');
+        }
+      }
+      return (0, _get2.default)((0, _getPrototypeOf2.default)(LocalMicrophoneTrack.prototype), "setMuted", this).call(this, muted);
+    }
+
+    /**
+     * @internal
+     */
+  }, {
+    key: "setServerMuted",
+    value: function setServerMuted(muted, reason) {
+      if (muted !== this.muted) {
+        this.setMuted(muted);
+        this.emit(LocalMicrophoneTrackEvents.ServerMuted, {
+          muted: muted,
+          reason: reason
+        });
+      }
+    }
+  }]);
+  return LocalMicrophoneTrack;
+}(_internalMediaCore.LocalMicrophoneTrack);
+exports.LocalMicrophoneTrack = LocalMicrophoneTrack;
+var LocalCameraTrack = /*#__PURE__*/function (_WcmeLocalCameraTrack) {
+  (0, _inherits2.default)(LocalCameraTrack, _WcmeLocalCameraTrack);
+  var _super2 = _createSuper(LocalCameraTrack);
+  function LocalCameraTrack() {
+    var _this2;
+    (0, _classCallCheck2.default)(this, LocalCameraTrack);
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    _this2 = _super2.call.apply(_super2, [this].concat(args));
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this2), "unmuteAllowed", true);
+    return _this2;
+  }
+  (0, _createClass2.default)(LocalCameraTrack, [{
+    key: "setUnmuteAllowed",
+    value:
+    /**
+     * @internal
+     */
+    function setUnmuteAllowed(allowed) {
+      this.unmuteAllowed = allowed;
+    }
+
+    /**
+     * @returns true if user is allowed to unmute the track, false otherwise
+     */
+  }, {
+    key: "isUnmuteAllowed",
+    value: function isUnmuteAllowed() {
+      return this.unmuteAllowed;
+    }
+  }, {
+    key: "setMuted",
+    value: function setMuted(muted) {
+      if (!muted) {
+        if (!this.isUnmuteAllowed()) {
+          throw new Error('Unmute is not allowed');
+        }
+      }
+      return (0, _get2.default)((0, _getPrototypeOf2.default)(LocalCameraTrack.prototype), "setMuted", this).call(this, muted);
+    }
+
+    /**
+     * @internal
+     */
+  }, {
+    key: "setServerMuted",
+    value: function setServerMuted(muted, reason) {
+      if (muted !== this.muted) {
+        this.setMuted(muted);
+        this.emit(LocalCameraTrackEvents.ServerMuted, {
+          muted: muted,
+          reason: reason
+        });
+      }
+    }
+  }]);
+  return LocalCameraTrack;
+}(_internalMediaCore.LocalCameraTrack);
+exports.LocalCameraTrack = LocalCameraTrack;
+var createMicrophoneTrack = function createMicrophoneTrack(constraints) {
+  return (0, _internalMediaCore.createMicrophoneTrack)(LocalMicrophoneTrack, constraints);
+};
+exports.createMicrophoneTrack = createMicrophoneTrack;
+var createCameraTrack = function createCameraTrack(constraints) {
+  return (0, _internalMediaCore.createCameraTrack)(LocalCameraTrack, constraints);
+};
+exports.createCameraTrack = createCameraTrack;
+var createDisplayTrack = function createDisplayTrack() {
+  return (0, _internalMediaCore.createDisplayTrack)(_internalMediaCore.LocalDisplayTrack);
+};
+exports.createDisplayTrack = createDisplayTrack;
+//# sourceMappingURL=webrtc-core.js.map

package/dist/webrtc-core.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["LocalMicrophoneTrackEvents","LocalCameraTrackEvents","LocalMicrophoneTrack","allowed","unmuteAllowed","muted","isUnmuteAllowed","Error","reason","setMuted","emit","ServerMuted","WcmeLocalMicrophoneTrack","LocalCameraTrack","WcmeLocalCameraTrack","createMicrophoneTrack","constraints","wcmeCreateMicrophoneTrack","createCameraTrack","wcmeCreateCameraTrack","createDisplayTrack","wcmeCreateDisplayTrack","LocalDisplayTrack"],"sources":["webrtc-core.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-misused-new */\n/* eslint-disable valid-jsdoc */\n/* eslint-disable require-jsdoc */\nimport {\n  AudioDeviceConstraints,\n  createCameraTrack as wcmeCreateCameraTrack,\n  createDisplayTrack as wcmeCreateDisplayTrack,\n  createMicrophoneTrack as wcmeCreateMicrophoneTrack,\n  LocalDisplayTrack,\n  LocalMicrophoneTrack as WcmeLocalMicrophoneTrack,\n  LocalCameraTrack as WcmeLocalCameraTrack,\n  VideoDeviceConstraints,\n} from '@webex/internal-media-core';\n\nexport {\n  LocalTrack,\n  LocalDisplayTrack,\n  LocalTrackEvents,\n  type TrackMuteEvent,\n} from '@webex/internal-media-core';\n\nexport type ServerMuteReason =\n  | 'remotelyMuted' // other user has remotely muted us\n  | 'clientRequestFailed' // client called setMuted() but server request failed\n  | 'localUnmuteRequired'; // server forced the client to be unmuted\n\n// these events are in addition to WCME events. This will be properly typed once webrtc-core event types inheritance is fixed\nexport enum LocalMicrophoneTrackEvents {\n  ServerMuted = 'muted:byServer',\n}\n\n// these events are in addition to WCME events. This will be properly typed once webrtc-core event types inheritance is fixed\nexport enum LocalCameraTrackEvents {\n  ServerMuted = 'muted:byServer',\n}\n\nexport class LocalMicrophoneTrack extends WcmeLocalMicrophoneTrack {\n  private unmuteAllowed = true;\n\n  /**\n   * @internal\n   */\n  setUnmuteAllowed(allowed) {\n    this.unmuteAllowed = allowed;\n  }\n\n  /**\n   * @returns true if user is allowed to unmute the track, false otherwise\n   */\n  isUnmuteAllowed() {\n    return this.unmuteAllowed;\n  }\n\n  setMuted(muted: boolean): void {\n    if (!muted) {\n      if (!this.isUnmuteAllowed()) {\n        throw new Error('Unmute is not allowed');\n      }\n    }\n\n    return super.setMuted(muted);\n  }\n\n  /**\n   * @internal\n   */\n  setServerMuted(muted: boolean, reason: ServerMuteReason) {\n    if (muted !== this.muted) {\n      this.setMuted(muted);\n      this.emit(LocalMicrophoneTrackEvents.ServerMuted, {muted, reason});\n    }\n  }\n}\n\nexport class LocalCameraTrack extends WcmeLocalCameraTrack {\n  private unmuteAllowed = true;\n\n  /**\n   * @internal\n   */\n  setUnmuteAllowed(allowed) {\n    this.unmuteAllowed = allowed;\n  }\n\n  /**\n   * @returns true if user is allowed to unmute the track, false otherwise\n   */\n  isUnmuteAllowed() {\n    return this.unmuteAllowed;\n  }\n\n  setMuted(muted: boolean): void {\n    if (!muted) {\n      if (!this.isUnmuteAllowed()) {\n        throw new Error('Unmute is not allowed');\n      }\n    }\n\n    return super.setMuted(muted);\n  }\n\n  /**\n   * @internal\n   */\n  setServerMuted(muted: boolean, reason: ServerMuteReason) {\n    if (muted !== this.muted) {\n      this.setMuted(muted);\n      this.emit(LocalCameraTrackEvents.ServerMuted, {muted, reason});\n    }\n  }\n}\n\nexport const createMicrophoneTrack = (constraints?: AudioDeviceConstraints) =>\n  wcmeCreateMicrophoneTrack(LocalMicrophoneTrack, constraints);\n\nexport const createCameraTrack = (constraints?: VideoDeviceConstraints) =>\n  wcmeCreateCameraTrack(LocalCameraTrack, constraints);\n\nexport const createDisplayTrack = () => wcmeCreateDisplayTrack(LocalDisplayTrack);\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@webex/media-helpers",
+  "version": "3.0.0-beta.87",
+  "description": "",
+  "license": "Cisco EULA (https://www.cisco.com/c/en/us/products/end-user-license-agreement.html)",
+  "main": "dist/index.js",
+  "devMain": "src/index.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/webex/webex-js-sdk.git",
+    "directory": "packages/@webex/media-helpers"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "dependencies": {
+    "@webex/internal-media-core": "1.36.0"
+  },
+  "browserify": {
+    "transform": [
+      "babelify",
+      "envify"
+    ]
+  },
+  "devDependencies": {
+    "@webex/test-helper-chai": "3.0.0-beta.87",
+    "@webex/test-helper-mock-webex": "3.0.0-beta.87",
+    "sinon": "^9.2.4"
+  }
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+export {
+  LocalTrack,
+  LocalDisplayTrack,
+  LocalTrackEvents,
+  type TrackMuteEvent,
+  type ServerMuteReason,
+  LocalMicrophoneTrackEvents,
+  LocalCameraTrackEvents,
+  LocalMicrophoneTrack,
+  LocalCameraTrack,
+  createMicrophoneTrack,
+  createCameraTrack,
+  createDisplayTrack,
+} from './webrtc-core';

package/src/webrtc-core.ts

@@ -0,0 +1,119 @@
+/* eslint-disable @typescript-eslint/no-misused-new */
+/* eslint-disable valid-jsdoc */
+/* eslint-disable require-jsdoc */
+import {
+  AudioDeviceConstraints,
+  createCameraTrack as wcmeCreateCameraTrack,
+  createDisplayTrack as wcmeCreateDisplayTrack,
+  createMicrophoneTrack as wcmeCreateMicrophoneTrack,
+  LocalDisplayTrack,
+  LocalMicrophoneTrack as WcmeLocalMicrophoneTrack,
+  LocalCameraTrack as WcmeLocalCameraTrack,
+  VideoDeviceConstraints,
+} from '@webex/internal-media-core';
+
+export {
+  LocalTrack,
+  LocalDisplayTrack,
+  LocalTrackEvents,
+  type TrackMuteEvent,
+} from '@webex/internal-media-core';
+
+export type ServerMuteReason =
+  | 'remotelyMuted' // other user has remotely muted us
+  | 'clientRequestFailed' // client called setMuted() but server request failed
+  | 'localUnmuteRequired'; // server forced the client to be unmuted
+
+// these events are in addition to WCME events. This will be properly typed once webrtc-core event types inheritance is fixed
+export enum LocalMicrophoneTrackEvents {
+  ServerMuted = 'muted:byServer',
+}
+
+// these events are in addition to WCME events. This will be properly typed once webrtc-core event types inheritance is fixed
+export enum LocalCameraTrackEvents {
+  ServerMuted = 'muted:byServer',
+}
+
+export class LocalMicrophoneTrack extends WcmeLocalMicrophoneTrack {
+  private unmuteAllowed = true;
+
+  /**
+   * @internal
+   */
+  setUnmuteAllowed(allowed) {
+    this.unmuteAllowed = allowed;
+  }
+
+  /**
+   * @returns true if user is allowed to unmute the track, false otherwise
+   */
+  isUnmuteAllowed() {
+    return this.unmuteAllowed;
+  }
+
+  setMuted(muted: boolean): void {
+    if (!muted) {
+      if (!this.isUnmuteAllowed()) {
+        throw new Error('Unmute is not allowed');
+      }
+    }
+
+    return super.setMuted(muted);
+  }
+
+  /**
+   * @internal
+   */
+  setServerMuted(muted: boolean, reason: ServerMuteReason) {
+    if (muted !== this.muted) {
+      this.setMuted(muted);
+      this.emit(LocalMicrophoneTrackEvents.ServerMuted, {muted, reason});
+    }
+  }
+}
+
+export class LocalCameraTrack extends WcmeLocalCameraTrack {
+  private unmuteAllowed = true;
+
+  /**
+   * @internal
+   */
+  setUnmuteAllowed(allowed) {
+    this.unmuteAllowed = allowed;
+  }
+
+  /**
+   * @returns true if user is allowed to unmute the track, false otherwise
+   */
+  isUnmuteAllowed() {
+    return this.unmuteAllowed;
+  }
+
+  setMuted(muted: boolean): void {
+    if (!muted) {
+      if (!this.isUnmuteAllowed()) {
+        throw new Error('Unmute is not allowed');
+      }
+    }
+
+    return super.setMuted(muted);
+  }
+
+  /**
+   * @internal
+   */
+  setServerMuted(muted: boolean, reason: ServerMuteReason) {
+    if (muted !== this.muted) {
+      this.setMuted(muted);
+      this.emit(LocalCameraTrackEvents.ServerMuted, {muted, reason});
+    }
+  }
+}
+
+export const createMicrophoneTrack = (constraints?: AudioDeviceConstraints) =>
+  wcmeCreateMicrophoneTrack(LocalMicrophoneTrack, constraints);
+
+export const createCameraTrack = (constraints?: VideoDeviceConstraints) =>
+  wcmeCreateCameraTrack(LocalCameraTrack, constraints);
+
+export const createDisplayTrack = () => wcmeCreateDisplayTrack(LocalDisplayTrack);

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

@@ -0,0 +1,115 @@
+import {assert, expect} from '@webex/test-helper-chai';
+import sinon from 'sinon';
+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', event: LocalCameraTrackEvents, createFn: createCameraTrack, spyFn: 'createCameraTrack'},
+      {className: LocalMicrophoneTrack, title: 'LocalMicrophoneTrack', event: LocalMicrophoneTrackEvents, createFn: createMicrophoneTrack, spyFn: 'createMicrophoneTrack'},
+    ];
+
+    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('resolves setMute(false) if unmute is allowed', async () => {
+        track.setUnmuteAllowed(true);
+
+        assert.equal(track.isUnmuteAllowed(), true);
+        await track.setMuted(false);
+      });
+
+      describe('#setServerMuted', () => {
+
+        afterEach(() => {
+          sinon.restore();
+        });
+
+        const checkSetServerMuted = async (startMute, setMute, expectedCalled) => {
+          await track.setMuted(startMute);
+
+          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);
+    });
+
+  });
+ });
+});