Skip to content

armgit / Piik

Public Imported from GitHub
0

Free, open-source screen sharing for private live streams with friends. Watch together in a browser or self-host Piik. 免费开源的私密屏幕共享,支持游戏直播、一起看电影与自部署。

8.2 KB
Raw Blame
import { describe, expect, it, vi } from "vitest";

import type { SignalPayload } from "../src/shared/protocol";
import {
  NativeSenderEdge,
  type NativeEdgeControl,
} from "../src/client/native/native-sender-edge";
import type { NativeClientEvent } from "../src/client/native/wire";

function fixture(natPrediction = false, extraStun = false, retry = false) {
  let listener: ((event: NativeClientEvent) => void) | null = null;
  const prepareEdge = vi.fn<NativeEdgeControl["prepareEdge"]>(async () => ({
    type: "offer",
    sdp: "v=0\r\n",
  }));
  const control: NativeEdgeControl = {
    preparePunch: vi.fn(async () => null),
    runPunch: vi.fn(async () => false),
    closePunch: vi.fn(async () => undefined),
    updateShare: vi.fn(async () => undefined),
    prepareEdge,
    acceptSignal: vi.fn(async () => undefined),
    closeEdge: vi.fn(async () => undefined),
    onEvent: vi.fn((next) => {
      listener = next;
      return () => {
        listener = null;
      };
    }),
  };
  const sent: SignalPayload[] = [];
  const states: RTCPeerConnectionState[] = [];
  const sendSignal = vi.fn((_peerId: string, payload: SignalPayload) => {
    sent.push(payload);
    return true;
  });
  const edge = new NativeSenderEdge(
    "viewer_123456",
    "edge_12345678",
    "share_1234567",
    natPrediction
      ? {
          iceServers: [{ urls: ["stun:share.example.test:3478", ...(extraStun ? ["stun:other.example.test:3478"] : [])] }],
          natPredictionStunUrls: [
            "stun:share.example.test:3479",
            "stun:share.example.test:3480",
          ],
        }
      : { iceServers: [], natPredictionStunUrls: [] },
    natPrediction,
    control,
    {
      sendSignal,
      onState: (state) => states.push(state),
    },
    undefined, retry,
  );
  return {
    edge,
    control,
    sent,
    states,
    sendSignal,
    emit: (event: NativeClientEvent) => listener?.(event),
  };
}

