Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
20 commits
Select commit Hold shift + click to select a range
23dfd92
chore(quest): claim quest/m1/route-swap-keeps-incumbent.md
kixelated Nov 5, 2026
9043240
fix(net): a replacement that fails before delivering never ends a liv…
kixelated Nov 5, 2026
d21aa0c
fix(net): splice at once over a complete incumbent copy; finish the q…
kixelated Nov 5, 2026
5e65093
style: rustfmt
kixelated Nov 5, 2026
682b0ab
fix(net): an awaited replacement follows the readers' demand
kixelated Nov 5, 2026
db6fe80
Merge origin/main; a replacement failing after the front concludes ke…
kixelated Nov 5, 2026
f7767cf
Merge remote-tracking branch 'origin/main' into HEAD
kixelated Nov 5, 2026
b74cc1a
quest land: merge tested base
Nov 5, 2026
ed61b47
fix(net): settle the CodeRabbit findings on the replacement gate
kixelated Nov 5, 2026
b9ab8a0
Merge remote-tracking branch 'origin/main' into t3/bf250198
kixelated Nov 5, 2026
7bf01a4
style(net): rustfmt the new test
kixelated Nov 5, 2026
1a6ea1e
wip(net): judge a reached end by what the reader's range still owes
kixelated Nov 5, 2026
80d1e90
fix(net): a JS reader joining before the replacement delivers keeps t…
kixelated Nov 5, 2026
27a65da
Merge remote-tracking branch 'origin/main' into t3/bf250198
kixelated Nov 5, 2026
c31c153
style(net): satisfy biome
kixelated Nov 5, 2026
1f0b2ee
fix(net): keep the incumbent across replacements that have yet to del…
kixelated Nov 5, 2026
d85b732
fix(net): a JS fork joins the incumbent, and only a settled end excus…
kixelated Nov 5, 2026
ecd88f7
style(net): biome format
kixelated Nov 5, 2026
7e34ac3
Merge branch 'base' into pr-7956
Nov 6, 2026
354c2f8
test(net): follow base route API renames
Nov 6, 2026
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
251 changes: 251 additions & 0 deletions js/net/src/resume.test.ts
Original file line number Diff line number Diff line change
Expand Up @@ -757,6 +757,257 @@ test("a replacement differing only in unchecked takes over", async () => {
close();
});

// Mirrors `a_replacement_aborted_after_its_answer_keeps_the_incumbent` in rs/moq-net/src/model/origin.rs.
test("a replacement that answers and then aborts before its first group leaves the incumbent serving", async () => {
const { a, b, swap, active, close } = await setup();
const ta = copy(a);
const tb = copy(b);
const sub = active.track("seq").subscribe();
ta.write(0n);
expect(drain(sub)).toEqual([0n]);

await swap();
tb.producer.abort(new StreamError(StreamCode(64)));
await settle();
expect(sub.closed.peek()).toBeUndefined();

ta.write(1n);
await settle();
expect(drain(sub)).toEqual([1n]);

// The incumbent's clean end is the track's, not the replacement's error.
ta.producer.finish();
expect(await sub.recvGroup()).toBeUndefined();

sub.close();
close();
});

// Mirrors the Rust front: an incumbent that finished cleanly ends the track whoever serves it.
test("a replacement that aborts before its first group after the incumbent finished ends the track cleanly", async () => {
const { a, b, swap, active, close } = await setup();
const ta = copy(a);
const tb = copy(b);
const sub = active.track("seq").subscribe();
ta.write(0n);
expect(drain(sub)).toEqual([0n]);

await swap();
ta.write(1n);
ta.producer.finish();
tb.producer.abort(new StreamError(StreamCode(64)));
await settle();
const groups: bigint[] = [];
for (let group = await sub.recvGroup(); group; group = await sub.recvGroup()) {
groups.push(group.sequence);
group.close();
}
expect(groups).toEqual([1n]);

sub.close();
close();
});

// Mirrors `readers_owed_nothing_below_the_incumbents_end_end_cleanly` in rs/moq-net/src/model/origin.rs:
// a reader owed nothing below the incumbent's end, and one joining while the replacement has yet
// to deliver, end cleanly once the incumbent finished and the replacement aborted.
test("readers owed nothing below the incumbent's end end cleanly when the replacement aborts", async () => {
const { a, b, swap, active, close } = await setup();
const ta = copy(a);
const tb = copy(b);
const later = active.track("seq").subscribe({ ranges: [{ start: { absolute: 3n } }] });
ta.write(0n);
ta.write(1n);
await swap();
const joiner = active.track("seq").subscribe();
await settle();
ta.producer.finish();
tb.producer.abort(new StreamError(StreamCode(64)));
await settle();

expect(await later.recvGroup()).toBeUndefined();
const groups: bigint[] = [];
for (let group = await joiner.recvGroup(); group; group = await joiner.recvGroup()) {
groups.push(group.sequence);
group.close();
}
expect(groups).toEqual([1n]);

later.close();
joiner.close();
close();
});

