wrangler 0.0.0-e22f9d7 → 0.0.0-e2a26a0

package/src/__tests__/kv.test.ts

@@ -1,20 +1,22 @@
-import { writeFileSync } from "fs";
+import { writeFileSync } from "node:fs";
+import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
 import {
   setMockResponse,
-  setMockRawResponse,
   unsetAllMocks,
-  createFetchResult,
-} from "./mock-cfetch";
-import { runWrangler } from "./run-wrangler";
-import { runInTempDir } from "./run-in-tmp";
-
-interface KVNamespaceInfo {
-  title: string;
-  id: string;
-}
+  unsetMockFetchKVGetValues,
+  setMockFetchKVGetValue,
+} from "./helpers/mock-cfetch";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { mockKeyListRequest } from "./helpers/mock-kv";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+import type { KVNamespaceInfo } from "../kv";
 
 describe("wrangler", () => {
+  mockAccountId();
+  mockApiToken();
   runInTempDir();
+  const std = mockConsoleMethods();
 
   afterEach(() => {
     unsetAllMocks();
@@ -36,11 +38,13 @@ describe("wrangler", () => {
       }
 
       it("should error if no namespace is given", async () => {
-        const { error, stdout, stderr } = await runWrangler(
-          "kv:namespace create"
+        await expect(
+          runWrangler("kv:namespace create")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Not enough non-option arguments: got 0, need at least 1"`
         );
-        expect(stdout).toMatchInlineSnapshot(`""`);
-        expect(stderr).toMatchInlineSnapshot(`
+        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`
           "wrangler kv:namespace create <namespace>
 
           Create a new namespace
@@ -60,17 +64,16 @@ describe("wrangler", () => {
 
           Not enough non-option arguments: got 0, need at least 1"
         `);
-        expect(error).toMatchInlineSnapshot(
-          `[Error: Not enough non-option arguments: got 0, need at least 1]`
-        );
       });
 
       it("should error if the namespace to create contains spaces", async () => {
-        const { error, stdout, stderr } = await runWrangler(
-          "kv:namespace create abc def ghi"
+        await expect(
+          runWrangler("kv:namespace create abc def ghi")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Unexpected additional positional arguments \\"def ghi\\"."`
         );
-        expect(stdout).toMatchInlineSnapshot(`""`);
-        expect(stderr).toMatchInlineSnapshot(`
+        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`
           "wrangler kv:namespace create <namespace>
 
           Create a new namespace
@@ -90,17 +93,17 @@ describe("wrangler", () => {
 
           Unexpected additional positional arguments \\"def ghi\\"."
         `);
-        expect(error).toMatchInlineSnapshot(
-          `[Error: Unexpected additional positional arguments "def ghi".]`
-        );
       });
 
       it("should error if the namespace to create is not valid", async () => {
-        const { error, stdout, stderr } = await runWrangler(
-          "kv:namespace create abc-def"
+        await expect(
+          runWrangler("kv:namespace create abc-def")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"The namespace binding name \\"abc-def\\" is invalid. It can only have alphanumeric and _ characters, and cannot begin with a number."`
         );
-        expect(stdout).toMatchInlineSnapshot(`""`);
-        expect(stderr).toMatchInlineSnapshot(`
+
+        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`
           "wrangler kv:namespace create <namespace>
 
           Create a new namespace
@@ -120,17 +123,12 @@ describe("wrangler", () => {
 
           The namespace binding name \\"abc-def\\" is invalid. It can only have alphanumeric and _ characters, and cannot begin with a number."
         `);
-        expect(error).toMatchInlineSnapshot(
-          `[Error: The namespace binding name "abc-def" is invalid. It can only have alphanumeric and _ characters, and cannot begin with a number.]`
-        );
       });
 
       it("should create a namespace", async () => {
         mockCreateRequest("worker-UnitTestNamespace");
-        const { stdout } = await runWrangler(
-          "kv:namespace create UnitTestNamespace"
-        );
-        expect(stdout).toMatchInlineSnapshot(`
+        await runWrangler("kv:namespace create UnitTestNamespace");
+        expect(std.out).toMatchInlineSnapshot(`
           "🌀 Creating namespace with title \\"worker-UnitTestNamespace\\"
           ✨ Success!
           Add the following to your configuration file in your kv_namespaces array:
@@ -140,10 +138,8 @@ describe("wrangler", () => {
 
       it("should create a preview namespace if configured to do so", async () => {
         mockCreateRequest("worker-UnitTestNamespace_preview");
-        const { stdout } = await runWrangler(
-          "kv:namespace create UnitTestNamespace --preview"
-        );
-        expect(stdout).toMatchInlineSnapshot(`
+        await runWrangler("kv:namespace create UnitTestNamespace --preview");
+        expect(std.out).toMatchInlineSnapshot(`
           "🌀 Creating namespace with title \\"worker-UnitTestNamespace_preview\\"
           ✨ Success!
           Add the following to your configuration file in your kv_namespaces array:
@@ -154,10 +150,8 @@ describe("wrangler", () => {
       it("should create a namespace using configured worker name", async () => {
         writeFileSync("./wrangler.toml", 'name = "otherWorker"', "utf-8");
         mockCreateRequest("otherWorker-UnitTestNamespace");
-        const { stdout } = await runWrangler(
-          "kv:namespace create UnitTestNamespace"
-        );
-        expect(stdout).toMatchInlineSnapshot(`
+        await runWrangler("kv:namespace create UnitTestNamespace");
+        expect(std.out).toMatchInlineSnapshot(`
             "🌀 Creating namespace with title \\"otherWorker-UnitTestNamespace\\"
             ✨ Success!
             Add the following to your configuration file in your kv_namespaces array:
@@ -167,10 +161,10 @@ describe("wrangler", () => {
 
       it("should create a namespace in an environment if configured to do so", async () => {
         mockCreateRequest("worker-customEnv-UnitTestNamespace");
-        const { stdout } = await runWrangler(
+        await runWrangler(
           "kv:namespace create UnitTestNamespace --env customEnv"
         );
-        expect(stdout).toMatchInlineSnapshot(`
+        expect(std.out).toMatchInlineSnapshot(`
           "🌀 Creating namespace with title \\"worker-customEnv-UnitTestNamespace\\"
           ✨ Success!
           Add the following to your configuration file in your kv_namespaces array under [env.customEnv]:
@@ -206,12 +200,10 @@ describe("wrangler", () => {
           { title: "title-2", id: "id-2" },
         ];
         mockListRequest(kvNamespaces);
-        const { error, stdout, stderr } = await runWrangler(
-          "kv:namespace list"
-        );
-        expect(error).toMatchInlineSnapshot(`undefined`);
-        expect(stderr).toMatchInlineSnapshot(`""`);
-        const namespaces = JSON.parse(stdout);
+        await runWrangler("kv:namespace list");
+
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        const namespaces = JSON.parse(std.out);
         expect(namespaces).toEqual(kvNamespaces);
       });
 
@@ -222,8 +214,8 @@ describe("wrangler", () => {
           kvNamespaces.push({ title: "title-" + i, id: "id-" + i });
         }
         const requests = mockListRequest(kvNamespaces);
-        const { stdout } = await runWrangler("kv:namespace list");
-        const namespaces = JSON.parse(stdout);
+        await runWrangler("kv:namespace list");
+        const namespaces = JSON.parse(std.out);
         expect(namespaces).toEqual(kvNamespaces);
         expect(requests.count).toEqual(6);
       });
@@ -273,10 +265,12 @@ describe("wrangler", () => {
 
       it("should error if a given binding name is not in the configured kv namespaces", async () => {
         writeWranglerConfig();
-        const { stderr } = await runWrangler(
-          `kv:namespace delete --binding otherBinding`
-        );
-        expect(stderr).toMatchInlineSnapshot(`
+        await expect(runWrangler("kv:namespace delete --binding otherBinding"))
+          .rejects.toThrowErrorMatchingInlineSnapshot(`
+                "Not able to delete namespace.
+                A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\"."
+              `);
+        expect(std.err).toMatchInlineSnapshot(`
           "wrangler kv:namespace delete
 
           Deletes a given namespace.
@@ -301,12 +295,12 @@ describe("wrangler", () => {
       it("should delete a namespace specified by binding name in a given environment", async () => {
         writeWranglerConfig();
         const requests = mockDeleteRequest("env-bound-id");
-        const { stdout, stderr, error } = await runWrangler(
-          `kv:namespace delete --binding someBinding --env some-environment --preview false`
+        await runWrangler(
+          "kv:namespace delete --binding someBinding --env some-environment --preview false"
         );
-        expect(stdout).toMatchInlineSnapshot(`""`);
-        expect(stderr).toMatchInlineSnapshot(`""`);
-        expect(error).toMatchInlineSnapshot(`undefined`);
+
+        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
         expect(requests.count).toEqual(1);
       });
 
@@ -362,28 +356,29 @@ describe("wrangler", () => {
           "my-key",
           "my-value"
         );
-        const { error, stderr, stdout } = await runWrangler(
+
+        await runWrangler(
           "kv:key put my-key my-value --namespace-id some-namespace-id"
         );
+
         expect(requests.count).toEqual(1);
-        expect(stdout).toMatchInlineSnapshot(
+        expect(std.out).toMatchInlineSnapshot(
           `"writing the value \\"my-value\\" to key \\"my-key\\" on namespace some-namespace-id"`
         );
-        expect(stderr).toMatchInlineSnapshot(`""`);
-        expect(error).toMatchInlineSnapshot(`undefined`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
       });
 
       it("should put a key in a given namespace specified by binding", async () => {
         writeWranglerConfig();
         const requests = mockKeyPutRequest("bound-id", "my-key", "my-value");
-        const { error, stderr, stdout } = await runWrangler(
+        await runWrangler(
           "kv:key put my-key my-value --binding someBinding --preview false"
         );
-        expect(stdout).toMatchInlineSnapshot(
+
+        expect(std.out).toMatchInlineSnapshot(
           `"writing the value \\"my-value\\" to key \\"my-key\\" on namespace bound-id"`
         );
-        expect(stderr).toMatchInlineSnapshot(`""`);
-        expect(error).toMatchInlineSnapshot(`undefined`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
         expect(requests.count).toEqual(1);
       });
 
@@ -394,14 +389,15 @@ describe("wrangler", () => {
           "my-key",
           "my-value"
         );
-        const { error, stderr, stdout } = await runWrangler(
+
+        await runWrangler(
           "kv:key put my-key my-value --binding someBinding --preview"
         );
-        expect(stdout).toMatchInlineSnapshot(
+
+        expect(std.out).toMatchInlineSnapshot(
           `"writing the value \\"my-value\\" to key \\"my-key\\" on namespace preview-bound-id"`
         );
-        expect(stderr).toMatchInlineSnapshot(`""`);
-        expect(error).toMatchInlineSnapshot(`undefined`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
         expect(requests.count).toEqual(1);
       });
 
@@ -413,15 +409,14 @@ describe("wrangler", () => {
           10,
           20
         );
-        const { error, stderr, stdout } = await runWrangler(
+        await runWrangler(
           "kv:key put my-key my-value --namespace-id some-namespace-id --expiration 10 --ttl 20"
         );
         expect(requests.count).toEqual(1);
-        expect(stdout).toMatchInlineSnapshot(
+        expect(std.out).toMatchInlineSnapshot(
           `"writing the value \\"my-value\\" to key \\"my-key\\" on namespace some-namespace-id"`
         );
-        expect(stderr).toMatchInlineSnapshot(`""`);
-        expect(error).toMatchInlineSnapshot(`undefined`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
       });
 
       it("should put a key to the specified environment in a given namespace", async () => {
@@ -431,14 +426,13 @@ describe("wrangler", () => {
           "my-key",
           "my-value"
         );
-        const { error, stderr, stdout } = await runWrangler(
+        await runWrangler(
           "kv:key put my-key my-value --binding someBinding --env some-environment --preview false"
         );
-        expect(stdout).toMatchInlineSnapshot(
+        expect(std.out).toMatchInlineSnapshot(
           `"writing the value \\"my-value\\" to key \\"my-key\\" on namespace env-bound-id"`
         );
-        expect(stderr).toMatchInlineSnapshot(`""`);
-        expect(error).toMatchInlineSnapshot(`undefined`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
         expect(requests.count).toEqual(1);
       });
 
@@ -449,22 +443,25 @@ describe("wrangler", () => {
           "my-key",
           "file-contents"
         );
-        const { error, stderr, stdout } = await runWrangler(
+        await runWrangler(
           "kv:key put my-key --namespace-id some-namespace-id --path foo.txt"
         );
-        expect(stdout).toMatchInlineSnapshot(
+        expect(std.out).toMatchInlineSnapshot(
           `"writing the contents of foo.txt to the key \\"my-key\\" on namespace some-namespace-id"`
         );
-        expect(stderr).toMatchInlineSnapshot(`""`);
-        expect(error).toMatchInlineSnapshot(`undefined`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
         expect(requests.count).toEqual(1);
       });
 
       it("should error if no key is provided", async () => {
-        const { error, stdout, stderr } = await runWrangler("kv:key put");
+        await expect(
+          runWrangler("kv:key put")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Not enough non-option arguments: got 0, need at least 1"`
+        );
 
-        expect(stdout).toMatchInlineSnapshot(`""`);
-        expect(stderr).toMatchInlineSnapshot(`
+        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`
           "wrangler kv:key put <key> [value]
 
           Writes a single key/value pair to the given namespace.
@@ -490,18 +487,17 @@ describe("wrangler", () => {
 
           Not enough non-option arguments: got 0, need at least 1"
         `);
-        expect(error).toMatchInlineSnapshot(
-          `[Error: Not enough non-option arguments: got 0, need at least 1]`
-        );
       });
 
       it("should error if no binding nor namespace is provided", async () => {
-        const { error, stdout, stderr } = await runWrangler(
-          "kv:key put foo bar"
+        await expect(
+          runWrangler("kv:key put foo bar")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Exactly one of the arguments binding and namespace-id is required"`
         );
 
-        expect(stdout).toMatchInlineSnapshot(`""`);
-        expect(stderr).toMatchInlineSnapshot(`
+        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`
           "wrangler kv:key put <key> [value]
 
           Writes a single key/value pair to the given namespace.
@@ -527,18 +523,17 @@ describe("wrangler", () => {
 
           Exactly one of the arguments binding and namespace-id is required"
         `);
-        expect(error).toMatchInlineSnapshot(
-          `[Error: Exactly one of the arguments binding and namespace-id is required]`
-        );
       });
 
       it("should error if both binding and namespace is provided", async () => {
-        const { error, stdout, stderr } = await runWrangler(
-          "kv:key put foo bar --binding x --namespace-id y"
+        await expect(
+          runWrangler("kv:key put foo bar --binding x --namespace-id y")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Arguments binding and namespace-id are mutually exclusive"`
         );
 
-        expect(stdout).toMatchInlineSnapshot(`""`);
-        expect(stderr).toMatchInlineSnapshot(`
+        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`
           "wrangler kv:key put <key> [value]
 
           Writes a single key/value pair to the given namespace.
@@ -564,18 +559,17 @@ describe("wrangler", () => {
 
           Arguments binding and namespace-id are mutually exclusive"
         `);
-        expect(error).toMatchInlineSnapshot(
-          `[Error: Arguments binding and namespace-id are mutually exclusive]`
-        );
       });
 
       it("should error if no value nor path is provided", async () => {
-        const { error, stdout, stderr } = await runWrangler(
-          "kv:key put key --namespace-id 12345"
+        await expect(
+          runWrangler("kv:key put key --namespace-id 12345")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Exactly one of the arguments value and path is required"`
         );
 
-        expect(stdout).toMatchInlineSnapshot(`""`);
-        expect(stderr).toMatchInlineSnapshot(`
+        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`
           "wrangler kv:key put <key> [value]
 
           Writes a single key/value pair to the given namespace.
@@ -601,18 +595,17 @@ describe("wrangler", () => {
 
           Exactly one of the arguments value and path is required"
         `);
-        expect(error).toMatchInlineSnapshot(
-          `[Error: Exactly one of the arguments value and path is required]`
-        );
       });
 
       it("should error if both value and path is provided", async () => {
-        const { error, stdout, stderr } = await runWrangler(
-          "kv:key put key value --path xyz --namespace-id 12345"
+        await expect(
+          runWrangler("kv:key put key value --path xyz --namespace-id 12345")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Arguments value and path are mutually exclusive"`
         );
 
-        expect(stdout).toMatchInlineSnapshot(`""`);
-        expect(stderr).toMatchInlineSnapshot(`
+        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`
           "wrangler kv:key put <key> [value]
 
           Writes a single key/value pair to the given namespace.
@@ -638,23 +631,23 @@ describe("wrangler", () => {
 
           Arguments value and path are mutually exclusive"
         `);
-        expect(error).toMatchInlineSnapshot(
-          `[Error: Arguments value and path are mutually exclusive]`
-        );
       });
 
       it("should error if a given binding name is not in the configured kv namespaces", async () => {
         writeWranglerConfig();
-        const { error, stdout, stderr } = await runWrangler(
-          `kv:key put key value --binding otherBinding`
-        );
-        expect(stdout).toMatchInlineSnapshot(`""`);
-        expect(stderr).toMatchInlineSnapshot(
+        await expect(
+          runWrangler("kv:key put key value --binding otherBinding")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
           `"A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\"."`
         );
-        expect(error).toMatchInlineSnapshot(
-          `[Error: A namespace with binding name "otherBinding" was not found in the configured "kv_namespaces".]`
-        );
+
+        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`
+          "A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\".
+
+          %s
+          If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+        `);
       });
 
       it("should error if a given binding has both preview and non-preview and --preview is not specified", async () => {
@@ -664,64 +657,46 @@ describe("wrangler", () => {
           "my-key",
           "my-value"
         );
-        const { error, stderr, stdout } = await runWrangler(
-          "kv:key put my-key my-value --binding someBinding"
-        );
-        expect(stdout).toMatchInlineSnapshot(`""`);
-        expect(stderr).toMatchInlineSnapshot(
+        await expect(
+          runWrangler("kv:key put my-key my-value --binding someBinding")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
           `"someBinding has both a namespace ID and a preview ID. Specify \\"--preview\\" or \\"--preview false\\" to avoid writing data to the wrong namespace."`
         );
-        expect(error).toMatchInlineSnapshot(
-          `[Error: someBinding has both a namespace ID and a preview ID. Specify "--preview" or "--preview false" to avoid writing data to the wrong namespace.]`
-        );
+        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`
+          "someBinding has both a namespace ID and a preview ID. Specify \\"--preview\\" or \\"--preview false\\" to avoid writing data to the wrong namespace.
+
+          %s
+          If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+        `);
         expect(requests.count).toEqual(0);
       });
     });
 
     describe("list", () => {
-      function mockKeyListRequest(
-        expectedNamespaceId: string,
-        expectedKeys: string[],
-        keysPerRequest = 1000
-      ) {
-        const requests = { count: 0 };
-        setMockRawResponse(
-          "/accounts/:accountId/storage/kv/namespaces/:namespaceId/keys",
-          ([_url, accountId, namespaceId], _init, query) => {
-            requests.count++;
-            expect(accountId).toEqual("some-account-id");
-            expect(namespaceId).toEqual(expectedNamespaceId);
-            if (expectedKeys.length <= keysPerRequest) {
-              return createFetchResult(expectedKeys);
-            } else {
-              const start = parseInt(query.get("cursor") ?? "0") || 0;
-              const end = start + keysPerRequest;
-              const cursor = end < expectedKeys.length ? end : undefined;
-              return createFetchResult(
-                expectedKeys.slice(start, end),
-                true,
-                [],
-                [],
-                { cursor }
-              );
-            }
-          }
-        );
-        return requests;
-      }
-
       it("should list the keys of a namespace specified by namespace-id", async () => {
         const keys = ["key-1", "key-2", "key-3"];
         mockKeyListRequest("some-namespace-id", keys);
-        const { error, stdout, stderr } = await runWrangler(
-          "kv:key list --namespace-id some-namespace-id"
-        );
-        expect(error).toMatchInlineSnapshot(`undefined`);
-        expect(stderr).toMatchInlineSnapshot(`""`);
-        expect(stdout).toMatchInlineSnapshot(`
-          "key-1
-          key-2
-          key-3"
+        await runWrangler("kv:key list --namespace-id some-namespace-id");
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.out).toMatchInlineSnapshot(`
+          "[
+            {
+              \\"name\\": \\"key-1\\",
+              \\"expiration\\": 123456789,
+              \\"metadata\\": {}
+            },
+            {
+              \\"name\\": \\"key-2\\",
+              \\"expiration\\": 123456789,
+              \\"metadata\\": {}
+            },
+            {
+              \\"name\\": \\"key-3\\",
+              \\"expiration\\": 123456789,
+              \\"metadata\\": {}
+            }
+          ]"
         `);
       });
 
@@ -729,15 +704,27 @@ describe("wrangler", () => {
         writeWranglerConfig();
         const keys = ["key-1", "key-2", "key-3"];
         mockKeyListRequest("bound-id", keys);
-        const { error, stdout, stderr } = await runWrangler(
-          "kv:key list --binding someBinding"
-        );
-        expect(error).toMatchInlineSnapshot(`undefined`);
-        expect(stderr).toMatchInlineSnapshot(`""`);
-        expect(stdout).toMatchInlineSnapshot(`
-          "key-1
-          key-2
-          key-3"
+
+        await runWrangler("kv:key list --binding someBinding");
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.out).toMatchInlineSnapshot(`
+          "[
+            {
+              \\"name\\": \\"key-1\\",
+              \\"expiration\\": 123456789,
+              \\"metadata\\": {}
+            },
+            {
+              \\"name\\": \\"key-2\\",
+              \\"expiration\\": 123456789,
+              \\"metadata\\": {}
+            },
+            {
+              \\"name\\": \\"key-3\\",
+              \\"expiration\\": 123456789,
+              \\"metadata\\": {}
+            }
+          ]"
         `);
       });
 
@@ -745,15 +732,26 @@ describe("wrangler", () => {
         writeWranglerConfig();
         const keys = ["key-1", "key-2", "key-3"];
         mockKeyListRequest("preview-bound-id", keys);
-        const { error, stdout, stderr } = await runWrangler(
-          "kv:key list --binding someBinding --preview"
-        );
-        expect(error).toMatchInlineSnapshot(`undefined`);
-        expect(stderr).toMatchInlineSnapshot(`""`);
-        expect(stdout).toMatchInlineSnapshot(`
-          "key-1
-          key-2
-          key-3"
+        await runWrangler("kv:key list --binding someBinding --preview");
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.out).toMatchInlineSnapshot(`
+          "[
+            {
+              \\"name\\": \\"key-1\\",
+              \\"expiration\\": 123456789,
+              \\"metadata\\": {}
+            },
+            {
+              \\"name\\": \\"key-2\\",
+              \\"expiration\\": 123456789,
+              \\"metadata\\": {}
+            },
+            {
+              \\"name\\": \\"key-3\\",
+              \\"expiration\\": 123456789,
+              \\"metadata\\": {}
+            }
+          ]"
         `);
       });
 
@@ -761,15 +759,28 @@ describe("wrangler", () => {
         writeWranglerConfig();
         const keys = ["key-1", "key-2", "key-3"];
         mockKeyListRequest("env-bound-id", keys);
-        const { error, stdout, stderr } = await runWrangler(
+        await runWrangler(
           "kv:key list --binding someBinding --env some-environment"
         );
-        expect(error).toMatchInlineSnapshot(`undefined`);
-        expect(stderr).toMatchInlineSnapshot(`""`);
-        expect(stdout).toMatchInlineSnapshot(`
-          "key-1
-          key-2
-          key-3"
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.out).toMatchInlineSnapshot(`
+          "[
+            {
+              \\"name\\": \\"key-1\\",
+              \\"expiration\\": 123456789,
+              \\"metadata\\": {}
+            },
+            {
+              \\"name\\": \\"key-2\\",
+              \\"expiration\\": 123456789,
+              \\"metadata\\": {}
+            },
+            {
+              \\"name\\": \\"key-3\\",
+              \\"expiration\\": 123456789,
+              \\"metadata\\": {}
+            }
+          ]"
         `);
       });
 
@@ -777,134 +788,148 @@ describe("wrangler", () => {
         writeWranglerConfig();
         const keys = ["key-1", "key-2", "key-3"];
         mockKeyListRequest("preview-env-bound-id", keys);
-        const { error, stdout, stderr } = await runWrangler(
+        await runWrangler(
           "kv:key list --binding someBinding --preview --env some-environment"
         );
-        expect(error).toMatchInlineSnapshot(`undefined`);
-        expect(stderr).toMatchInlineSnapshot(`""`);
-        expect(stdout).toMatchInlineSnapshot(`
-          "key-1
-          key-2
-          key-3"
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(std.out).toMatchInlineSnapshot(`
+          "[
+            {
+              \\"name\\": \\"key-1\\",
+              \\"expiration\\": 123456789,
+              \\"metadata\\": {}
+            },
+            {
+              \\"name\\": \\"key-2\\",
+              \\"expiration\\": 123456789,
+              \\"metadata\\": {}
+            },
+            {
+              \\"name\\": \\"key-3\\",
+              \\"expiration\\": 123456789,
+              \\"metadata\\": {}
+            }
+          ]"
         `);
       });
 
-      it("should make multiple requests for paginated results", async () => {
-        // Create a lot of mock keys, so that the fetch requests will be paginated
-        const keys: string[] = [];
-        for (let i = 0; i < 550; i++) {
-          keys.push("key-" + i);
-        }
-        // Ask for the keys in pages of size 100.
-        const requests = mockKeyListRequest("some-namespace-id", keys, 100);
-        const { stdout, stderr, error } = await runWrangler(
-          "kv:key list --namespace-id some-namespace-id --limit 100"
-        );
-        expect(error).toMatchInlineSnapshot(`undefined`);
-        expect(stderr).toMatchInlineSnapshot(`""`);
-        expect(stdout).toEqual(keys.join("\n"));
-        expect(requests.count).toEqual(6);
-      });
+      // We'll run the next test with variations on the cursor
+      // that's returned on cloudflare's API after all results
+      // have been drained.
+      for (const blankCursorValue of [undefined, null, ""] as [
+        undefined,
+        null,
+        ""
+      ]) {
+        describe(`cursor - ${blankCursorValue}`, () => {
+          it("should make multiple requests for paginated results", async () => {
+            // Create a lot of mock keys, so that the fetch requests will be paginated
+            const keys: string[] = [];
+            for (let i = 0; i < 550; i++) {
+              keys.push("key-" + i);
+            }
+            // Ask for the keys in pages of size 100.
+            const requests = mockKeyListRequest(
+              "some-namespace-id",
+              keys,
+              100,
+              blankCursorValue
+            );
+            await runWrangler(
+              "kv:key list --namespace-id some-namespace-id --limit 100"
+            );
+            expect(std.err).toMatchInlineSnapshot(`""`);
+            expect(JSON.parse(std.out).map((k) => k.name)).toEqual(keys);
+            expect(requests.count).toEqual(6);
+          });
+        });
+      }
 
       it("should error if a given binding name is not in the configured kv namespaces", async () => {
         writeWranglerConfig();
-        const { error, stdout, stderr } = await runWrangler(
-          "kv:key list --binding otherBinding"
-        );
-        expect(error).toMatchInlineSnapshot(
-          `[Error: A namespace with binding name "otherBinding" was not found in the configured "kv_namespaces".]`
-        );
-        expect(stderr).toMatchInlineSnapshot(
+        await expect(
+          runWrangler("kv:key list --binding otherBinding")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
           `"A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\"."`
         );
-        expect(stdout).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`
+          "A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\".
+
+          %s
+          If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+        `);
+        expect(std.out).toMatchInlineSnapshot(`""`);
       });
     });
 
     describe("get", () => {
-      function mockKeyGetRequest(
-        expectedNamespaceId: string,
-        expectedKey: string,
-        expectedValue: string
-      ) {
-        const requests = { count: 0 };
-        setMockRawResponse(
-          "/accounts/:accountId/storage/kv/namespaces/:namespaceId/values/:key",
-          ([_url, accountId, namespaceId, key]) => {
-            requests.count++;
-            expect(accountId).toEqual("some-account-id");
-            expect(namespaceId).toEqual(expectedNamespaceId);
-            expect(key).toEqual(expectedKey);
-            return expectedValue;
-          }
-        );
-        return requests;
-      }
+      afterEach(() => {
+        unsetMockFetchKVGetValues();
+      });
 
       it("should get a key in a given namespace specified by namespace-id", async () => {
-        const requests = mockKeyGetRequest(
+        setMockFetchKVGetValue(
+          "some-account-id",
           "some-namespace-id",
           "my-key",
           "my-value"
         );
-        const { error, stderr, stdout } = await runWrangler(
-          "kv:key get my-key --namespace-id some-namespace-id"
-        );
-        expect(stdout).toMatchInlineSnapshot(`"my-value"`);
-        expect(stderr).toMatchInlineSnapshot(`""`);
-        expect(error).toMatchInlineSnapshot(`undefined`);
-        expect(requests.count).toEqual(1);
+        await runWrangler("kv:key get my-key --namespace-id some-namespace-id");
+        expect(std.out).toMatchInlineSnapshot(`"my-value"`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
       });
 
       it("should get a key in a given namespace specified by binding", async () => {
         writeWranglerConfig();
-        const requests = mockKeyGetRequest("bound-id", "my-key", "my-value");
-        const { error, stderr, stdout } = await runWrangler(
+        setMockFetchKVGetValue(
+          "some-account-id",
+          "bound-id",
+          "my-key",
+          "my-value"
+        );
+        await runWrangler(
           "kv:key get my-key --binding someBinding --preview false"
         );
-        expect(stdout).toMatchInlineSnapshot(`"my-value"`);
-        expect(stderr).toMatchInlineSnapshot(`""`);
-        expect(error).toMatchInlineSnapshot(`undefined`);
-        expect(requests.count).toEqual(1);
+        expect(std.out).toMatchInlineSnapshot(`"my-value"`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
       });
 
       it("should get a key in a given preview namespace specified by binding", async () => {
         writeWranglerConfig();
-        const requests = mockKeyGetRequest(
+        setMockFetchKVGetValue(
+          "some-account-id",
           "preview-bound-id",
           "my-key",
           "my-value"
         );
-        const { error, stderr, stdout } = await runWrangler(
-          "kv:key get my-key --binding someBinding --preview"
-        );
-        expect(stdout).toMatchInlineSnapshot(`"my-value"`);
-        expect(stderr).toMatchInlineSnapshot(`""`);
-        expect(error).toMatchInlineSnapshot(`undefined`);
-        expect(requests.count).toEqual(1);
+        await runWrangler("kv:key get my-key --binding someBinding --preview");
+        expect(std.out).toMatchInlineSnapshot(`"my-value"`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
       });
 
       it("should get a key for the specified environment in a given namespace", async () => {
         writeWranglerConfig();
-        const requests = mockKeyGetRequest(
+        setMockFetchKVGetValue(
+          "some-account-id",
           "env-bound-id",
           "my-key",
           "my-value"
         );
-        const { error, stderr, stdout } = await runWrangler(
+        await runWrangler(
           "kv:key get my-key my-value --binding someBinding --env some-environment --preview false"
         );
-        expect(stdout).toMatchInlineSnapshot(`"my-value"`);
-        expect(stderr).toMatchInlineSnapshot(`""`);
-        expect(error).toMatchInlineSnapshot(`undefined`);
-        expect(requests.count).toEqual(1);
+        expect(std.out).toMatchInlineSnapshot(`"my-value"`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
       });
 
       it("should error if no key is provided", async () => {
-        const { error, stdout, stderr } = await runWrangler("kv:key get");
-
-        expect(stdout).toMatchInlineSnapshot(`""`);
-        expect(stderr).toMatchInlineSnapshot(`
+        await expect(
+          runWrangler("kv:key get")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Not enough non-option arguments: got 0, need at least 1"`
+        );
+        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`
           "wrangler kv:key get <key>
 
           Reads a single value by key from the given namespace.
@@ -926,16 +951,16 @@ describe("wrangler", () => {
 
           Not enough non-option arguments: got 0, need at least 1"
         `);
-        expect(error).toMatchInlineSnapshot(
-          `[Error: Not enough non-option arguments: got 0, need at least 1]`
-        );
       });
 
       it("should error if no binding nor namespace is provided", async () => {
-        const { error, stdout, stderr } = await runWrangler("kv:key get foo");
-
-        expect(stdout).toMatchInlineSnapshot(`""`);
-        expect(stderr).toMatchInlineSnapshot(`
+        await expect(
+          runWrangler("kv:key get foo")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Exactly one of the arguments binding and namespace-id is required"`
+        );
+        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`
           "wrangler kv:key get <key>
 
           Reads a single value by key from the given namespace.
@@ -957,18 +982,17 @@ describe("wrangler", () => {
 
           Exactly one of the arguments binding and namespace-id is required"
         `);
-        expect(error).toMatchInlineSnapshot(
-          `[Error: Exactly one of the arguments binding and namespace-id is required]`
-        );
       });
 
       it("should error if both binding and namespace is provided", async () => {
-        const { error, stdout, stderr } = await runWrangler(
-          "kv:key get foo --binding x --namespace-id y"
+        await expect(
+          runWrangler("kv:key get foo --binding x --namespace-id y")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Arguments binding and namespace-id are mutually exclusive"`
         );
 
-        expect(stdout).toMatchInlineSnapshot(`""`);
-        expect(stderr).toMatchInlineSnapshot(`
+        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`
           "wrangler kv:key get <key>
 
           Reads a single value by key from the given namespace.
@@ -990,23 +1014,22 @@ describe("wrangler", () => {
 
           Arguments binding and namespace-id are mutually exclusive"
         `);
-        expect(error).toMatchInlineSnapshot(
-          `[Error: Arguments binding and namespace-id are mutually exclusive]`
-        );
       });
 
       it("should error if a given binding name is not in the configured kv namespaces", async () => {
         writeWranglerConfig();
-        const { error, stdout, stderr } = await runWrangler(
-          `kv:key get key --binding otherBinding`
-        );
-        expect(stdout).toMatchInlineSnapshot(`""`);
-        expect(stderr).toMatchInlineSnapshot(
+        await expect(
+          runWrangler("kv:key get key --binding otherBinding")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
           `"A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\"."`
         );
-        expect(error).toMatchInlineSnapshot(
-          `[Error: A namespace with binding name "otherBinding" was not found in the configured "kv_namespaces".]`
-        );
+        expect(std.out).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`
+          "A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\".
+
+          %s
+          If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+        `);
       });
     });
 
@@ -1058,25 +1081,30 @@ describe("wrangler", () => {
 
       it("should error if a given binding name is not in the configured kv namespaces", async () => {
         writeWranglerConfig();
-        const { stderr } = await runWrangler(
-          `kv:key delete --binding otherBinding someKey`
-        );
-        expect(stderr).toMatchInlineSnapshot(
+        await expect(
+          runWrangler(`kv:key delete --binding otherBinding someKey`)
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
           `"A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\"."`
         );
+
+        expect(std.err).toMatchInlineSnapshot(`
+          "A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\".
+
+          %s
+          If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+        `);
       });
 
       it("should delete a key in a namespace specified by binding name in a given environment", async () => {
         writeWranglerConfig();
         const requests = mockDeleteRequest("env-bound-id", "someKey");
-        const { stdout, stderr, error } = await runWrangler(
+        await runWrangler(
           `kv:key delete --binding someBinding --env some-environment --preview false someKey`
         );
-        expect(stdout).toMatchInlineSnapshot(
+        expect(std.out).toMatchInlineSnapshot(
           `"deleting the key \\"someKey\\" on namespace env-bound-id"`
         );
-        expect(stderr).toMatchInlineSnapshot(`""`);
-        expect(error).toMatchInlineSnapshot(`undefined`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
         expect(requests.count).toEqual(1);
       });