wrangler 0.0.0-e7a0cd5b → 0.0.0-e87ad068

package/src/__tests__/pages/project-list.test.ts

@@ -0,0 +1,110 @@
+import { rest } from "msw";
+import { endEventLoop } from "../helpers/end-event-loop";
+import { mockConsoleMethods } from "../helpers/mock-console";
+import { mockAccountId, mockApiToken } from "./../helpers/mock-account-id";
+import { msw } from "./../helpers/msw";
+import { runInTempDir } from "./../helpers/run-in-tmp";
+import { runWrangler } from "./../helpers/run-wrangler";
+import type { Project } from "./../../pages/types";
+
+describe("project list", () => {
+	runInTempDir();
+	mockConsoleMethods();
+	mockAccountId();
+	mockApiToken();
+
+	afterEach(async () => {
+		// Force a tick to ensure that all promises resolve
+		await endEventLoop();
+		// Reset MSW after tick to ensure that all requests have been handled
+		msw.resetHandlers();
+		msw.restoreHandlers();
+	});
+
+	it("should make request to list projects", async () => {
+		const projects: Project[] = [
+			{
+				name: "dogs",
+				subdomain: "docs.pages.dev",
+				domains: ["dogs.pages.dev"],
+				source: {
+					type: "github",
+				},
+				latest_deployment: {
+					modified_on: "2021-11-17T14:52:26.133835Z",
+				},
+				created_on: "2021-11-17T14:52:26.133835Z",
+				production_branch: "main",
+			},
+			{
+				name: "cats",
+				subdomain: "cats.pages.dev",
+				domains: ["cats.pages.dev", "kitten.com"],
+				latest_deployment: {
+					modified_on: "2021-11-17T14:52:26.133835Z",
+				},
+				created_on: "2021-11-17T14:52:26.133835Z",
+				production_branch: "main",
+			},
+		];
+
+		const requests = mockProjectListRequest(projects);
+		await runWrangler("pages project list");
+
+		expect(requests.count).toBe(1);
+	});
+
+	it("should make multiple requests for paginated results", async () => {
+		const projects: Project[] = [];
+		for (let i = 0; i < 15; i++) {
+			projects.push({
+				name: "dogs" + i,
+				subdomain: i + "dogs.pages.dev",
+				domains: [i + "dogs.pages.dev"],
+				source: {
+					type: "github",
+				},
+				latest_deployment: {
+					modified_on: "2021-11-17T14:52:26.133835Z",
+				},
+				created_on: "2021-11-17T14:52:26.133835Z",
+				production_branch: "main",
+			});
+		}
+		const requests = mockProjectListRequest(projects);
+		await runWrangler("pages project list");
+		expect(requests.count).toEqual(2);
+	});
+});
+
+/* -------------------------------------------------- */
+/*                    Helper Functions                */
+/* -------------------------------------------------- */
+
+function mockProjectListRequest(projects: unknown[]) {
+	const requests = { count: 0 };
+	msw.use(
+		rest.get("*/accounts/:accountId/pages/projects", async (req, res, ctx) => {
+			requests.count++;
+			const pageSize = Number(req.url.searchParams.get("per_page"));
+			const page = Number(req.url.searchParams.get("page"));
+			const expectedPageSize = 10;
+			const expectedPage = requests.count;
+			expect(req.params.accountId).toEqual("some-account-id");
+			expect(pageSize).toEqual(expectedPageSize);
+			expect(page).toEqual(expectedPage);
+			expect(await req.text()).toEqual("");
+
+			return res(
+				ctx.status(200),
+				ctx.json({
+					success: true,
+					errors: [],
+					messages: [],
+					result: projects.slice((page - 1) * pageSize, page * pageSize),
+				})
+			);
+		})
+	);
+	return requests;
+}

package/src/__tests__/pages/project-upload.test.ts

