ep_webrtc 2.5.35 → 2.5.36

package/static/tests/frontend-new/specs/setStream.spec.ts

@@ -0,0 +1,185 @@
+import {expect, test} from '@playwright/test';
+import {cartesian, goToNewPadWithParams, installFakeGetUserMedia} from '../helper/utils';
+
+const otherUserId = 'other_user_id';
+const otherVideoId = `video_${otherUserId.replace(/\./g, '_')}`;
+const otherInterfaceId = `interface_${otherVideoId}`;
+
+test.describe('setStream()', () => {
+  test.describe('Audio and video enabled', () => {
+    const testCases = [...cartesian(...Array(4).fill([false, true]) as boolean[][])].map(
+        ([webrtcaudioenabled, webrtcvideoenabled, peerAudio, peerVideo]: boolean[]) => ({
+          params: {webrtcaudioenabled, webrtcvideoenabled},
+          peer: {audio: peerAudio, video: peerVideo},
+        }));
+
+    for (const tc of testCases) {
+      test.describe(JSON.stringify(tc), () => {
+        test.describe.configure({mode: 'serial'});
+        let sharedPage: import('@playwright/test').Page;
+        let ownVideoId: string;
+        let ownInterfaceId: string;
+
+        test.beforeAll(async ({browser}) => {
+          sharedPage = await browser.newPage();
+          test.setTimeout(60_000);
+          await goToNewPadWithParams(sharedPage, {av: false, ...tc.params});
+          await installFakeGetUserMedia(sharedPage);
+          await sharedPage.evaluate(() => (window as any).ep_webrtc.activate());
+          const ids = await sharedPage.evaluate(() => {
+            const w = window as any;
+            const ownUserId = w.ep_webrtc.getUserId();
+            const ownVideoId = `video_${ownUserId.replace(/\./g, '_')}`;
+            return {ownVideoId, ownInterfaceId: `interface_${ownVideoId}`};
+          });
+          ownVideoId = ids.ownVideoId;
+          ownInterfaceId = ids.ownInterfaceId;
+          await sharedPage.evaluate(async ({peer, otherUserId}) => {
+            const w = window as any;
+            const peerStream = (peer.audio || peer.video)
+                ? await w.__fakeGetUserMedia(peer)
+                : new MediaStream();
+            await w.ep_webrtc.setStream(otherUserId, peerStream);
+          }, {peer: tc.peer, otherUserId});
+        });
+
+        test.afterAll(async () => {
+          await sharedPage.close();
+        });
+
+        test('self and peer elements exist', async () => {
+          const count = await sharedPage.locator('.interface-container').count();
+          expect(count).toBe(2);
+        });
+
+        test('self interface', async () => {
+          // Self view is always muted (no audio feedback).
+          const muted = await sharedPage.locator(`#${ownVideoId}`)
+              .evaluate((el) => (el as HTMLVideoElement).muted);
+          expect(muted).toBe(true);
+
+          const audioBtn = sharedPage.locator(`#${ownInterfaceId} .audio-btn`);
+          expect(await audioBtn.count()).toBe(1);
+          expect(await audioBtn.evaluate((el) => el.classList.contains('muted')))
+              .toBe(!tc.params.webrtcaudioenabled);
+          expect(await audioBtn.evaluate((el) => el.classList.contains('disallowed')))
+              .toBe(false);
+
+          const videoBtn = sharedPage.locator(`#${ownInterfaceId} .video-btn`);
+          expect(await videoBtn.count()).toBe(1);
+          expect(await videoBtn.evaluate((el) => el.classList.contains('off')))
+              .toBe(!tc.params.webrtcvideoenabled);
+          expect(await videoBtn.evaluate((el) => el.classList.contains('disallowed')))
+              .toBe(false);
+
+          const enlargeBtn = sharedPage.locator(`#${ownInterfaceId} .enlarge-btn`);
+          expect(await enlargeBtn.count()).toBe(1);
+          expect(await enlargeBtn.evaluate((el) => el.classList.contains('large')))
+              .toBe(false);
+        });
+
+        test('peer interface', async () => {
+          const audioBtn = sharedPage.locator(`#${otherInterfaceId} .audio-btn`);
+          expect(await audioBtn.count()).toBe(1);
+          // Only initially muted if browser doesn't permit autoplay unless muted.
+          const peerVideoMuted = await sharedPage.locator(`#${otherVideoId}`)
+              .evaluate((el) => (el as HTMLVideoElement).muted);
+          expect(await audioBtn.evaluate((el) => el.classList.contains('muted')))
+              .toBe(peerVideoMuted);
+
+          const videoBtn = sharedPage.locator(`#${otherInterfaceId} .video-btn`);
+          expect(await videoBtn.count()).toBe(0);
+
+          const enlargeBtn = sharedPage.locator(`#${otherInterfaceId} .enlarge-btn`);
+          expect(await enlargeBtn.count()).toBe(1);
+          expect(await enlargeBtn.evaluate((el) => el.classList.contains('large')))
+              .toBe(false);
+        });
+      });
+    }
+  });
+
+  test.describe('Audio and video hard disabled', () => {
+    test.describe.configure({mode: 'serial'});
+    let sharedPage: import('@playwright/test').Page;
+    let ownVideoId: string;
+    let ownInterfaceId: string;
+
+    test.beforeAll(async ({browser}) => {
+      sharedPage = await browser.newPage();
+      test.setTimeout(60_000);
+      await goToNewPadWithParams(sharedPage, {
+        av: false,
+        webrtcaudioenabled: true,
+        webrtcvideoenabled: true,
+      });
+      await installFakeGetUserMedia(sharedPage);
+      await sharedPage.waitForFunction(
+          () => (window as any).$('#rtcbox').data('initialized'));
+      await sharedPage.evaluate(() => {
+        const w = window as any;
+        w.ep_webrtc._settings.audio.disabled = 'hard';
+        w.ep_webrtc._settings.video.disabled = 'hard';
+      });
+      await sharedPage.evaluate(() => (window as any).ep_webrtc.activate());
+      const ids = await sharedPage.evaluate(() => {
+        const w = window as any;
+        const ownUserId = w.ep_webrtc.getUserId();
+        const ownVideoId = `video_${ownUserId.replace(/\./g, '_')}`;
+        return {ownVideoId, ownInterfaceId: `interface_${ownVideoId}`};
+      });
+      ownVideoId = ids.ownVideoId;
+      ownInterfaceId = ids.ownInterfaceId;
+      await sharedPage.evaluate(async (otherUserId) => {
+        const w = window as any;
+        await w.ep_webrtc.setStream(otherUserId, new MediaStream());
+      }, otherUserId);
+    });
+
+    test.afterAll(async () => {
+      await sharedPage.close();
+    });
+
+    test('self and peer elements exist', async () => {
+      const count = await sharedPage.locator('.interface-container').count();
+      expect(count).toBe(2);
+    });
+
+    test('self interface', async () => {
+      const muted = await sharedPage.locator(`#${ownVideoId}`)
+          .evaluate((el) => (el as HTMLVideoElement).muted);
+      expect(muted).toBe(true);
+
+      const audioBtn = sharedPage.locator(`#${ownInterfaceId} .audio-btn`);
+      expect(await audioBtn.count()).toBe(1);
+      expect(await audioBtn.evaluate((el) => el.classList.contains('muted'))).toBe(true);
+      expect(await audioBtn.evaluate((el) => el.classList.contains('disallowed'))).toBe(true);
+
+      const videoBtn = sharedPage.locator(`#${ownInterfaceId} .video-btn`);
+      expect(await videoBtn.count()).toBe(1);
+      expect(await videoBtn.evaluate((el) => el.classList.contains('off'))).toBe(true);
+      expect(await videoBtn.evaluate((el) => el.classList.contains('disallowed'))).toBe(true);
+
+      const enlargeBtn = sharedPage.locator(`#${ownInterfaceId} .enlarge-btn`);
+      expect(await enlargeBtn.count()).toBe(1);
+      expect(await enlargeBtn.evaluate((el) => el.classList.contains('large'))).toBe(false);
+    });
+
+    test('peer interface', async () => {
+      const audioBtn = sharedPage.locator(`#${otherInterfaceId} .audio-btn`);
+      expect(await audioBtn.count()).toBe(1);
+      // Mute state only depends on browser autoplay-when-unmuted permission.
+      const peerVideoMuted = await sharedPage.locator(`#${otherVideoId}`)
+          .evaluate((el) => (el as HTMLVideoElement).muted);
+      expect(await audioBtn.evaluate((el) => el.classList.contains('muted')))
+          .toBe(peerVideoMuted);
+
+      const videoBtn = sharedPage.locator(`#${otherInterfaceId} .video-btn`);
+      expect(await videoBtn.count()).toBe(0);
+
+      const enlargeBtn = sharedPage.locator(`#${otherInterfaceId} .enlarge-btn`);
+      expect(await enlargeBtn.count()).toBe(1);
+      expect(await enlargeBtn.evaluate((el) => el.classList.contains('large'))).toBe(false);
+    });
+  });
+});