// A reader arriving after the replacement answered reads the incumbent too, as the Rust front
// serves it until the replacement delivers.
test("a reader joining before the replacement delivers keeps the incumbent when the replacement aborts", async () => {
const { a, b, swap, active, close } = await setup();
const ta = copy(a);
const tb = copy(b);
const first = active.track("seq").subscribe();
ta.write(0n);
expect(drain(first)).toEqual([0n]);
await swap();
const joiner = active.track("seq").subscribe();
await settle();
tb.producer.abort(new StreamError(StreamCode(64)));
await settle();
ta.write(1n);
await settle();
expect(drain(joiner)).toContain(1n);
expect(joiner.closed.peek()).toBeUndefined();

first.close();
joiner.close();
close();
});

// The incumbent is the source that last delivered, however many replacements answered since.
test("a reader joining after two undelivered replacements keeps the incumbent when both abort", async () => {
const { origin, a, b, swap, active, close } = await setup();
const c = new BroadcastProducer();
const ta = copy(a);
const tb = copy(b);
const tc = copy(c);
const first = active.track("seq").subscribe();
ta.write(0n);
expect(drain(first)).toEqual([0n]);
await swap();
const disposeC = serve(origin, c, 0n);
await settle();
await settle();
const joiner = active.track("seq").subscribe();
await settle();
tb.producer.abort(new StreamError(StreamCode(64)));
tc.producer.abort(new StreamError(StreamCode(64)));
await settle();
ta.write(1n);
await settle();
expect(drain(joiner)).toContain(1n);
expect(joiner.closed.peek()).toBeUndefined();

first.close();
joiner.close();
disposeC();
close();
});

// A fork joins like any reader arriving before the replacement delivers.
test("a fork made before the replacement delivers keeps the incumbent when the replacement aborts", async () => {
const { a, b, swap, active, close } = await setup();
const ta = copy(a);
const tb = copy(b);
const sub = active.track("seq").subscribe();
ta.write(0n);
expect(drain(sub)).toEqual([0n]);
await swap();
const fork = sub.fork();
await settle();
tb.producer.abort(new StreamError(StreamCode(64)));
await settle();
ta.write(1n);
await settle();
expect(drain(fork)).toContain(1n);
expect(fork.closed.peek()).toBeUndefined();

sub.close();
fork.close();
close();
});

// Only an end some other copy settled cleanly excuses the serving copy's failure.
test("a serving copy that declares an end and then aborts short of it keeps the error", async () => {
const { a, active, close } = await setup();
const ta = copy(a);
const sub = active.track("seq").subscribe();
ta.write(0n, 1, false);
ta.producer.finishAt({ group: 1n, frame: 0 });
const group = await sub.recvGroup();
group?.close();
ta.producer.abort(new StreamError(StreamCode(64)));
await settle();
await expect(sub.recvGroup()).rejects.toThrow("64");

sub.close();
close();
});

// Mirrors `a_replacement_aborted_after_its_answer_keeps_the_incumbent` for a reader awaiting only the end.
test("waiting for the end of a track whose replacement aborts before its first group follows the incumbent", async () => {
const { a, b, swap, active, close } = await setup();
const ta = copy(a);
const tb = copy(b);
const sub = active.track("seq").subscribe();
ta.write(0n);
expect(drain(sub)).toEqual([0n]);

await swap();
const finished = sub.finished();
finished.catch(() => {});
tb.producer.abort(new StreamError(StreamCode(64)));
await settle();
ta.producer.finish();
await expect(finished).resolves.toEqual({ group: 1n, frame: 0 });

sub.close();
close();
});

// The Rust front judges the replacement by its copy, whatever each reader's window took from it:
// one that held a group delivered, so its later abort is the track's verdict for every reader.
test("a replacement that delivered is not undone by a reader whose window skipped its groups", async () => {
const { a, b, swap, active, close } = await setup();
const ta = copy(a);
const tb = copy(b);
const first = active.track("seq").subscribe();
const later = active.track("seq").subscribe({ ranges: [{ start: { absolute: 3n } }] });
ta.write(0n);
expect(drain(first)).toEqual([0n]);
expect(drain(later)).toEqual([]);

await swap();
tb.write(1n);
await settle();
expect(drain(first)).toEqual([1n]);
tb.producer.abort(new StreamError(StreamCode(64)));
await settle();
expect(() => drain(later)).toThrow("64");
ta.write(2n);
await settle();
expect(() => drain(first)).toThrow("64");

first.close();
later.close();
close();
});

test("a replacement that aborts before its first group after the front concludes leaves the incumbent serving", async () => {
const front = new Front();
const a = new BroadcastProducer();
const b = new BroadcastProducer();
const ta = copy(a);
const tb = copy(b);
front.serve(a.consume());
const sub = front.consumer.track("seq").subscribe();
ta.write(0n);
expect(drain(sub)).toEqual([0n]);

front.serve(b.consume());
await settle();
// No front is left to replace the replacement, but the incumbent still feeds the track.
front.conclude();
tb.producer.abort(new StreamError(StreamCode(64)));
await settle();
expect(sub.closed.peek()).toBeUndefined();

ta.write(1n);
await settle();
expect(drain(sub)).toEqual([1n]);
ta.producer.finish();
expect(await sub.recvGroup()).toBeUndefined();
sub.close();
});

test("waiting for the end of a track whose replacement was refused ends with the refusal", async () => {
const { a, b, swap, active, close } = await setup();
const old = a.createTrack("seq", { priority: 1 });
Expand Down
Loading
Loading