Skip to content

A platform for community discussion. Free, open, simple.

3.5 KB
Raw Blame
import { module, test } from "qunit";
import SignalingManager from "discourse/plugins/live/discourse/lib/live/signaling";

function wait(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

function deferred() {
  let resolve;
  let reject;

  const promise = new Promise((resolvePromise, rejectPromise) => {
    resolve = resolvePromise;
    reject = rejectPromise;
  });

  return { promise, resolve, reject };
}

module("Live | Unit | Lib | signaling", function () {
  test("clearForPeer drops unsent HTTP-batched signals for destroyed peers", async function (assert) {
    assert.timeout(1000);

    let requests = 0;

    const manager = new SignalingManager({
      isActiveRoom: () => true,
      hasPeer: () => true,
      httpBatchDelayMs: 5,
      requestSignals: async () => {
        requests++;
      },
    });

    const send = manager.send(1, 2, { type: "offer", sdp: "v=0" });
    await Promise.resolve();
    manager.clearForPeer(1, 2);

    await send;
    await wait(50);

    assert.strictEqual(
      requests,
      0,
      "does not send signals that were cleared during teardown"
    );

    manager.destroy();
  });

  test("flushes a recipient's batch early once it reaches the event cap", async function (assert) {
    assert.timeout(2000);

    const payloads = [];

    const manager = new SignalingManager({
      isActiveRoom: () => true,
      hasPeer: () => true,
      // Far beyond the test's patience: only the early flush can send.
      httpBatchDelayMs: 5000,
      requestSignals: async (roomId, payload) => {
        payloads.push(payload);
      },
    });

    const sends = [];
    for (let i = 0; i < 20; i++) {
      sends.push(manager.send(1, 2, { type: "offer", sdp: `sdp-${i}` }));
    }
    await Promise.all(sends);

    assert.strictEqual(
      payloads.length,
      1,
      "sends without waiting for the batch timer"
    );
    assert.strictEqual(
      payloads[0].events.length,
      20,
      "carries the whole accumulated batch"
    );

    manager.destroy();
  });

  test("each HTTP flush only settles the signals it actually sent", async function (assert) {
    assert.timeout(2000);

    const requests = [];
    let firstResolved = false;
    let secondResolved = false;

    const manager = new SignalingManager({
      isActiveRoom: () => true,
      hasPeer: () => true,
      httpBatchDelayMs: 5,
      requestSignals: () => {
        const request = deferred();
        requests.push(request);
        return request.promise;
      },
    });

    const firstSend = manager
      .send(1, 2, { type: "offer", sdp: "first" })
      .then(() => {
        firstResolved = true;
      });

    await wait(50);

    assert.strictEqual(requests.length, 1, "starts the first HTTP flush");

    const secondSend = manager
      .send(1, 3, {
        type: "offer",
        sdp: "second",
      })
      .then(() => {
        secondResolved = true;
      });

    await wait(50);

    assert.strictEqual(
      requests.length,
      2,
      "starts a second HTTP flush for signals queued during the first one"
    );

    requests[0].resolve();
    await firstSend;

    assert.true(firstResolved, "resolves the first send after the first flush");
    assert.false(
      secondResolved,
      "does not resolve later sends when an earlier flush completes"
    );

    requests[1].resolve();
    await secondSend;

    assert.true(
      secondResolved,
      "resolves the second send after its own flush completes"
    );

    manager.destroy();
  });
});