Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
22 changes: 11 additions & 11 deletions js/hang/src/container/consumer.startup.test.ts
Original file line number Diff line number Diff line change
@@ -1,14 +1,14 @@
import { expect, jest, onTestFinished, spyOn, test } from "bun:test";
import { Micro, Milli } from "@moq/clock";
import { expect, onTestFinished, spyOn, test } from "bun:test";
import { Manual, Micro, Milli, Nano } from "@moq/clock";
import { type Group, Error as NetError, StreamCode, Time, Track } from "@moq/net";
import { Consumer, type Read } from "./consumer.ts";
import { encodeFrame, Format } from "./legacy.ts";

// Drain the in-memory readers and their continuations without advancing mocked time.
const flush = () => new Promise<void>((resolve) => setImmediate(resolve));

function setup(maxDelay = 100) {
jest.useFakeTimers();
const clock = new Manual();
const installed = clock.install();
// Drain the in-memory readers and their continuations without moving time.
const flush = () => clock.advance(Nano.zero);
const track = new Track.Producer("video");
const consumer = new Consumer(track.subscribe({ maxDelay: Milli(30_000) }), {
format: new Format("video"),
Expand All @@ -31,10 +31,10 @@ function setup(maxDelay = 100) {
await reading;
} finally {
warn.mockRestore();
jest.useRealTimers();
installed.close();
}
});
return { track, consumer, results, warn };
return { track, consumer, results, warn, flush };
}