describe("native sender edge adapter", () => {
  it("keeps initial ICE immediate and falls through immediately for a Browser retry", async () => {
    const initial = fixture(true);
    expect(await initial.edge.start()).toBe(true);
    expect(initial.control.preparePunch).not.toHaveBeenCalled();
    initial.edge.dispose();

    const retry = fixture(true, false, true);
    const started = retry.edge.start();
    expect(retry.sent[0].kind).toBe("punch");
    await retry.edge.acceptSignal({ kind: "punch", connectionId: "edge_12345678", punch: { phase: "ready" } });
    expect(await started).toBe(true);
    expect(retry.control.runPunch).not.toHaveBeenCalled();
    expect(retry.control.prepareEdge).toHaveBeenCalledWith("share_1234567", "edge_12345678", expect.anything(), undefined, false);
    expect(retry.sent.find(signal => signal.kind === "description")).not.toHaveProperty("punched");
    retry.edge.dispose();
  });
  it.each([null, { candidate: "candidate:1 1 udp 1 127.0.0.1 9 typ host" }])(
    "keeps connected media when trickle signaling is unavailable: %j", async (candidate) => {
      const current = fixture();
      expect(await current.edge.start()).toBe(true);
      current.emit({ version: 10, type: "edge-state", shareId: "share_1234567", connectionId: "edge_12345678", state: "connected" });
      current.sendSignal.mockReturnValue(false);
      current.emit({ version: 10, type: "edge-candidate", shareId: "share_1234567", connectionId: "edge_12345678", candidate });
      expect(current.edge.isConnected()).toBe(true);
      expect(current.control.closeEdge).not.toHaveBeenCalled();
      expect(current.states).toEqual(["connected"]);
      current.emit({ version: 10, type: "edge-state", shareId: "share_1234567", connectionId: "edge_12345678", state: "failed" });
      expect(current.edge.isConnected()).toBe(false);
      expect(current.states).toEqual(["connected", "failed"]);
      current.edge.dispose();
      current.emit({ version: 10, type: "edge-state", shareId: "share_1234567", connectionId: "edge_12345678", state: "connected" });
      expect(current.edge.isConnected()).toBe(false);
      expect(current.control.closeEdge).toHaveBeenCalledOnce();
    },
  );

  it("retires an offer that could not be sent, but leaves gathered candidates to edge recovery", async () => {
    const rejected = fixture();
    rejected.sendSignal.mockReturnValue(false);
    expect(await rejected.edge.start()).toBe(false);
    expect(rejected.control.closeEdge).toHaveBeenCalledOnce();

    const current = fixture();
    vi.mocked(current.control.prepareEdge).mockImplementationOnce(async () => {
      current.emit({ version: 10, type: "edge-candidate", shareId: "share_1234567", connectionId: "edge_12345678", candidate: null });
      return { type: "offer", sdp: "v=0\r\n" };
    });
    current.sendSignal.mockImplementation((_peer, payload) => payload.kind === "description");
    expect(await current.edge.start()).toBe(true);
    expect(current.control.closeEdge).not.toHaveBeenCalled();
    current.edge.dispose();
  });

  it("sends the offer before candidates gathered during preparation", async () => {
    const current = fixture();
    const prepare = vi.mocked(current.control.prepareEdge);
    prepare.mockImplementationOnce(async () => {
      current.emit({
        version: 10,
        type: "edge-candidate",
        shareId: "share_1234567",
        connectionId: "edge_12345678",
        candidate: {
          candidate: "candidate:1 1 udp 1 127.0.0.1 9 typ host",
        },
      });
      return { type: "offer", sdp: "v=0\r\n" };
    });
    expect(await current.edge.start()).toBe(true);
    expect(current.sent.map((payload) => payload.kind)).toEqual([
      "description",
      "candidate",
    ]);
  });

  it("forwards only exact-generation signals and state", async () => {
    const current = fixture();
    expect(await current.edge.start()).toBe(true);
    current.emit({
      version: 10,
      type: "edge-state",
      shareId: "share_1234567",
      connectionId: "edge_12345678",
      state: "connected",
    });
    expect(current.edge.isConnected()).toBe(true);
    await current.edge.acceptSignal({
      kind: "candidate",
      connectionId: "other_123456",
      candidate: null,
    });
    expect(current.control.acceptSignal).not.toHaveBeenCalled();
    await current.edge.acceptSignal({
      kind: "candidate",
      connectionId: "edge_12345678",
      candidate: null,
    });
    expect(current.control.acceptSignal).toHaveBeenCalledOnce();
  });

  it("reuses the Site survey for Native candidate prediction", async () => {
    const current = fixture(true);
    expect(await current.edge.start()).toBe(true);
    expect(vi.mocked(current.control.prepareEdge).mock.calls[0]?.[2].iceServers)
      .toHaveLength(3);
    for (const [index, port] of [40_000, 40_003, 40_006].entries()) {
      current.emit({
        version: 10,
        type: "edge-candidate",
        shareId: "share_1234567",
        connectionId: "edge_12345678",
        candidate: {
          candidate: `candidate:ns${index + 1} 1 udp 1 203.0.113.7 ${port} typ srflx`,
        },
      });
    }
    const candidates = current.sent.flatMap((payload) =>
      payload.kind === "candidate" && payload.candidate
        ? [payload.candidate.candidate]
        : [],
    );
    expect(candidates.filter((candidate) => /^candidate:s[pm]\d+ /.test(candidate)))
      .toHaveLength(8);
  });

  it("forwards extra STUN candidates without mistaking them for prediction evidence", async () => {
    const current = fixture(true, true);
    expect(await current.edge.start()).toBe(true);
    const emit = (index: number, port: number) => current.emit({
      version: 10, type: "edge-candidate", shareId: "share_1234567", connectionId: "edge_12345678",
      candidate: { candidate: `candidate:ns${index} 1 udp 1 203.0.113.7 ${port} typ srflx` },
    });
    const candidates = () => current.sent.flatMap(payload => payload.kind === "candidate" && payload.candidate
      ? [payload.candidate.candidate] : []);
    // Deliberately receive out of list order, with three seemingly sequential ports.
    emit(3, 40_006);
    emit(2, 40_003);
    emit(1, 40_000);
    expect(candidates()).toHaveLength(3);
    emit(4, 40_012);
    expect(candidates().filter(value => /^candidate:ns/.test(value))).toHaveLength(4);
    expect(candidates().filter(value => /^candidate:s[pm]/.test(value))).toHaveLength(8);
    current.edge.dispose();
  });
});