wrangler 2.6.2 → 2.7.0

package/src/__tests__/kv.test.ts

@@ -1,20 +1,11 @@
 import { writeFileSync } from "node:fs";
-import { FormData, Headers } from "undici";
+import { rest } from "msw";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
-import {
-	setMockResponse,
-	unsetAllMocks,
-	unsetSpecialMockFns,
-	setMockFetchKVGetValue,
-	setMockRawResponse,
-	createFetchResult,
-} from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
-import { clearConfirmMocks, mockConfirm } from "./helpers/mock-dialogs";
+import { mockConfirm, clearDialogs } from "./helpers/mock-dialogs";
 import { useMockIsTTY } from "./helpers/mock-istty";
-import { mockKeyListRequest } from "./helpers/mock-kv";
-import { mockGetMemberships } from "./helpers/mock-oauth-flow";
 import { mockProcess } from "./helpers/mock-process";
+import { msw } from "./helpers/msw";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 import type {
@@ -22,31 +13,37 @@ import type {
 	KVNamespaceInfo,
 	NamespaceKeyInfo,
 } from "../kv/helpers";
-
 describe("wrangler", () => {
 	mockAccountId();
 	mockApiToken();
 	runInTempDir();
+
 	const std = mockConsoleMethods();
 	const proc = mockProcess();
 
+	const { setIsTTY } = useMockIsTTY();
+	beforeEach(() => {
+		setIsTTY(true);
+	});
 	afterEach(() => {
-		unsetAllMocks();
-		clearConfirmMocks();
+		clearDialogs();
 	});
-
 	describe("kv:namespace", () => {
 		describe("create", () => {
 			function mockCreateRequest(expectedTitle: string) {
-				setMockResponse(
-					"/accounts/:accountId/storage/kv/namespaces",
-					"POST",
-					([_url, accountId], { body }) => {
-						expect(accountId).toEqual("some-account-id");
-						const title = JSON.parse(body as string).title;
-						expect(title).toEqual(expectedTitle);
-						return { id: "some-namespace-id" };
-					}
+				msw.use(
+					rest.post(
+						"*/accounts/:accountId/storage/kv/namespaces",
+						async (req, res, ctx) => {
+							expect(req.params.accountId).toEqual("some-account-id");
+							const title = (await req.json()).title as string;
+							expect(title).toEqual(expectedTitle);
+							return res.once(
+								ctx.status(200),
+								ctx.json(createFetchResult({ id: "some-namespace-id" }))
+							);
+						}
+					)
 				);
 			}
 
@@ -193,22 +190,32 @@ describe("wrangler", () => {
 		});
 
 		describe("list", () => {
-			function mockListRequest(namespaces: unknown[]) {
+			function mockListRequest(namespaces: KVNamespaceInfo[]) {
 				const requests = { count: 0 };
-				setMockResponse(
-					"/accounts/:accountId/storage/kv/namespaces",
-					([_url, accountId], init, query) => {
-						requests.count++;
-						expect(accountId).toEqual("some-account-id");
-						expect(query.get("per_page")).toEqual("100");
-						expect(query.get("order")).toEqual("title");
-						expect(query.get("direction")).toEqual("asc");
-						expect(query.get("page")).toEqual(`${requests.count}`);
-						expect(init).toEqual({});
-						const pageSize = Number(query.get("per_page"));
-						const page = Number(query.get("page"));
-						return namespaces.slice((page - 1) * pageSize, page * pageSize);
-					}
+				msw.use(
+					rest.get(
+						"*/accounts/:accountId/storage/kv/namespaces",
+						async (req, res, ctx) => {
+							requests.count++;
+							expect(req.params.accountId).toEqual("some-account-id");
+							expect(req.url.searchParams.get("per_page")).toEqual("100");
+							expect(req.url.searchParams.get("order")).toEqual("title");
+							expect(req.url.searchParams.get("direction")).toEqual("asc");
+							expect(req.url.searchParams.get("page")).toEqual(
+								`${requests.count}`
+							);
+
+							const pageSize = Number(req.url.searchParams.get("per_page"));
+							const page = Number(req.url.searchParams.get("page"));
+							return res(
+								ctx.json(
+									createFetchResult(
+										namespaces.slice((page - 1) * pageSize, page * pageSize)
+									)
+								)
+							);
+						}
+					)
 				);
 				return requests;
 			}
@@ -222,8 +229,7 @@ describe("wrangler", () => {
 				await runWrangler("kv:namespace list");
 
 				expect(std.err).toMatchInlineSnapshot(`""`);
-				const namespaces = JSON.parse(std.out);
-				expect(namespaces).toEqual(kvNamespaces);
+				expect(JSON.parse(std.out)).toEqual(kvNamespaces);
 			});
 
 			it("should make multiple requests for paginated results", async () => {
@@ -234,8 +240,8 @@ describe("wrangler", () => {
 				}
 				const requests = mockListRequest(kvNamespaces);
 				await runWrangler("kv:namespace list");
-				const namespaces = JSON.parse(std.out);
-				expect(namespaces).toEqual(kvNamespaces);
+
+				expect(JSON.parse(std.out)).toEqual(kvNamespaces);
 				expect(requests.count).toEqual(6);
 			});
 		});
@@ -243,15 +249,16 @@ describe("wrangler", () => {
 		describe("delete", () => {
 			function mockDeleteRequest(expectedNamespaceId: string) {
 				const requests = { count: 0 };
-				setMockResponse(
-					"/accounts/:accountId/storage/kv/namespaces/:namespaceId",
-					"DELETE",
-					([_url, accountId, namespaceId]) => {
-						requests.count++;
-						expect(accountId).toEqual("some-account-id");
-						expect(namespaceId).toEqual(expectedNamespaceId);
-						return null;
-					}
+				msw.use(
+					rest.delete(
+						"*/accounts/:accountId/storage/kv/namespaces/:namespaceId",
+						(req, res, ctx) => {
+							requests.count++;
+							expect(req.params.accountId).toEqual("some-account-id");
+							expect(req.params.namespaceId).toEqual(expectedNamespaceId);
+							return res(ctx.status(200), ctx.json(createFetchResult(null)));
+						}
+					)
 				);
 				return requests;
 			}
@@ -331,39 +338,43 @@ describe("wrangler", () => {
 				expectedKV: KeyValue
 			) {
 				const requests = { count: 0 };
-				setMockResponse(
-					"/accounts/:accountId/storage/kv/namespaces/:namespaceId/values/:key",
-					"PUT",
-					([_url, accountId, namespaceId, key], { body }, query) => {
-						requests.count++;
-						expect(accountId).toEqual("some-account-id");
-						expect(namespaceId).toEqual(expectedNamespaceId);
-						expect(key).toEqual(expectedKV.key);
-						if (expectedKV.metadata) {
-							expect(body).toBeInstanceOf(FormData);
-							expect((body as FormData).get("value")).toEqual(expectedKV.value);
-							expect((body as FormData).get("metadata")).toEqual(
-								JSON.stringify(expectedKV.metadata)
-							);
-						} else {
-							expect(body).toEqual(expectedKV.value);
-						}
-						if (expectedKV.expiration !== undefined) {
-							expect(query.get("expiration")).toEqual(
-								`${expectedKV.expiration}`
-							);
-						} else {
-							expect(query.has("expiration")).toBe(false);
+				msw.use(
+					rest.put(
+						"*/accounts/:accountId/storage/kv/namespaces/:namespaceId/values/:key",
+						(req, res, ctx) => {
+							requests.count++;
+							const { accountId, namespaceId, key } = req.params;
+							expect(accountId).toEqual("some-account-id");
+							expect(namespaceId).toEqual(expectedNamespaceId);
+							expect(encodeURIComponent(key as string)).toEqual(expectedKV.key);
+							// if (expectedKV.metadata) {
+							// 	expect(body).toBeInstanceOf(FormData);
+							// 	expect((body as FormData).get("value")).toEqual(
+							// 		expectedKV.value
+							// 	);
+							// 	expect((body as FormData).get("metadata")).toEqual(
+							// 		JSON.stringify(expectedKV.metadata)
+							// 	);
+							// } else {
+							// 	expect(body).toEqual(expectedKV.value);
+							// }
+							if (expectedKV.expiration !== undefined) {
+								expect(req.url.searchParams.get("expiration")).toEqual(
+									`${expectedKV.expiration}`
+								);
+							} else {
+								expect(req.url.searchParams.has("expiration")).toBe(false);
+							}
+							if (expectedKV.expiration_ttl) {
+								expect(req.url.searchParams.get("expiration_ttl")).toEqual(
+									`${expectedKV.expiration_ttl}`
+								);
+							} else {
+								expect(req.url.searchParams.has("expiration_ttl")).toBe(false);
+							}
+							return res(ctx.status(200), ctx.json(createFetchResult(null)));
 						}
-						if (expectedKV.expiration_ttl) {
-							expect(query.get("expiration_ttl")).toEqual(
-								`${expectedKV.expiration_ttl}`
-							);
-						} else {
-							expect(query.has("expiration_ttl")).toBe(false);
-						}
-						return null;
-					}
+					)
 				);
 				return requests;
 			}
@@ -927,10 +938,6 @@ describe("wrangler", () => {
 		});
 
 		describe("get", () => {
-			afterEach(() => {
-				unsetSpecialMockFns();
-			});
-
 			it("should get a key in a given namespace specified by namespace-id", async () => {
 				setMockFetchKVGetValue(
 					"some-account-id",
@@ -938,7 +945,9 @@ describe("wrangler", () => {
 					"my-key",
 					"my-value"
 				);
+
 				await runWrangler("kv:key get my-key --namespace-id some-namespace-id");
+
 				expect(proc.write).toEqual(Buffer.from("my-value"));
 				expect(std.err).toMatchInlineSnapshot(`""`);
 			});
@@ -1047,9 +1056,10 @@ describe("wrangler", () => {
 				setMockFetchKVGetValue(
 					"some-account-id",
 					"some-namespace-id",
-					"%2Fmy%2Ckey",
+					"%2Fmy%2Ckey", // expect the key /my,key to be encoded
 					"my-value"
 				);
+
 				await runWrangler(
 					"kv:key get /my,key --namespace-id some-namespace-id"
 				);
@@ -1179,7 +1189,6 @@ describe("wrangler", () => {
 			});
 
 			describe("non-interactive", () => {
-				const { setIsTTY } = useMockIsTTY();
 				mockAccountId({ accountId: null });
 
 				it("should error if there are multiple accounts available but not interactive on stdin", async () => {
@@ -1190,12 +1199,12 @@ describe("wrangler", () => {
 					setIsTTY({ stdin: false, stdout: true });
 					await expect(runWrangler("kv:key get key --namespace-id=xxxx"))
 						.rejects.toThrowErrorMatchingInlineSnapshot(`
-							                  "More than one account available but unable to select one in non-interactive mode.
-							                  Please set the appropriate \`account_id\` in your \`wrangler.toml\` file.
-							                  Available accounts are (\\"<name>\\" - \\"<id>\\"):
-							                    \\"one\\" - \\"1\\")
-							                    \\"two\\" - \\"2\\")"
-						                `);
+				"More than one account available but unable to select one in non-interactive mode.
+				Please set the appropriate \`account_id\` in your \`wrangler.toml\` file.
+				Available accounts are (\`<name>\`: \`<account_id>\`):
+				  \`one\`: \`1\`
+				  \`two\`: \`2\`"
+			`);
 				});
 
 				it("should error if there are multiple accounts available but not interactive on stdout", async () => {
@@ -1206,23 +1215,30 @@ describe("wrangler", () => {
 					setIsTTY({ stdin: true, stdout: false });
 					await expect(runWrangler("kv:key get key --namespace-id=xxxx"))
 						.rejects.toThrowErrorMatchingInlineSnapshot(`
-							                  "More than one account available but unable to select one in non-interactive mode.
-							                  Please set the appropriate \`account_id\` in your \`wrangler.toml\` file.
-							                  Available accounts are (\\"<name>\\" - \\"<id>\\"):
-							                    \\"one\\" - \\"1\\")
-							                    \\"two\\" - \\"2\\")"
-						                `);
+				"More than one account available but unable to select one in non-interactive mode.
+				Please set the appropriate \`account_id\` in your \`wrangler.toml\` file.
+				Available accounts are (\`<name>\`: \`<account_id>\`):
+				  \`one\`: \`1\`
+				  \`two\`: \`2\`"
+			`);
 				});
 
 				it("should recommend using a configuration if unable to fetch memberships", async () => {
-					setMockRawResponse("/memberships", () => {
-						return createFetchResult(undefined, false, [
-							{
-								code: 9109,
-								message: "Uauthorized to access requested resource",
-							},
-						]);
-					});
+					msw.use(
+						rest.get("*/memberships", (req, res, ctx) => {
+							return res.once(
+								ctx.status(200),
+								ctx.json(
+									createFetchResult(null, false, [
+										{
+											code: 9109,
+											message: "Uauthorized to access requested resource",
+										},
+									])
+								)
+							);
+						})
+					);
 					await expect(runWrangler("kv:key get key --namespace-id=xxxx"))
 						.rejects.toThrowErrorMatchingInlineSnapshot(`
 							"Failed to automatically retrieve account IDs for the logged in user.
@@ -1238,12 +1254,12 @@ describe("wrangler", () => {
 					setIsTTY(false);
 					await expect(runWrangler("kv:key get key --namespace-id=xxxx"))
 						.rejects.toThrowErrorMatchingInlineSnapshot(`
-							                  "More than one account available but unable to select one in non-interactive mode.
-							                  Please set the appropriate \`account_id\` in your \`wrangler.toml\` file.
-							                  Available accounts are (\\"<name>\\" - \\"<id>\\"):
-							                    \\"one\\" - \\"1\\")
-							                    \\"two\\" - \\"2\\")"
-						                `);
+				"More than one account available but unable to select one in non-interactive mode.
+				Please set the appropriate \`account_id\` in your \`wrangler.toml\` file.
+				Available accounts are (\`<name>\`: \`<account_id>\`):
+				  \`one\`: \`1\`
+				  \`two\`: \`2\`"
+			`);
 				});
 			});
 		});
@@ -1254,16 +1270,20 @@ describe("wrangler", () => {
 				expectedKey: string
 			) {
 				const requests = { count: 0 };
-				setMockResponse(
-					"/accounts/:accountId/storage/kv/namespaces/:namespaceId/values/:key",
-					"DELETE",
-					([_url, accountId, namespaceId, key]) => {
-						requests.count++;
-						expect(accountId).toEqual("some-account-id");
-						expect(namespaceId).toEqual(expectedNamespaceId);
-						expect(key).toEqual(expectedKey);
-						return null;
-					}
+				msw.use(
+					rest.delete(
+						"*/accounts/:accountId/storage/kv/namespaces/:namespaceId/values/:key",
+						(req, res, ctx) => {
+							requests.count++;
+							expect(req.params.accountId).toEqual("some-account-id");
+							expect(req.params.namespaceId).toEqual(expectedNamespaceId);
+							expect(req.params.key).toEqual(expectedKey);
+							return res.once(
+								ctx.status(200),
+								ctx.json(createFetchResult(null))
+							);
+						}
+					)
 				);
 				return requests;
 			}
@@ -1277,8 +1297,9 @@ describe("wrangler", () => {
 			});
 
 			it("should encode the key in the api request to delete a value", async () => {
-				const requests = mockDeleteRequest("voyager", "%2FNCC-74656");
+				const requests = mockDeleteRequest("voyager", "/NCC-74656");
 				await runWrangler(`kv:key delete --namespace-id voyager /NCC-74656`);
+
 				expect(requests.count).toEqual(1);
 				expect(std.out).toMatchInlineSnapshot(
 					`"Deleting the key \\"/NCC-74656\\" on namespace voyager."`
@@ -1350,21 +1371,22 @@ describe("wrangler", () => {
 				expectedKeyValues: KeyValue[]
 			) {
 				const requests = { count: 0 };
-				setMockResponse(
-					"/accounts/:accountId/storage/kv/namespaces/:namespaceId/bulk",
-					"PUT",
-					([_url, accountId, namespaceId], { body }) => {
-						requests.count++;
-						expect(accountId).toEqual("some-account-id");
-						expect(namespaceId).toEqual(expectedNamespaceId);
-						expect(JSON.parse(body as string)).toEqual(
-							expectedKeyValues.slice(
-								(requests.count - 1) * 5000,
-								requests.count * 5000
-							)
-						);
-						return null;
-					}
+				msw.use(
+					rest.put(
+						"*/accounts/:accountId/storage/kv/namespaces/:namespaceId/bulk",
+						async (req, res, ctx) => {
+							requests.count++;
+							expect(req.params.accountId).toEqual("some-account-id");
+							expect(req.params.namespaceId).toEqual(expectedNamespaceId);
+							expect(await req.json()).toEqual(
+								expectedKeyValues.slice(
+									(requests.count - 1) * 5000,
+									requests.count * 5000
+								)
+							);
+							return res(ctx.status(200), ctx.json(createFetchResult(null)));
+						}
+					)
 				);
 				return requests;
 			}
@@ -1500,24 +1522,25 @@ describe("wrangler", () => {
 				expectedKeys: string[]
 			) {
 				const requests = { count: 0 };
-				setMockResponse(
-					"/accounts/:accountId/storage/kv/namespaces/:namespaceId/bulk",
-					"DELETE",
-					([_url, accountId, namespaceId], { headers, body }) => {
-						requests.count++;
-						expect(accountId).toEqual("some-account-id");
-						expect(namespaceId).toEqual(expectedNamespaceId);
-						expect(new Headers(headers ?? []).get("Content-Type")).toEqual(
-							"application/json"
-						);
-						expect(JSON.parse(body as string)).toEqual(
-							expectedKeys.slice(
-								(requests.count - 1) * 5000,
-								requests.count * 5000
-							)
-						);
-						return null;
-					}
+				msw.use(
+					rest.delete(
+						"*/accounts/:accountId/storage/kv/namespaces/:namespaceId/bulk",
+						async (req, res, ctx) => {
+							requests.count++;
+							expect(req.params.accountId).toEqual("some-account-id");
+							expect(req.params.namespaceId).toEqual(expectedNamespaceId);
+							expect(req.headers.get("Content-Type")).toEqual(
+								"application/json"
+							);
+							expect(await req.json()).toEqual(
+								expectedKeys.slice(
+									(requests.count - 1) * 5000,
+									requests.count * 5000
+								)
+							);
+							return res(ctx.status(200), ctx.json(createFetchResult(null)));
+						}
+					)
 				);
 				return requests;
 			}
@@ -1552,12 +1575,12 @@ describe("wrangler", () => {
 				);
 				expect(requests.count).toEqual(3);
 				expect(std.out).toMatchInlineSnapshot(`
-			          "Deleted 0% (0 out of 12,000)
-			          Deleted 41% (5,000 out of 12,000)
-			          Deleted 83% (10,000 out of 12,000)
-			          Deleted 100% (12,000 out of 12,000)
-			          Success!"
-		        `);
+			"Deleted 0% (0 out of 12,000)
+			Deleted 41% (5,000 out of 12,000)
+			Deleted 83% (10,000 out of 12,000)
+			Deleted 100% (12,000 out of 12,000)
+			Success!"
+		`);
 				expect(std.warn).toMatchInlineSnapshot(`""`);
 				expect(std.err).toMatchInlineSnapshot(`""`);
 			});
@@ -1622,9 +1645,9 @@ describe("wrangler", () => {
 						                12354"
 					              `);
 				expect(std.out).toMatchInlineSnapshot(`
-			          "
-			          If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new/choose"
-		        `);
+			"
+			If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new/choose"
+		`);
 				expect(std.warn).toMatchInlineSnapshot(`""`);
 			});
 
@@ -1647,9 +1670,9 @@ describe("wrangler", () => {
 						                The item at index 3 is type: \\"object\\" - null"
 					              `);
 				expect(std.out).toMatchInlineSnapshot(`
-			          "
-			          If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new/choose"
-		        `);
+			"
+			If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new/choose"
+		`);
 				expect(std.warn).toMatchInlineSnapshot(`""`);
 			});
 		});
@@ -1673,3 +1696,93 @@ function writeWranglerConfig() {
 		"utf-8"
 	);
 }
+
+function setMockFetchKVGetValue(
+	accountId: string,
+	namespaceId: string,
+	key: string,
+	value: string | Buffer
+) {
+	msw.use(
+		rest.get(
+			"*/accounts/:accountId/storage/kv/namespaces/:namespaceId/values/:key",
+			(req, res, ctx) => {
+				console.dir(req.params);
+				expect(req.params.accountId).toEqual(accountId);
+				expect(req.params.namespaceId).toEqual(namespaceId);
+				// Getting the key from params decodes it so we need to grab the encoded key from the URL
+				expect(req.url.toString().split("/").pop()).toBe(key);
+
+				return res.once(ctx.status(200), ctx.body(value));
+			}
+		)
+	);
+}
+
+function createFetchResult(
+	result: unknown,
+	success = true,
+	errors: { code: number; message: string }[] = []
+) {
+	return {
+		success,
+		errors,
+		messages: [],
+		result,
+	};
+}
+
+function mockGetMemberships(
+	accounts: { id: string; account: { id: string; name: string } }[]
+) {
+	msw.use(
+		rest.get("*/memberships", (req, res, ctx) => {
+			return res.once(ctx.json(createFetchResult(accounts)));
+		})
+	);
+}
+
+function mockKeyListRequest(
+	expectedNamespaceId: string,
+	expectedKeys: NamespaceKeyInfo[],
+	keysPerRequest = 1000,
+	blankCursorValue: "" | undefined | null = undefined
+) {
+	const requests = { count: 0 };
+	// See https://api.cloudflare.com/#workers-kv-namespace-list-a-namespace-s-keys
+	msw.use(
+		rest.get(
+			"*/accounts/:accountId/storage/kv/namespaces/:namespaceId/keys",
+			(req, res, ctx) => {
+				requests.count++;
+				let result;
+				let cursor;
+
+				expect(req.params.accountId).toEqual("some-account-id");
+				expect(req.params.namespaceId).toEqual(expectedNamespaceId);
+
+				if (expectedKeys.length <= keysPerRequest) {
+					result = expectedKeys;
+				} else {
+					const start =
+						parseInt(req.url.searchParams.get("cursor") ?? "0") || 0;
+					const end = start + keysPerRequest;
+					cursor = end < expectedKeys.length ? end : blankCursorValue;
+					result = expectedKeys.slice(start, end);
+				}
+				return res(
+					ctx.json({
+						success: true,
+						errors: [],
+						messages: [],
+						result,
+						result_info: {
+							cursor,
+						},
+					})
+				);
+			}
+		)
+	);
+	return requests;
+}

package/src/__tests__/logout.test.ts

@@ -32,7 +32,7 @@ describe("logout", () => {
 			rest.post("*/oauth2/revoke", (_, response, context) => {
 				// Make sure that we made the request to logout.
 				counter += 1;
-				response.once(context.status(200), context.text(""));
+				return response.once(context.status(200), context.text(""));
 			})
 		);