package/static/tests/frontend/specs/audio_video_on_start.js

@@ -1,35 +0,0 @@
-'use strict';
-
-const {cartesian, fakeGetUserMedia} = require('ep_webrtc/static/tests/frontend/utils');
-
-describe('audio/video on/off according to query parameters/cookies', function () {
-  const testCases = cartesian(['audio', 'video'], [null, false, true], [null, false, true]);
-
-  for (const [avType, cookieVal, queryVal] of testCases) {
-    it(`${avType} cookie=${cookieVal} query=${queryVal}`, async function () {
-      this.timeout(60000);
-      await helper.aNewPad({
-        padPrefs: cookieVal == null ? {} : {[`${avType}EnabledOnStart`]: cookieVal},
-        params: Object.assign({
-          // Disable WebRTC so we can install a fake getUserMedia() before WebRTC stuff is
-          // initialized.
-          av: false,
-        }, queryVal == null ? {} : {[`webrtc${avType}enabled`]: queryVal}),
-      });
-      const chrome$ = helper.padChrome$;
-      chrome$.window.navigator.mediaDevices.getUserMedia = fakeGetUserMedia;
-      // Clicking $(#options-enablertc) also activates, but calling activate() directly blocks until
-      // activation is complete.
-      await chrome$.window.ep_webrtc.activate();
-      const {disabled} = chrome$.window.ep_webrtc._settings[avType];
-      const checkbox = chrome$(`#options-${avType}enabledonstart`);
-      if (disabled === 'hard') {
-        expect(checkbox.length).to.equal(0); // There shouldn't even be a checkbox.
-      } else {
-        const wantChecked = (queryVal || (queryVal == null && cookieVal) ||
-                             (queryVal == null && cookieVal == null && disabled === 'none'));
-        expect(checkbox.prop('checked')).to.equal(wantChecked);
-      }
-    });
-  }
-});

