| import { describe, expect, test } from "vitest"; |
| import { DEFAULT_MAX_FRAME_LENGTH, encodeFrame, FrameDecoder, FrameError } from "../src/index.ts"; |
|
|
| function concatenate(...chunks: Uint8Array[]): Uint8Array { |
| const result = new Uint8Array(chunks.reduce((length, chunk) => length + chunk.byteLength, 0)); |
| let offset = 0; |
| for (const chunk of chunks) { |
| result.set(chunk, offset); |
| offset += chunk.byteLength; |
| } |
| return result; |
| } |
|
|
| describe("binary framing", () => { |
| test("prefixes payloads with a four-byte big-endian length", () => { |
| expect(encodeFrame(new Uint8Array([0xaa, 0xbb, 0xcc]))).toEqual( |
| new Uint8Array([0x00, 0x00, 0x00, 0x03, 0xaa, 0xbb, 0xcc]), |
| ); |
| expect(encodeFrame(new Uint8Array())).toEqual(new Uint8Array([0, 0, 0, 0])); |
| }); |
|
|
| test("decodes fragmented, coalesced, and empty frames in order", () => { |
| const wire = concatenate( |
| encodeFrame(new Uint8Array([1, 2, 3])), |
| encodeFrame(new Uint8Array()), |
| encodeFrame(new Uint8Array([4])), |
| ); |
| const decoder = new FrameDecoder(); |
| const frames: Uint8Array[] = []; |
| for (const byte of wire) frames.push(...decoder.push(new Uint8Array([byte]))); |
| decoder.end(); |
| expect(frames).toEqual([new Uint8Array([1, 2, 3]), new Uint8Array(), new Uint8Array([4])]); |
|
|
| const coalesced = new FrameDecoder(); |
| expect(coalesced.push(wire)).toEqual(frames); |
| coalesced.end(); |
| }); |
|
|
| test("assembles payloads spanning multiple internal blocks", () => { |
| const payload = Uint8Array.from({ length: 70_000 }, (_, index) => index % 251); |
| const wire = encodeFrame(payload); |
| const decoder = new FrameDecoder(); |
| const frames = [ |
| ...decoder.push(wire.subarray(0, 101)), |
| ...decoder.push(wire.subarray(101, 65_541)), |
| ...decoder.push(wire.subarray(65_541)), |
| ]; |
| decoder.end(); |
| expect(frames).toEqual([payload]); |
| }); |
|
|
| test("handles every split point across a frame", () => { |
| const wire = encodeFrame(new Uint8Array([10, 20, 30, 40])); |
| for (let split = 0; split <= wire.byteLength; split++) { |
| const decoder = new FrameDecoder(); |
| const frames = [...decoder.push(wire.subarray(0, split)), ...decoder.push(wire.subarray(split))]; |
| decoder.end(); |
| expect(frames).toEqual([new Uint8Array([10, 20, 30, 40])]); |
| } |
| }); |
|
|
| test("copies payload bytes instead of retaining or aliasing input chunks", () => { |
| const chunk = encodeFrame(new Uint8Array([1, 2, 3])); |
| const decoder = new FrameDecoder(); |
| const frames = decoder.push(chunk); |
| chunk.fill(9); |
| expect(frames).toEqual([new Uint8Array([1, 2, 3])]); |
| }); |
|
|
| test("accepts empty chunks and a clean empty stream", () => { |
| const decoder = new FrameDecoder(); |
| expect(decoder.push(new Uint8Array())).toEqual([]); |
| expect(() => decoder.end()).not.toThrow(); |
| }); |
|
|
| test.each([ |
| ["partial header", new Uint8Array([0, 0, 0])], |
| ["partial payload", new Uint8Array([0, 0, 0, 2, 1])], |
| ] as const)("rejects a truncated stream at end: %s", (_label, wire) => { |
| const decoder = new FrameDecoder(); |
| expect(decoder.push(wire)).toEqual([]); |
| expect(() => decoder.end()).toThrow(FrameError); |
| }); |
|
|
| test("rejects an oversized declared length as soon as its header is complete", () => { |
| const decoder = new FrameDecoder({ maxFrameLength: 3 }); |
| expect(() => decoder.push(new Uint8Array([0, 0, 0, 4]))).toThrow(/limit/i); |
| expect(() => decoder.push(new Uint8Array([1]))).toThrow(/failed/i); |
| }); |
|
|
| test("accepts a frame exactly at the configured maximum", () => { |
| const decoder = new FrameDecoder({ maxFrameLength: 3 }); |
| expect(decoder.push(encodeFrame(new Uint8Array([1, 2, 3])))).toEqual([new Uint8Array([1, 2, 3])]); |
| decoder.end(); |
| }); |
|
|
| test("cannot be pushed after end", () => { |
| const decoder = new FrameDecoder(); |
| decoder.end(); |
| expect(() => decoder.push(new Uint8Array())).toThrow(/ended/i); |
| expect(() => decoder.end()).toThrow(/ended/i); |
| }); |
|
|
| test.each([-1, 1.5, Number.NaN, DEFAULT_MAX_FRAME_LENGTH * 1_000])( |
| "rejects invalid maximum frame length: %s", |
| (maxFrameLength) => { |
| expect(() => new FrameDecoder({ maxFrameLength })).toThrow(RangeError); |
| }, |
| ); |
| }); |
|
|
