The best way to control Claude Code, Codex and more from any computer or phone
| 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 | }); |