package/static/tests/frontend/specs/checkbox.js

@@ -1,107 +0,0 @@
-'use strict';
-
-const {cartesian} = require('ep_webrtc/static/tests/frontend/utils');
-
-describe('settingToCheckbox', function () {
-  const testCases = [
-    ...cartesian([false, true], [null, false, true], [null, false, true]),
-  ].map(([defaultVal, cookieVal, queryVal], i) => ({
-    name: `default=${defaultVal} cookie=${cookieVal} query=${queryVal}`,
-    defaultVal,
-    cookieVal,
-    queryVal,
-    i,
-    id: `checkboxId${i}`,
-    want: queryVal ||
-        (queryVal == null && cookieVal) ||
-        (queryVal == null && cookieVal == null && defaultVal),
-  }));
-  let chrome$;
-  let padcookie;
-
-  before(async function () {
-    this.timeout(60000);
-    await helper.aNewPad({
-      padPrefs: Object.assign({}, ...testCases
-          .filter(({cookieVal}) => cookieVal != null)
-          .map(({cookieVal, i}) => ({[`cookie${i}`]: cookieVal}))),
-      params: Object.assign({av: false}, ...testCases
-          .filter(({queryVal}) => queryVal != null)
-          .map(({queryVal, i}) => ({[`urlVar${i}`]: queryVal}))),
-    });
-    chrome$ = helper.padChrome$;
-    padcookie = chrome$.window.require('ep_etherpad-lite/static/js/pad_cookie').padcookie;
-    for (const {id} of testCases) {
-      chrome$('#settings').append(chrome$('<input>').attr('type', 'checkbox').attr('id', id));
-    }
-    await helper.waitForPromise(() => {
-      for (const {id} of testCases) {
-        if (chrome$(`#${id}`).length !== 1) return false;
-      }
-      return true;
-    });
-    for (const {defaultVal, i, id} of testCases) {
-      chrome$.window.ep_webrtc.settingToCheckbox({
-        urlVar: `urlVar${i}`,
-        cookie: `cookie${i}`,
-        defaultVal,
-        checkboxId: `#${id}`,
-      });
-    }
-  });
-
-  describe('initially checked/unchecked', function () {
-    for (const {name, want, id} of testCases) {
-      it(name, async function () {
-        expect(chrome$(`#${id}`).prop('checked')).to.equal(want);
-      });
-    }
-  });
-
-  describe('query parameter sets cookie', function () {
-    for (const {name, queryVal, i} of testCases.filter(({queryVal}) => queryVal != null)) {
-      it(name, async function () {
-        expect(padcookie.getPref(`cookie${i}`)).to.equal(queryVal);
-      });
-    }
-  });
-
-  describe('no query parameter, no cookie -> cookie not set', function () {
-    for (const {name, queryVal, cookieVal, i} of testCases) {
-      if (queryVal != null || cookieVal != null) continue;
-      it(name, async function () {
-        expect(padcookie.getPref(`cookie${i}`) == null).to.be(true);
-      });
-    }
-  });
-
-  describe('clicking sets cookie', function () {
-    for (const {name, i, id, want} of testCases) {
-      it(name, async function () {
-        const cb = chrome$(`#${id}`);
-        cb.click();
-        await helper.waitForPromise(() => cb.prop('checked') === !want);
-        expect(padcookie.getPref(`cookie${i}`)).to.equal(!want);
-      });
-    }
-  });
-
-  describe('throws errors for missing params', function () {
-    const params = {
-      urlVar: 'urlVar',
-      cookie: 'cookie',
-      defaultVal: true,
-      checkboxId: '#checkboxId',
-    };
-
-    for (const k of Object.keys(params)) {
-      const badParams = Object.assign({}, params);
-      delete badParams[k];
-
-      it(k, async function () {
-        expect(() => chrome$.window.ep_webrtc.settingToCheckbox(badParams))
-            .to.throwError(new RegExp(k));
-      });
-    }
-  });
-});