// Each item as "gap <µs>+<µs>", "<group>@<µs>" for a frame, or "end <group>@<µs>".
Expand All @@ -61,7 +61,7 @@ for (const emptySuccessor of [false, true]) {
test.each([0, 100])(
`Consumer starts across a hole after an empty reset (empty successor: ${emptySuccessor}, maxDelay: %s)`,
async (maxDelay) => {
const { track, results, warn } = setup(maxDelay);
const { track, results, warn, flush } = setup(maxDelay);
const stale = track.createGroup(16);
await flush();
if (emptySuccessor) {
Expand Down Expand Up @@ -91,7 +91,7 @@ for (const emptySuccessor of [false, true]) {
}

test("Consumer preserves a declared marker before its first media across a hole", async () => {
const { track, results, warn } = setup();
const { track, results, warn, flush } = setup();
const marker = track.createGroup(16);
write(marker, 0, true);
marker.finish();
Expand All @@ -109,7 +109,7 @@ test("Consumer preserves a declared marker before its first media across a hole"
});

test.each([false, true])("Consumer still waits for a gap after media (playhead reset: %s)", async (reset) => {
const { track, consumer, results, warn } = setup(1000);
const { track, consumer, results, warn, flush } = setup(1000);
const first = track.createGroup(16);
write(first, 0);
first.finish();
Expand Down
12 changes: 5 additions & 7 deletions js/net/src/connection/connect.test.ts
Original file line number Diff line number Diff line change
@@ -1,4 +1,4 @@
import { expect, jest, spyOn, test } from "bun:test";
import { expect, spyOn, test } from "bun:test";
import { Manual, Milli, Nano, sleep } from "@moq/clock";
import { ConnectTimeout, SessionCode, SessionError } from "../error.ts";
import * as Ietf from "../ietf/index.ts";
Expand Down Expand Up @@ -300,7 +300,8 @@ test("connect without a signal still works", async () => {
// A session-level stream failure promises an authoritative session close, even when the
// browser publishes that close after the reset-only fallback would otherwise fire.
test("SETUP preserves a delayed session close code", async () => {
jest.useFakeTimers();
const clock = new Manual();
const installed = clock.install();
const closed = Promise.withResolvers<WebTransportCloseInfo>();
let localCloses = 0;
const transport = {
Expand All @@ -319,10 +320,7 @@ test("SETUP preserves a delayed session close code", async () => {
(cause: unknown) => cause,
);
try {
// Drain the finite async setup chain before advancing the mocked clock.
for (let i = 0; i < 64; i++) await Promise.resolve();
jest.advanceTimersByTime(1_000);
for (let i = 0; i < 64; i++) await Promise.resolve();
await clock.advance(Nano.fromMilli(Milli(1_000)));
expect(localCloses).toBe(0);
closed.resolve({ closeCode: SessionCode.Unauthorized, reason: "unauthorized" });
const cause = await result;
Expand All @@ -331,7 +329,7 @@ test("SETUP preserves a delayed session close code", async () => {
} finally {
closed.resolve({ closeCode: 0, reason: "test cleanup" });
await result;
jest.useRealTimers();
installed.close();
}
});

Expand Down
90 changes: 43 additions & 47 deletions js/net/src/connection/forward.test.ts
Original file line number Diff line number Diff line change
@@ -1,4 +1,5 @@
import { afterEach, beforeEach, expect, jest, spyOn, test } from "bun:test";
import { type Installed, Manual, Milli, Nano } from "@moq/clock";
import { Once } from "@moq/signals";
import * as Announce from "../announced.ts";
import { AuthSession } from "../auth_session.ts";
Expand All @@ -14,19 +15,28 @@ import { forwardAnnounced } from "./forward.ts";

const LINGER = 2000;

let clock: Manual;
let installed: Installed;

beforeEach(() => {
jest.useFakeTimers();
clock = new Manual();
installed = clock.install();
spyOn(console, "warn").mockImplementation(() => {});
});

afterEach(() => {
jest.useRealTimers();
installed.close();
jest.restoreAllMocks();
});

/** Drain the reactive microtasks; timers only move through `jest.advanceTimersByTime`. */
async function settle() {
for (let i = 0; i < 64; i++) await Promise.resolve();
/** Drain the reactive work without moving time. */
function settle(): Promise<void> {
return clock.advance(Nano.zero);
}

/** Move time forward, draining the reactive work at each deadline on the way. */
function advance(ms: number): Promise<void> {
return clock.advance(Nano.fromMilli(Milli(ms)));
}

/**
Expand All @@ -47,6 +57,9 @@ class FakeSession {
/** Whether each request is synced as it opens, as one with no initial set to wait for is. */
syncedAtOnce = false;

/** Called as the forwarder closes a request, before its stream can wind down. */
onClose?: () => void;

closed: Promise<Error | null>;
#die!: (reason: Error | null) => void;

Expand All @@ -68,6 +81,11 @@ class FakeSession {
this.requests.push({ scope: scope.text, hidden: options?.hidden, stream });
if (this.syncedAtOnce) stream.synced();
const consumer = stream.consume();
const close = consumer.close.bind(consumer);
consumer.close = () => {
this.onClose?.();
close();
};
// The last reader leaving cancels the request, as a session's does.
closeUnwanted(stream);
return consumer;
Expand Down Expand Up @@ -157,22 +175,16 @@ test("a watch opens its request, and the request closes once the linger expires"

// Unwatching keeps the request open for the linger, so a watcher rebuilt in that window reuses it.
watch.close();
await settle();
jest.advanceTimersByTime(LINGER - 1);
await settle();
await advance(LINGER - 1);
expect(session.open()).toEqual(["room/**"]);

const again = origin.announced(Path.Pattern.subtree(Path.from("room")));
await settle();
jest.advanceTimersByTime(LINGER);
await settle();
await advance(LINGER);
expect(session.open()).toEqual(["room/**"]);
expect(session.requests.length).toBe(1);

again.close();
await settle();
jest.advanceTimersByTime(LINGER);
await settle();
await advance(LINGER);
expect(session.open()).toEqual([]);
// Closing it on purpose is not a discovery failure.
expect(origin.discovery.peek()).toBe(true);
Expand All @@ -192,13 +204,16 @@ test("a watch arriving as the linger expires opens a fresh request", async () =>
await settle();

// The expiry closes the old request, and the next watch lands before its stream winds down.
jest.advanceTimersByTime(LINGER);
const again = origin.announced(Path.Pattern.subtree(Path.from("room")));
await settle();
let again: Announce.Consumer | undefined;
session.onClose = () => {
again ??= origin.announced(Path.Pattern.subtree(Path.from("room")));
};
await advance(LINGER);
expect(again).toBeDefined();
expect(session.requests.length).toBe(2);
expect(session.open()).toEqual(["room/**"]);

again.close();
again?.close();
session.die();
origin.close();
});
Expand Down Expand Up @@ -253,9 +268,7 @@ test("a follower is a watch on its path", async () => {
expect(request.active.peek()).toBeDefined();

request.close();
await settle();
jest.advanceTimersByTime(LINGER);
await settle();
await advance(LINGER);
expect(session.open()).toEqual([]);

session.die();
Expand Down Expand Up @@ -295,18 +308,14 @@ test("a narrower watch rides an open broader request and keeps it open", async (
// The broader watch leaves, but its request stays open for the narrower one, so no request
// takes its routes over and nothing restarts.
broad.close();
await settle();
jest.advanceTimersByTime(LINGER);
await settle();
await advance(LINGER);
expect(session.open()).toEqual(["a/**"]);
expect(wireOf(origin).routes(Path.from("a/b/x"))).toBe(true);
expect(events).toEqual(["start a/b/x"]);

// Once nothing beneath it is watched, it lingers out.
narrow.close();
await settle();
jest.advanceTimersByTime(LINGER);
await settle();
await advance(LINGER);
expect(session.open()).toEqual([]);
expect(wireOf(origin).routes(Path.from("a/b/x"))).toBe(false);

Expand All @@ -330,20 +339,15 @@ test("a narrower request stays open until the broader one covering it goes", asy
const events = record(broad);
await settle();
narrow.close();
await settle();
jest.advanceTimersByTime(LINGER);
await settle();
await advance(LINGER);
expect(session.open()).toEqual(["a/b/**", "a/**"]);
expect(wireOf(origin).routes(Path.from("a/b/x"))).toBe(true);
expect(events).toEqual(["start a/b/x"]);

// Once the broader request lingers out, the narrower one it held follows.
broad.close();
await settle();
jest.advanceTimersByTime(LINGER);
await settle();
jest.advanceTimersByTime(LINGER);
await settle();
await advance(LINGER);
await advance(LINGER);
expect(session.open()).toEqual([]);
expect(wireOf(origin).routes(Path.from("a/b/x"))).toBe(false);

Expand Down Expand Up @@ -378,14 +382,10 @@ test("an exclusive session closes every request beneath a broader one before it

// The narrower watch rides the broader request from here on.
broad.close();
await settle();
jest.advanceTimersByTime(LINGER);
await settle();
await advance(LINGER);
expect(session.open()).toEqual(["a/**"]);
narrow.close();
await settle();
jest.advanceTimersByTime(LINGER);
await settle();
await advance(LINGER);
expect(session.open()).toEqual([]);
expect(session.requests.map(({ scope }) => scope)).toEqual(["a/b/**", "a/c/**", "a/**"]);

Expand Down Expand Up @@ -604,16 +604,12 @@ test("a scoped origin narrows a root watch to its disjoint literal heads", async
// nothing.
let inside = origin.announced(Path.Pattern.subtree(Path.from("room/alice/chat")));
const outside = origin.announced(Path.Pattern.subtree(Path.from("elsewhere")));
await settle();
jest.advanceTimersByTime(LINGER);
await settle();
await advance(LINGER);
expect(session.open()).toEqual(["room/**"]);

// With nothing open above it, a watch inside a head asks for itself.
inside.close();
await settle();
jest.advanceTimersByTime(LINGER);
await settle();
await advance(LINGER);
expect(session.open()).toEqual([]);
inside = origin.announced(Path.Pattern.subtree(Path.from("room/alice/chat")));
await settle();
Expand Down
Loading
Loading