@@ -0,0 +1,500 @@
+// /* eslint-disable no-shadow */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { rest } from "msw";
+import { endEventLoop } from "../helpers/end-event-loop";
+import { mockAccountId, mockApiToken } from "../helpers/mock-account-id";
+import { mockConsoleMethods } from "../helpers/mock-console";
+import { mockGetUploadTokenRequest } from "../helpers/mock-get-pages-upload-token";
+import { mockSetTimeout } from "../helpers/mock-set-timeout";
+import { msw } from "../helpers/msw";
+import { runInTempDir } from "../helpers/run-in-tmp";
+import { runWrangler } from "../helpers/run-wrangler";
+import type { UploadPayloadFile } from "../../pages/types";
+import type { RestRequest } from "msw";
+
+describe("project upload", () => {
+	const ENV_COPY = process.env;
+	const std = mockConsoleMethods();
+
+	runInTempDir();
+	mockAccountId();
+	mockApiToken();
+	mockSetTimeout();
+
+	beforeEach(() => {
+		process.env.CI = "true";
+		process.env.CF_PAGES_UPLOAD_JWT = "<<funfetti-auth-jwt>>";
+	});
+
+	afterEach(async () => {
+		process.env = ENV_COPY;
+
+		// Force a tick to ensure that all promises resolve
+		await endEventLoop();
+		// Reset MSW after tick to ensure that all requests have been handled
+		msw.resetHandlers();
+		msw.restoreHandlers();
+	});
+
+	it("should upload a directory of files with a provided JWT", async () => {
+		writeFileSync("logo.png", "foobar");
+
+		msw.use(
+			rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+				const body = (await req.json()) as {
+					hashes: string[];
+				};
+
+				expect(req.headers.get("Authorization")).toBe(
+					"Bearer <<funfetti-auth-jwt>>"
+				);
+				expect(body).toMatchObject({
+					hashes: ["2082190357cfd3617ccfe04f340c6247"],
+				});
+
+				return res.once(
+					ctx.status(200),
+					ctx.json({
+						success: true,
+						errors: [],
+						messages: [],
+						result: body.hashes,
+					})
+				);
+			}),
+			rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+				expect(req.headers.get("Authorization")).toBe(
+					"Bearer <<funfetti-auth-jwt>>"
+				);
+
+				expect(await req.json()).toMatchObject([
+					{
+						base64: true,
+						key: "2082190357cfd3617ccfe04f340c6247",
+						metadata: {
+							contentType: "image/png",
+						},
+						value: "Zm9vYmFy",
+					},
+				]);
+
+				return res(
+					ctx.status(200),
+					ctx.json({
+						success: true,
+						errors: [],
+						messages: [],
+						result: null,
+					})
+				);
+			})
+		);
+
+		await runWrangler("pages project upload .");
+
+		expect(normalizeProgressSteps(std.out)).toMatchInlineSnapshot(`
+		"✨ Success! Uploaded 1 files (TIMINGS)
+
+		✨ Upload complete!"
+	`);
+	});
+
+	it("should avoid uploading some files", async () => {
+		mkdirSync("some_dir/node_modules", { recursive: true });
+		mkdirSync("some_dir/functions", { recursive: true });
+
+		writeFileSync("logo.png", "foobar");
+		writeFileSync("some_dir/functions/foo.js", "func");
+		writeFileSync("some_dir/_headers", "headersfile");
+
+		writeFileSync("_headers", "headersfile");
+		writeFileSync("_redirects", "redirectsfile");
+		writeFileSync("_worker.js", "workerfile");
+		writeFileSync("_routes.json", "routesfile");
+		mkdirSync(".git");
+		writeFileSync(".git/foo", "gitfile");
+		writeFileSync("some_dir/node_modules/some_package", "nodefile");
+		mkdirSync("functions");
+		writeFileSync("functions/foo.js", "func");
+
+		// Accumulate multiple requests then assert afterwards
+		const requests: RestRequest[] = [];
+		msw.use(
+			rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+				const body = (await req.json()) as {
+					hashes: string[];
+				};
+
+				expect(req.headers.get("Authorization")).toBe(
+					"Bearer <<funfetti-auth-jwt>>"
+				);
+				expect(body).toMatchObject({
+					hashes: [
+						"2082190357cfd3617ccfe04f340c6247",
+						"95dedb64e6d4940fc2e0f11f711cc2f4",
+						"09a79777abda8ccc8bdd51dd3ff8e9e9",
+					],
+				});
+
+				return res.once(
+					ctx.status(200),
+					ctx.json({
+						success: true,
+						errors: [],
+						messages: [],
+						result: body.hashes,
+					})
+				);
+			}),
+			rest.post("*/pages/assets/upload", (req, res, ctx) => {
+				requests.push(req);
+
+				return res(
+					ctx.status(200),
+					ctx.json({
+						success: true,
+						errors: [],
+						messages: [],
+						result: null,
+					})
+				);
+			})
+		);
+
+		await runWrangler("pages project upload .");
+		expect(requests.length).toBe(3);
+
+		const resolvedRequests = (
+			await Promise.all(
+				requests.map(async (req) => await req.json<UploadPayloadFile[]>())
+			)
+		).flat();
+
+		const requestMap = resolvedRequests.reduce<{
+			[key: string]: UploadPayloadFile;
+		}>((map, req) => Object.assign(map, { [req.key]: req }), {});
+
+		for (const req of requests) {
+			expect(req.headers.get("Authorization")).toBe(
+				"Bearer <<funfetti-auth-jwt>>"
+			);
+		}
+
+		expect(Object.keys(requestMap).length).toBe(3);
+
+		expect(requestMap["95dedb64e6d4940fc2e0f11f711cc2f4"]).toMatchObject({
+			base64: true,
+			key: "95dedb64e6d4940fc2e0f11f711cc2f4",
+			metadata: {
+				contentType: "application/octet-stream",
+			},
+			value: "aGVhZGVyc2ZpbGU=",
+		});
+
+		expect(requestMap["2082190357cfd3617ccfe04f340c6247"]).toMatchObject({
+			base64: true,
+			key: "2082190357cfd3617ccfe04f340c6247",
+			metadata: {
+				contentType: "image/png",
+			},
+			value: "Zm9vYmFy",
+		});
+
+		expect(requestMap["09a79777abda8ccc8bdd51dd3ff8e9e9"]).toMatchObject({
+			base64: true,
+			key: "09a79777abda8ccc8bdd51dd3ff8e9e9",
+			metadata: {
+				contentType: "application/javascript",
+			},
+			value: "ZnVuYw==",
+		});
+
+		expect(normalizeProgressSteps(std.out)).toMatchInlineSnapshot(`
+		"✨ Success! Uploaded 3 files (TIMINGS)
+
+		✨ Upload complete!"
+	`);
+	});
+
+	it("should retry uploads", async () => {
+		writeFileSync("logo.txt", "foobar");
+
+		// Accumulate multiple requests then assert afterwards
+		const requests: RestRequest[] = [];
+		msw.use(
+			rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+				const body = (await req.json()) as { hashes: string[] };
+
+				expect(req.headers.get("Authorization")).toBe(
+					"Bearer <<funfetti-auth-jwt>>"
+				);
+				expect(body).toMatchObject({
+					hashes: ["1a98fb08af91aca4a7df1764a2c4ddb0"],
+				});
+
+				return res.once(
+					ctx.status(200),
+					ctx.json({
+						success: true,
+						errors: [],
+						messages: [],
+						result: body.hashes,
+					})
+				);
+			}),
+			rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+				requests.push(req);
+
+				if (requests.length < 2) {
+					return res(
+						ctx.status(200),
+						ctx.json({
+							success: false,
+							errors: [
+								{
+									code: 800000,
+									message: "Something exploded, please retry",
+								},
+							],
+							messages: [],
+							result: null,
+						})
+					);
+				} else {
+					return res(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: null,
+						})
+					);
+				}
+			})
+		);
+
+		await runWrangler("pages project upload .");
+
+		// Assert two identical requests
+		expect(requests.length).toBe(2);
+		for (const init of requests) {
+			expect(init.headers.get("Authorization")).toBe(
+				"Bearer <<funfetti-auth-jwt>>"
+			);
+
+			const body = (await init.json()) as UploadPayloadFile[];
+			expect(body).toMatchObject([
+				{
+					key: "1a98fb08af91aca4a7df1764a2c4ddb0",
+					value: Buffer.from("foobar").toString("base64"),
+					metadata: {
+						contentType: "text/plain",
+					},
+					base64: true,
+				},
+			]);
+		}
+
+		expect(normalizeProgressSteps(std.out)).toMatchInlineSnapshot(`
+		"✨ Success! Uploaded 1 files (TIMINGS)
+
+		✨ Upload complete!"
+	`);
+	});
+
+	it("should try to use multiple buckets (up to the max concurrency)", async () => {
+		writeFileSync("logo.txt", "foobar");
+		writeFileSync("logo.png", "foobar");
+		writeFileSync("logo.html", "foobar");
+		writeFileSync("logo.js", "foobar");
+
+		mockGetUploadTokenRequest(
+			"<<funfetti-auth-jwt>>",
+			"some-account-id",
+			"foo"
+		);
+
+		// Accumulate multiple requests then assert afterwards
+		const requests: RestRequest[] = [];
+		msw.use(
+			rest.post("*/pages/assets/check-missing", async (req, res, ctx) => {
+				const body = (await req.json()) as { hashes: string[] };
+
+				expect(req.headers.get("Authorization")).toBe(
+					"Bearer <<funfetti-auth-jwt>>"
+				);
+				expect(body).toMatchObject({
+					hashes: expect.arrayContaining([
+						"d96fef225537c9f5e44a3cb27fd0b492",
+						"2082190357cfd3617ccfe04f340c6247",
+						"6be321bef99e758250dac034474ddbb8",
+						"1a98fb08af91aca4a7df1764a2c4ddb0",
+					]),
+				});
+
+				return res.once(
+					ctx.status(200),
+					ctx.json({
+						success: true,
+						errors: [],
+						messages: [],
+						result: body.hashes,
+					})
+				);
+			}),
+			rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+				requests.push(req);
+
+				expect(req.headers.get("Authorization")).toBe(
+					"Bearer <<funfetti-auth-jwt>>"
+				);
+
+				return res(
+					ctx.status(200),
+					ctx.json({
+						success: true,
+						errors: [],
+						messages: [],
+						result: null,
+					})
+				);
+			})
+		);
+
+		await runWrangler("pages project upload .");
+
+		// We have 3 buckets, so expect 3 uploads
+		expect(requests.length).toBe(3);
+		const bodies: UploadPayloadFile[][] = [];
+		for (const init of requests) {
+			bodies.push((await init.json()) as UploadPayloadFile[]);
+		}
+		// One bucket should end up with 2 files
+		expect(bodies.map((b) => b.length).sort()).toEqual([1, 1, 2]);
+		// But we don't know the order, so flatten and test without ordering
+		expect(bodies.flatMap((b) => b)).toEqual(
+			expect.arrayContaining([
+				{
+					base64: true,
+					key: "d96fef225537c9f5e44a3cb27fd0b492",
+					metadata: { contentType: "text/html" },
+					value: "Zm9vYmFy",
+				},
+				{
+					base64: true,
+					key: "1a98fb08af91aca4a7df1764a2c4ddb0",
+					metadata: { contentType: "text/plain" },
+					value: "Zm9vYmFy",
+				},
+				{
+					base64: true,
+					key: "6be321bef99e758250dac034474ddbb8",
+					metadata: { contentType: "application/javascript" },
+					value: "Zm9vYmFy",
+				},
+				{
+					base64: true,
+					key: "2082190357cfd3617ccfe04f340c6247",
+					metadata: { contentType: "image/png" },
+					value: "Zm9vYmFy",
+				},
+			])
+		);
+
+		expect(normalizeProgressSteps(std.out)).toMatchInlineSnapshot(`
+		"✨ Success! Uploaded 4 files (TIMINGS)
+
+		✨ Upload complete!"
+	`);
+	});
+
+	it("should not error when directory names contain periods and houses a extensionless file", async () => {
+		mkdirSync(".well-known");
+		// Note: same content as previous test, but since it's a different extension,
+		// it hashes to a different value
+		writeFileSync(".well-known/foobar", "foobar");
+
+		mockGetUploadTokenRequest(
+			"<<funfetti-auth-jwt>>",
+			"some-account-id",
+			"foo"
+		);
+
+		msw.use(
+			rest.post(
+				"*/pages/assets/check-missing",
+
+				async (req, res, ctx) => {
+					const body = (await req.json()) as { hashes: string[] };
+
+					expect(req.headers.get("Authorization")).toBe(
+						"Bearer <<funfetti-auth-jwt>>"
+					);
+					expect(body).toMatchObject({
+						hashes: ["7b764dacfd211bebd8077828a7ddefd7"],
+					});
+
+					return res.once(
+						ctx.status(200),
+						ctx.json({
+							success: true,
+							errors: [],
+							messages: [],
+							result: body.hashes,
+						})
+					);
+				}
+			),
+			rest.post("*/pages/assets/upload", async (req, res, ctx) => {
+				expect(req.headers.get("Authorization")).toBe(
+					"Bearer <<funfetti-auth-jwt>>"
+				);
+				const body = (await req.json()) as UploadPayloadFile[];
+				expect(body).toMatchObject([
+					{
+						key: "7b764dacfd211bebd8077828a7ddefd7",
+						value: Buffer.from("foobar").toString("base64"),
+						metadata: {
+							contentType: "application/octet-stream",
+						},
+						base64: true,
+					},
+				]);
+
+				return res.once(
+					ctx.status(200),
+					ctx.json({
+						success: true,
+						errors: [],
+						messages: [],
+						result: null,
+					})
+				);
+			})
+		);
+
+		await runWrangler("pages project upload .");
+
+		expect(std.err).toMatchInlineSnapshot(`""`);
+	});
+});
+
+/**
+ * When uploading assets we print out progress messages that look like:
+ *
+ * Uploading... (1/4)
+ * Uploading... (2/4)
+ * Uploading... (4/4)
+ *
+ * Note that we don't always get a progress message for every item uploaded.
+ * These upload counts are not deterministic and can change from test run to test run.
+ *
+ * Also if you run the tests in --runInBand mode then we never see any of
+ * these progress messages in the tests!!
+ *
+ * So this helper removes these message from the snapshots to keep them consistent.
+ */
+export function normalizeProgressSteps(str: string): string {
+	return str.replace(/Uploading... \(\d\/\d\)\r?\n?/g, "");
+}