package/static/tests/frontend/specs/enable_disable.js

@@ -1,50 +0,0 @@
-'use strict';
-
-const {cartesian} = require('ep_webrtc/static/tests/frontend/utils');
-
-describe('enable/disable', function () {
-  const testCases = cartesian([null, false, true], [null, false, true, 'NO', 'YES', 'ignored']);
-
-  for (const [cookieVal, queryVal] of testCases) {
-    describe(`cookie=${cookieVal} query=${queryVal}`, function () {
-      let chrome$;
-      let wantChecked;
-      let checkbox;
-
-      before(async function () {
-        this.timeout(60000);
-        await helper.aNewPad({
-          padPrefs: cookieVal == null ? {} : {rtcEnabled: cookieVal},
-          params: queryVal == null ? {} : {av: queryVal},
-        });
-        chrome$ = helper.padChrome$;
-        // Normalize queryVal to null/false/true.
-        const queryNorm =
-            !!queryVal === queryVal ? queryVal // Already boolean.
-            : queryVal === 'NO' ? false
-            : queryVal === 'YES' ? true
-            : null;
-        await helper.waitForPromise(() => chrome$('#rtcbox').data('initialized'), 5000);
-        const defaultChecked = !!chrome$.window.ep_webrtc._settings.enabled;
-        wantChecked = (queryNorm || (queryNorm == null && cookieVal) ||
-                       (queryNorm == null && cookieVal == null && defaultChecked));
-        checkbox = chrome$('#options-enablertc');
-      });
-
-      it('checkbox is checked/unchecked', async function () {
-        expect(checkbox.prop('checked')).to.equal(wantChecked);
-      });
-
-      it('self video element', async function () {
-        expect(chrome$('#rtcbox video').length).to.equal(wantChecked ? 1 : 0);
-      });
-
-      it('clicking checkbox toggles state', async function () {
-        checkbox.click();
-        expect(checkbox.prop('checked')).to.equal(!wantChecked);
-        await helper.waitForPromise(
-            () => chrome$('#rtcbox video').length === (wantChecked ? 0 : 1));
-      });
-    });
-  }
-});

