@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 06:00 UTC

main
ts 133 lines 5.13 KB
Raw
1 import type { PrerenderRenderMetadata } from "astro";
2 import { describe, expect, it } from "vitest";
3 import { readFramedPrerenderResponse } from "../prerender-response.ts";
4 import {
5 createFramedPrerenderResponse,
6 PRERENDER_RESPONSE_CONTENT_TYPE,
7 } from "../runtime/utils/prerender-response.ts";
8
9 const metadata = {
10 contentEntryKeys: ["posts/hello-world"],
11 staticImages: [["/_astro/logo.png", { originalSrcPath: "/src/assets/logo.png" }]],
12 referencedImages: ["/src/assets/logo.png"],
13 } as unknown as PrerenderRenderMetadata;
14
15 /** Re-chunk a framed body one byte at a time, so no read lines up with a frame boundary. */
16 const byteByByte = async (response: Response): Promise<Response> => {
17 const bytes = new Uint8Array(await response.arrayBuffer());
18 let index = 0;
19 return new Response(
20 new ReadableStream<Uint8Array>({
21 pull(controller) {
22 if (index < bytes.byteLength) controller.enqueue(bytes.subarray(index, ++index));
23 else controller.close();
24 },
25 }),
26 { headers: response.headers },
27 );
28 };
29
30 /** Frame raw metadata JSON by hand, to feed the reader payloads the writer never produces. */
31 const frame = (json: string, body = new Uint8Array()): Response => {
32 const metadataBytes = new TextEncoder().encode(json);
33 const bytes = new Uint8Array(4 + metadataBytes.byteLength + body.byteLength);
34 new DataView(bytes.buffer).setUint32(0, metadataBytes.byteLength);
35 bytes.set(metadataBytes, 4);
36 bytes.set(body, 4 + metadataBytes.byteLength);
37 return new Response(bytes, { headers: { "Content-Type": PRERENDER_RESPONSE_CONTENT_TYPE } });
38 };
39
40 describe("framed prerender response", () => {
41 it("round-trips status, headers, body, and render metadata", async () => {
42 const framed = createFramedPrerenderResponse(
43 new Response("<h1>about</h1>", {
44 status: 201,
45 statusText: "Created",
46 headers: { "content-type": "text/html", "x-custom": "yes" },
47 }),
48 metadata,
49 );
50 expect(framed.headers.get("Content-Type")).toBe(PRERENDER_RESPONSE_CONTENT_TYPE);
51
52 const { response, metadata: decoded } = await readFramedPrerenderResponse(framed);
53 expect(response.status).toBe(201);
54 expect(response.statusText).toBe("Created");
55 expect(response.headers.get("content-type")).toBe("text/html");
56 expect(response.headers.get("x-custom")).toBe("yes");
57 expect(await response.text()).toBe("<h1>about</h1>");
58 expect(decoded).toEqual(metadata);
59 });
60
61 it("reassembles a frame split across arbitrary chunk boundaries", async () => {
62 const body = new Uint8Array(1024).map((_, index) => index % 256);
63 const framed = await byteByByte(createFramedPrerenderResponse(new Response(body), metadata));
64
65 const { response, metadata: decoded } = await readFramedPrerenderResponse(framed);
66 expect(new Uint8Array(await response.arrayBuffer())).toEqual(body);
67 expect(decoded).toEqual(metadata);
68 });
69
70 it("carries a body-less response without metadata", async () => {
71 const framed = createFramedPrerenderResponse(new Response(null, { status: 204 }), undefined);
72
73 const { response, metadata: decoded } = await readFramedPrerenderResponse(framed);
74 expect(response.status).toBe(204);
75 expect(response.body).toBeNull();
76 expect(decoded).toBeUndefined();
77 });
78
79 it("rejects a response that is not framed", async () => {
80 await expect(readFramedPrerenderResponse(new Response("<h1>about</h1>"))).rejects.toThrow(
81 "The prerender response is not framed.",
82 );
83 });
84
85 it("rejects a failed transport response", async () => {
86 await expect(
87 readFramedPrerenderResponse(new Response("boom", { status: 500 })),
88 ).rejects.toThrow("The framed prerender request failed (500");
89 });
90
91 it("rejects a frame that ends before its metadata", async () => {
92 const truncated = new Uint8Array(await frame('{"status":200}').arrayBuffer()).subarray(0, 8);
93 await expect(
94 readFramedPrerenderResponse(
95 new Response(truncated, { headers: { "Content-Type": PRERENDER_RESPONSE_CONTENT_TYPE } }),
96 ),
97 ).rejects.toThrow("The framed prerender response ended unexpectedly.");
98 });
99
100 it("rejects a zero metadata length", async () => {
101 await expect(readFramedPrerenderResponse(frame(""))).rejects.toThrow(
102 "The framed prerender response metadata length is invalid.",
103 );
104 });
105
106 it("rejects metadata that is not JSON", async () => {
107 await expect(readFramedPrerenderResponse(frame("not json"))).rejects.toThrow();
108 });
109
110 it("rejects an out-of-range status", async () => {
111 await expect(
112 readFramedPrerenderResponse(
113 frame(JSON.stringify({ status: 700, statusText: "", headers: [], hasBody: false })),
114 ),
115 ).rejects.toThrow();
116 });
117
118 it("rejects malformed headers", async () => {
119 await expect(
120 readFramedPrerenderResponse(
121 frame(JSON.stringify({ status: 200, statusText: "", headers: [["x"]], hasBody: false })),
122 ),
123 ).rejects.toThrow();
124 });
125
126 it("rejects a body on a null-body status", async () => {
127 await expect(
128 readFramedPrerenderResponse(
129 frame(JSON.stringify({ status: 304, statusText: "", headers: [], hasBody: true })),
130 ),
131 ).rejects.toThrow("a null-body status cannot carry a body");
132 });
133 });