package/static/tests/frontend/specs/errors.js

@@ -1,58 +0,0 @@
-'use strict';
-
-describe('error handling', function () {
-  let chrome$;
-  let $videoBtn;
-  let getUserMediaBackup;
-
-  const testCases = [
-    // Hard to test the version of NotAllowedError that is the SSL error
-    // because it requires changing window.location
-    ['NotAllowedError', 'Failed to get permission to access'],
-    ['NotFoundError', 'Failed to access'],
-    ['NotReadableError', 'hardware error occurred'],
-    ['AbortError', 'not a hardware error'],
-  ];
-
-  before(async function () {
-    this.timeout(60000);
-    await helper.aNewPad({params: {
-      av: true,
-      webrtcaudioenabled: false,
-      webrtcvideoenabled: false,
-    }});
-    chrome$ = helper.padChrome$;
-    await helper.waitForPromise(() => chrome$('#rtcbox').data('initialized'));
-    const ownUserId = chrome$.window.ep_webrtc.getUserId();
-    const ownVideoId = `video_${ownUserId.replace(/\./g, '_')}`;
-    const ownInterfaceId = `interface_${ownVideoId}`;
-    $videoBtn = chrome$(`#${ownInterfaceId} .video-btn`);
-    getUserMediaBackup = chrome$.window.navigator.mediaDevices.getUserMedia;
-  });
-
-  after(async function () {
-    chrome$.window.navigator.mediaDevices.getUserMedia = getUserMediaBackup;
-  });
-
-  beforeEach(async function () {
-    // No idea why but this needs to be called twice to actually make #gritter-container hidden
-    chrome$.gritter.removeAll({fade: false});
-    chrome$.gritter.removeAll({fade: false});
-    expect($videoBtn.hasClass('off')).to.equal(true);
-  });
-
-  for (const [errName, checkString] of testCases) {
-    it(errName, async function () {
-      chrome$.window.navigator.mediaDevices.getUserMedia = async () => {
-        const err = new Error();
-        err.name = errName;
-        throw err;
-      };
-      await helper.waitForPromise(() => chrome$('#gritter-container:visible').length === 0, 1000);
-      $videoBtn.click();
-      await helper.waitForPromise(() => chrome$('#gritter-container:visible').length === 1, 1000);
-      expect(chrome$('.gritter-title').html()).to.be('Error');
-      expect(chrome$('.gritter-content p').html()).to.contain(checkString);
-    });
-  }
-});

package/static/tests/frontend/specs/interface_buttons.js

@@ -1,251 +0,0 @@
-'use strict';
-
-const {fakeGetUserMedia} = require('ep_webrtc/static/tests/frontend/utils');
-
-describe('Test the behavior of the interface buttons: Mute, Video Disable, Enlarge', function () {
-  let audioTrack;
-  let videoTrack;
-
-  const installFakeGetUserMedia = () => {
-    const chrome$ = helper.padChrome$;
-    chrome$.window.navigator.mediaDevices.getUserMedia = async (constraints) => {
-      const stream = await fakeGetUserMedia(constraints);
-      audioTrack = stream.getAudioTracks()[0];
-      videoTrack = stream.getVideoTracks()[0];
-      return stream;
-    };
-  };
-
-  describe('audio and video on by default', function () {
-    beforeEach(async function () {
-      this.timeout(60000);
-      audioTrack = null;
-      videoTrack = null;
-
-      // Make sure webrtc starts disabled so we have time to wrap getUserMedia
-      await helper.aNewPad({
-        padPrefs: {
-          rtcEnabled: false,
-          audioEnabledOnStart: true,
-          videoEnabledOnStart: true,
-        },
-      });
-      const chrome$ = helper.padChrome$;
-      installFakeGetUserMedia();
-      // Clicking $('#options-enablertc') also activates, but calling activate() directly blocks
-      // until activation is complete.
-      await chrome$.window.ep_webrtc.activate();
-    });
-
-    it('enlarges then shrinks', async function () {
-      const chrome$ = helper.padChrome$;
-
-      this.timeout(60000);
-
-      // i.e., "160.25px" -> 160.25 the number
-      const numFromCssSize = (size) => {
-        expect(size.slice(-2)).to.be('px');
-        return Number(size.slice(0, -2));
-      };
-
-      // All of these sizes have to allow for tolerances.
-      // I.e. it has come back a quarter pixel off before.
-      const $video = chrome$('video');
-      await helper.waitForPromise(() => {
-        const w = numFromCssSize($video.css('width'));
-        const h = numFromCssSize($video.css('height'));
-        return 159 < w && w < 161 && 119 < h && h < 121;
-      });
-
-      const $enlargeBtn = chrome$('.enlarge-btn');
-      $enlargeBtn.click();
-
-      // Expect it to grow to 260, 190
-      await helper.waitForPromise(
-          () => (numFromCssSize($video.css('width')) > 259 &&
-                 numFromCssSize($video.css('height')) > 194),
-          1000);
-      $enlargeBtn.click();
-      // Expect it to shrink to 160, 116
-      await helper.waitForPromise(
-          () => (numFromCssSize($video.css('width')) < 161 &&
-                 numFromCssSize($video.css('height')) < 121),
-          1000);
-    });
-
-    it('mutes then unmutes', async function () {
-      this.timeout(60000);
-
-      const chrome$ = helper.padChrome$;
-
-      expect(audioTrack.enabled).to.be(true);
-      expect(chrome$('.audio-btn.muted').length).to.be(0);
-      expect(chrome$('.audio-btn').attr('title')).to.be('Mute');
-
-      const $audioBtn = chrome$('.audio-btn');
-      $audioBtn.click();
-
-      await helper.waitForPromise(
-          () => chrome$('.audio-btn.muted').length === 1 && audioTrack.enabled === false, 3000);
-      expect(chrome$('.audio-btn').attr('title')).to.be('Unmute');
-      $audioBtn.click();
-      await helper.waitForPromise(
-          () => chrome$('.audio-btn.muted').length === 0 && audioTrack.enabled === true, 3000);
-      expect(chrome$('.audio-btn').attr('title')).to.be('Mute');
-    });
-
-    it('disables then enables video', async function () {
-      this.timeout(60000);
-
-      const chrome$ = helper.padChrome$;
-
-      expect(videoTrack.enabled).to.be(true);
-      expect(chrome$('.video-btn.off').length).to.be(0);
-      expect(chrome$('.video-btn').attr('title')).to.contain('Disable');
-
-      const $videoBtn = chrome$('.video-btn');
-      $videoBtn.click();
-
-      await helper.waitForPromise(
-          () => chrome$('.video-btn.off').length === 1 && videoTrack.enabled === false, 3000);
-      expect(chrome$('.video-btn').attr('title')).to.contain('Enable');
-      $videoBtn.click();
-      await helper.waitForPromise(
-          () => chrome$('.video-btn.off').length === 0 && videoTrack.enabled === true, 3000);
-      expect(chrome$('.video-btn').attr('title')).to.contain('Disable');
-    });
-  });
-
-  context('audio and video off by default', function () {
-    beforeEach(async function () {
-      this.timeout(60000);
-      audioTrack = null;
-      videoTrack = null;
-
-      // Make sure webrtc starts disabled so we have time to wrap getUserMedia
-      await helper.aNewPad({
-        padPrefs: {
-          rtcEnabled: false,
-          audioEnabledOnStart: false,
-          videoEnabledOnStart: false,
-        },
-      });
-      const chrome$ = helper.padChrome$;
-      installFakeGetUserMedia();
-      // Clicking $('#options-enablertc') also activates, but calling activate() directly blocks
-      // until activation is complete.
-      await chrome$.window.ep_webrtc.activate();
-    });
-
-    it('unmutes then mutes', async function () {
-      this.timeout(60000);
-
-      const chrome$ = helper.padChrome$;
-
-      expect(audioTrack).to.be(null);
-      expect(chrome$('.audio-btn.muted').length).to.be(1);
-      expect(chrome$('.audio-btn').attr('title')).to.be('Unmute');
-
-      const $audioBtn = chrome$('.audio-btn');
-      $audioBtn.click();
-
-      await helper.waitForPromise(
-          () => (chrome$('.audio-btn.muted').length === 0 &&
-                 audioTrack != null && audioTrack.enabled),
-          3000);
-      expect(chrome$('.audio-btn').attr('title')).to.be('Mute');
-      $audioBtn.click();
-      await helper.waitForPromise(
-          () => chrome$('.audio-btn.muted').length === 1 && audioTrack.enabled === false, 3000);
-      expect(chrome$('.audio-btn').attr('title')).to.be('Unmute');
-    });
-
-    it('enables then disables video', async function () {
-      this.timeout(60000);
-
-      const chrome$ = helper.padChrome$;
-
-      expect(videoTrack).to.be(null);
-      expect(chrome$('.video-btn.off').length).to.be(1);
-      expect(chrome$('.video-btn').attr('title')).to.contain('Enable');
-
-      const $videoBtn = chrome$('.video-btn');
-      $videoBtn.click();
-
-      await helper.waitForPromise(
-          () => (chrome$('.video-btn.off').length === 0 &&
-                 videoTrack != null && videoTrack.enabled),
-          3000);
-      expect(chrome$('.video-btn').attr('title')).to.contain('Disable');
-      $videoBtn.click();
-      await helper.waitForPromise(
-          () => chrome$('.video-btn.off').length === 1 && videoTrack.enabled === false, 3000);
-      expect(chrome$('.video-btn').attr('title')).to.contain('Enable');
-    });
-  });
-
-  context('audio and video hard-disabled', function () {
-    beforeEach(async function () {
-      this.timeout(60000);
-      audioTrack = null;
-      videoTrack = null;
-      // Make sure webrtc starts disabled so we have time to wrap getUserMedia and change settings
-      // before activation.
-      await helper.aNewPad({params: {av: false}});
-      const chrome$ = helper.padChrome$;
-      await helper.waitForPromise(() => chrome$('#rtcbox').data('initialized'));
-      chrome$.window.ep_webrtc._settings.audio.disabled = 'hard';
-      chrome$.window.ep_webrtc._settings.video.disabled = 'hard';
-      installFakeGetUserMedia();
-      // Clicking $(#options-enablertc) also activates, but calling activate() directly blocks until
-      // activation is complete.
-      await chrome$.window.ep_webrtc.activate();
-    });
-
-    it('cannot mute or unmute', async function () {
-      this.timeout(60000);
-
-      const chrome$ = helper.padChrome$;
-
-      expect(chrome$('.audio-btn.disallowed').length).to.be(1);
-      expect(chrome$('.audio-btn.muted').length).to.be(1);
-      expect(chrome$('.audio-btn').attr('title')).to.be('Audio disallowed by admin');
-      expect(audioTrack).to.be(null);
-      expect(videoTrack).to.be(null);
-
-      const $audioBtn = chrome$('.audio-btn');
-      $audioBtn.click();
-
-      // Wait a sec to make sure there's no change
-      await new Promise((resolve) => setTimeout(resolve, 200));
-      expect(chrome$('.audio-btn.disallowed').length).to.be(1);
-      expect(chrome$('.audio-btn.muted').length).to.be(1);
-      expect(chrome$('.audio-btn').attr('title')).to.be('Audio disallowed by admin');
-      expect(audioTrack).to.be(null);
-      expect(videoTrack).to.be(null);
-    });
-
-    it('cannot enable or disable video', async function () {
-      this.timeout(60000);
-
-      const chrome$ = helper.padChrome$;
-
-      expect(chrome$('.video-btn.disallowed').length).to.be(1);
-      expect(chrome$('.video-btn.off').length).to.be(1);
-      expect(chrome$('.video-btn').attr('title')).to.be('Video disallowed by admin');
-      expect(audioTrack).to.be(null);
-      expect(videoTrack).to.be(null);
-
-      const $videoBtn = chrome$('.video-btn');
-      $videoBtn.click();
-
-      // Wait a sec to make sure there's no change
-      await new Promise((resolve) => setTimeout(resolve, 200));
-      expect(chrome$('.video-btn.disallowed').length).to.be(1);
-      expect(chrome$('.video-btn.off').length).to.be(1);
-      expect(chrome$('.video-btn').attr('title')).to.be('Video disallowed by admin');
-      expect(audioTrack).to.be(null);
-      expect(videoTrack).to.be(null);
-    });
-  });
-});