wrangler 0.0.0-e0d2f35 → 0.0.0-e1b8ac4

package/src/__tests__/kv.test.ts

@@ -1,21 +1,30 @@
-import { writeFileSync } from "fs";
-import type { KVNamespaceInfo } from "../kv";
+import { writeFileSync } from "node:fs";
+import { Headers } from "undici";
+import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
 import {
   setMockResponse,
-  setMockRawResponse,
   unsetAllMocks,
-} from "./mock-cfetch";
-import { runWrangler } from "./run-wrangler";
-import { runInTempDir } from "./run-in-tmp";
-import { mockConsoleMethods } from "./mock-console";
-import { mockKeyListRequest } from "./mock-kv";
+  unsetMockFetchKVGetValues,
+  setMockFetchKVGetValue,
+} from "./helpers/mock-cfetch";
+import { mockConsoleMethods } from "./helpers/mock-console";
+import { clearConfirmMocks, mockConfirm } from "./helpers/mock-dialogs";
+import { mockKeyListRequest } from "./helpers/mock-kv";
+import { mockProcess } from "./helpers/mock-process";
+import { runInTempDir } from "./helpers/run-in-tmp";
+import { runWrangler } from "./helpers/run-wrangler";
+import type { KeyValue, KVNamespaceInfo, NamespaceKeyInfo } from "../kv";
 
 describe("wrangler", () => {
+  mockAccountId();
+  mockApiToken();
   runInTempDir();
   const std = mockConsoleMethods();
+  const proc = mockProcess();
 
   afterEach(() => {
     unsetAllMocks();
+    clearConfirmMocks();
   });
 
   describe("kv:namespace", () => {
@@ -34,15 +43,14 @@ describe("wrangler", () => {
       }
 
       it("should error if no namespace is given", async () => {
-        let error: Error | undefined;
-        try {
-          await runWrangler("kv:namespace create");
-        } catch (e) {
-          error = e;
-        }
-        expect(std.out).toMatchInlineSnapshot(`""`);
-        expect(std.err).toMatchInlineSnapshot(`
-          "wrangler kv:namespace create <namespace>
+        await expect(
+          runWrangler("kv:namespace create")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Not enough non-option arguments: got 0, need at least 1"`
+        );
+        expect(std.out).toMatchInlineSnapshot(`
+          "
+          wrangler kv:namespace create <namespace>
 
           Create a new namespace
 
@@ -55,27 +63,25 @@ describe("wrangler", () => {
             -v, --version  Show version number  [boolean]
 
           Options:
-            -l, --local    Run on my machine  [boolean] [default: false]
-                --env      Perform on a specific environment  [string]
-                --preview  Interact with a preview namespace  [boolean]
+            -e, --env      Perform on a specific environment  [string]
+                --preview  Interact with a preview namespace  [boolean]"
+        `);
+        expect(std.err).toMatchInlineSnapshot(`
+          "X [ERROR] Not enough non-option arguments: got 0, need at least 1
 
-          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 () => {
-        let error: Error | undefined;
-        try {
-          await runWrangler("kv:namespace create abc def ghi");
-        } catch (e) {
-          error = e;
-        }
-        expect(std.out).toMatchInlineSnapshot(`""`);
-        expect(std.err).toMatchInlineSnapshot(`
-          "wrangler kv:namespace create <namespace>
+        await expect(
+          runWrangler("kv:namespace create abc def ghi")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Unknown arguments: def, ghi"`
+        );
+        expect(std.out).toMatchInlineSnapshot(`
+          "
+          wrangler kv:namespace create <namespace>
 
           Create a new namespace
 
@@ -88,28 +94,26 @@ describe("wrangler", () => {
             -v, --version  Show version number  [boolean]
 
           Options:
-            -l, --local    Run on my machine  [boolean] [default: false]
-                --env      Perform on a specific environment  [string]
-                --preview  Interact with a preview namespace  [boolean]
+            -e, --env      Perform on a specific environment  [string]
+                --preview  Interact with a preview namespace  [boolean]"
+        `);
+        expect(std.err).toMatchInlineSnapshot(`
+          "X [ERROR] Unknown arguments: def, ghi
 
-          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 () => {
-        let error: Error | undefined;
-        try {
-          await runWrangler("kv:namespace create abc-def");
-        } catch (e) {
-          error = e;
-        }
+        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(std.out).toMatchInlineSnapshot(`""`);
-        expect(std.err).toMatchInlineSnapshot(`
-          "wrangler kv:namespace create <namespace>
+        expect(std.out).toMatchInlineSnapshot(`
+          "
+          wrangler kv:namespace create <namespace>
 
           Create a new namespace
 
@@ -122,15 +126,14 @@ describe("wrangler", () => {
             -v, --version  Show version number  [boolean]
 
           Options:
-            -l, --local    Run on my machine  [boolean] [default: false]
-                --env      Perform on a specific environment  [string]
-                --preview  Interact with a preview namespace  [boolean]
+            -e, --env      Perform on a specific environment  [string]
+                --preview  Interact with a preview namespace  [boolean]"
+        `);
+        expect(std.err).toMatchInlineSnapshot(`
+          "X [ERROR] The namespace binding name \\"abc-def\\" is invalid. It can only have alphanumeric and _ characters, and cannot begin with a number.
 
-          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 () => {
@@ -156,11 +159,11 @@ describe("wrangler", () => {
       });
 
       it("should create a namespace using configured worker name", async () => {
-        writeFileSync("./wrangler.toml", 'name = "otherWorker"', "utf-8");
-        mockCreateRequest("otherWorker-UnitTestNamespace");
+        writeFileSync("./wrangler.toml", 'name = "other-worker"', "utf-8");
+        mockCreateRequest("other-worker-UnitTestNamespace");
         await runWrangler("kv:namespace create UnitTestNamespace");
         expect(std.out).toMatchInlineSnapshot(`
-            "🌀 Creating namespace with title \\"otherWorker-UnitTestNamespace\\"
+            "🌀 Creating namespace with title \\"other-worker-UnitTestNamespace\\"
             ✨ Success!
             Add the following to your configuration file in your kv_namespaces array:
             { binding = \\"UnitTestNamespace\\", id = \\"some-namespace-id\\" }"
@@ -273,35 +276,17 @@ describe("wrangler", () => {
 
       it("should error if a given binding name is not in the configured kv namespaces", async () => {
         writeWranglerConfig();
-        let error: Error | undefined;
-        try {
-          await runWrangler("kv:namespace delete --binding otherBinding");
-        } catch (e) {
-          error = e;
-        }
-        expect(error).toMatchInlineSnapshot(`
-          [Error: Not able to delete namespace.
-          A namespace with binding name "otherBinding" was not found in the configured "kv_namespaces".]
-        `);
+        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
+          "X [ERROR] Not able to delete namespace.
 
-          Deletes a given namespace.
+            A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\".
 
-          Flags:
-            -c, --config   Path to .toml configuration file  [string]
-            -h, --help     Show help  [boolean]
-            -v, --version  Show version number  [boolean]
-
-          Options:
-            -l, --local         Run on my machine  [boolean] [default: false]
-                --binding       The name of the namespace to delete  [string]
-                --namespace-id  The id of the namespace to delete  [string]
-                --env           Perform on a specific environment  [string]
-                --preview       Interact with a preview namespace  [boolean]
-
-          Not able to delete namespace.
-          A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\"."
+          "
         `);
       });
 
@@ -332,10 +317,7 @@ describe("wrangler", () => {
     describe("put", () => {
       function mockKeyPutRequest(
         expectedNamespaceId: string,
-        expectedKey: string,
-        expectedValue: string,
-        expiration?: number,
-        expirationTtl?: number
+        expectedKV: KeyValue
       ) {
         const requests = { count: 0 };
         setMockResponse(
@@ -345,15 +327,19 @@ describe("wrangler", () => {
             requests.count++;
             expect(accountId).toEqual("some-account-id");
             expect(namespaceId).toEqual(expectedNamespaceId);
-            expect(key).toEqual(expectedKey);
-            expect(body).toEqual(expectedValue);
-            if (expiration !== undefined) {
-              expect(query.get("expiration")).toEqual(`${expiration}`);
+            expect(key).toEqual(expectedKV.key);
+            expect(body).toEqual(expectedKV.value);
+            if (expectedKV.expiration !== undefined) {
+              expect(query.get("expiration")).toEqual(
+                `${expectedKV.expiration}`
+              );
             } else {
               expect(query.has("expiration")).toBe(false);
             }
-            if (expirationTtl) {
-              expect(query.get("expiration_ttl")).toEqual(`${expirationTtl}`);
+            if (expectedKV.expiration_ttl) {
+              expect(query.get("expiration_ttl")).toEqual(
+                `${expectedKV.expiration_ttl}`
+              );
             } else {
               expect(query.has("expiration_ttl")).toBe(false);
             }
@@ -364,11 +350,10 @@ describe("wrangler", () => {
       }
 
       it("should put a key in a given namespace specified by namespace-id", async () => {
-        const requests = mockKeyPutRequest(
-          "some-namespace-id",
-          "my-key",
-          "my-value"
-        );
+        const requests = mockKeyPutRequest("some-namespace-id", {
+          key: "my-key",
+          value: "my-value",
+        });
 
         await runWrangler(
           "kv:key put my-key my-value --namespace-id some-namespace-id"
@@ -376,20 +361,38 @@ describe("wrangler", () => {
 
         expect(requests.count).toEqual(1);
         expect(std.out).toMatchInlineSnapshot(
-          `"writing the value \\"my-value\\" to key \\"my-key\\" on namespace some-namespace-id"`
+          `"Writing the value \\"my-value\\" to key \\"my-key\\" on namespace some-namespace-id."`
+        );
+        expect(std.err).toMatchInlineSnapshot(`""`);
+      });
+
+      it("should encode the key in the api request to put a value", async () => {
+        const requests = mockKeyPutRequest("DS9", {
+          key: "%2Fmy-key",
+          value: "my-value",
+        });
+
+        await runWrangler("kv:key put /my-key my-value --namespace-id DS9");
+
+        expect(requests.count).toEqual(1);
+        expect(std.out).toMatchInlineSnapshot(
+          `"Writing the value \\"my-value\\" to key \\"/my-key\\" on namespace DS9."`
         );
         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 requests = mockKeyPutRequest("bound-id", {
+          key: "my-key",
+          value: "my-value",
+        });
         await runWrangler(
           "kv:key put my-key my-value --binding someBinding --preview false"
         );
 
         expect(std.out).toMatchInlineSnapshot(
-          `"writing the value \\"my-value\\" to key \\"my-key\\" on namespace bound-id"`
+          `"Writing the value \\"my-value\\" to key \\"my-key\\" on namespace bound-id."`
         );
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(requests.count).toEqual(1);
@@ -397,99 +400,108 @@ describe("wrangler", () => {
 
       it("should put a key in a given preview namespace specified by binding", async () => {
         writeWranglerConfig();
-        const requests = mockKeyPutRequest(
-          "preview-bound-id",
-          "my-key",
-          "my-value"
-        );
+        const requests = mockKeyPutRequest("preview-bound-id", {
+          key: "my-key",
+          value: "my-value",
+        });
 
         await runWrangler(
           "kv:key put my-key my-value --binding someBinding --preview"
         );
 
         expect(std.out).toMatchInlineSnapshot(
-          `"writing the value \\"my-value\\" to key \\"my-key\\" on namespace preview-bound-id"`
+          `"Writing the value \\"my-value\\" to key \\"my-key\\" on namespace preview-bound-id."`
         );
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(requests.count).toEqual(1);
       });
 
       it("should add expiration and ttl properties when putting a key", async () => {
-        const requests = mockKeyPutRequest(
-          "some-namespace-id",
-          "my-key",
-          "my-value",
-          10,
-          20
-        );
-        let error: Error | undefined;
-        try {
-          await runWrangler(
-            "kv:key put my-key my-value --namespace-id some-namespace-id --expiration 10 --ttl 20"
-          );
-        } catch (e) {
-          error = e;
-        }
-
+        const requests = mockKeyPutRequest("some-namespace-id", {
+          key: "my-key",
+          value: "my-value",
+          expiration: 10,
+          expiration_ttl: 20,
+        });
+        await runWrangler(
+          "kv:key put my-key my-value --namespace-id some-namespace-id --expiration 10 --ttl 20"
+        );
         expect(requests.count).toEqual(1);
         expect(std.out).toMatchInlineSnapshot(
-          `"writing the value \\"my-value\\" to key \\"my-key\\" on namespace some-namespace-id"`
+          `"Writing the value \\"my-value\\" to key \\"my-key\\" on namespace some-namespace-id."`
         );
         expect(std.err).toMatchInlineSnapshot(`""`);
-        expect(error).toMatchInlineSnapshot(`undefined`);
       });
 
       it("should put a key to the specified environment in a given namespace", async () => {
         writeWranglerConfig();
-        const requests = mockKeyPutRequest(
-          "env-bound-id",
-          "my-key",
-          "my-value"
-        );
+        const requests = mockKeyPutRequest("env-bound-id", {
+          key: "my-key",
+          value: "my-value",
+        });
         await runWrangler(
           "kv:key put my-key my-value --binding someBinding --env some-environment --preview false"
         );
         expect(std.out).toMatchInlineSnapshot(
-          `"writing the value \\"my-value\\" to key \\"my-key\\" on namespace env-bound-id"`
+          `"Writing the value \\"my-value\\" to key \\"my-key\\" on namespace env-bound-id."`
         );
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(requests.count).toEqual(1);
       });
 
       it("should put a key with a value loaded from a given path", async () => {
-        writeFileSync("foo.txt", "file-contents", "utf-8");
-        const requests = mockKeyPutRequest(
-          "some-namespace-id",
-          "my-key",
-          "file-contents"
-        );
+        const buf = Buffer.from("file-contents", "utf-8");
+        writeFileSync("foo.txt", buf);
+        const requests = mockKeyPutRequest("some-namespace-id", {
+          key: "my-key",
+          value: buf,
+        });
         await runWrangler(
           "kv:key put my-key --namespace-id some-namespace-id --path foo.txt"
         );
         expect(std.out).toMatchInlineSnapshot(
-          `"writing the contents of foo.txt to the key \\"my-key\\" on namespace some-namespace-id"`
+          `"Writing the contents of foo.txt to the key \\"my-key\\" on namespace some-namespace-id."`
+        );
+        expect(std.err).toMatchInlineSnapshot(`""`);
+        expect(requests.count).toEqual(1);
+      });
+
+      it("should put a key with a binary value loaded from a given path", async () => {
+        const buf = Buffer.from(
+          "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAiSURBVHgB7coxEQAACMPAgH/PgAM6dGwu49fA/deIBXrgAj2cAhIFT4QxAAAAAElFTkSuQmCC",
+          "base64"
+        );
+        writeFileSync("test.png", buf);
+        const requests = mockKeyPutRequest("another-namespace-id", {
+          key: "my-key",
+          value: buf,
+        });
+        await runWrangler(
+          "kv:key put my-key --namespace-id another-namespace-id --path test.png"
+        );
+        expect(std.out).toMatchInlineSnapshot(
+          `"Writing the contents of test.png to the key \\"my-key\\" on namespace another-namespace-id."`
         );
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(requests.count).toEqual(1);
       });
 
       it("should error if no key is provided", async () => {
-        let error: Error | undefined;
-        try {
-          await runWrangler("kv:key put");
-        } catch (e) {
-          error = e;
-        }
+        await expect(
+          runWrangler("kv:key put")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Not enough non-option arguments: got 0, need at least 1"`
+        );
 
-        expect(std.out).toMatchInlineSnapshot(`""`);
-        expect(std.err).toMatchInlineSnapshot(`
-          "wrangler kv:key put <key> [value]
+        expect(std.out).toMatchInlineSnapshot(`
+          "
+          wrangler kv:key put <key> [value]
 
           Writes a single key/value pair to the given namespace.
 
           Positionals:
-            key    The key to write to.  [string] [required]
-            value  The value to write.  [string]
+            key    The key to write to  [string] [required]
+            value  The value to write  [string]
 
           Flags:
             -c, --config   Path to .toml configuration file  [string]
@@ -497,39 +509,37 @@ describe("wrangler", () => {
             -v, --version  Show version number  [boolean]
 
           Options:
-            -l, --local         Run on my machine  [boolean] [default: false]
-                --binding       The binding of the namespace to write to.  [string]
-                --namespace-id  The id of the namespace to write to.  [string]
-                --env           Perform on a specific environment  [string]
+                --binding       The binding of the namespace to write to  [string]
+                --namespace-id  The id of the namespace to write to  [string]
+            -e, --env           Perform on a specific environment  [string]
                 --preview       Interact with a preview namespace  [boolean]
-                --ttl           Time for which the entries should be visible.  [number]
+                --ttl           Time for which the entries should be visible  [number]
                 --expiration    Time since the UNIX epoch after which the entry expires  [number]
-                --path          Read value from the file at a given path.  [string]
+                --path          Read value from the file at a given path  [string]"
+        `);
+        expect(std.err).toMatchInlineSnapshot(`
+          "X [ERROR] Not enough non-option arguments: got 0, need at least 1
 
-          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 () => {
-        let error: Error | undefined;
-        try {
-          await runWrangler("kv:key put foo bar");
-        } catch (e) {
-          error = e;
-        }
+        await expect(
+          runWrangler("kv:key put foo bar")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Exactly one of the arguments binding and namespace-id is required"`
+        );
 
-        expect(std.out).toMatchInlineSnapshot(`""`);
-        expect(std.err).toMatchInlineSnapshot(`
-          "wrangler kv:key put <key> [value]
+        expect(std.out).toMatchInlineSnapshot(`
+          "
+          wrangler kv:key put <key> [value]
 
           Writes a single key/value pair to the given namespace.
 
           Positionals:
-            key    The key to write to.  [string] [required]
-            value  The value to write.  [string]
+            key    The key to write to  [string] [required]
+            value  The value to write  [string]
 
           Flags:
             -c, --config   Path to .toml configuration file  [string]
@@ -537,39 +547,37 @@ describe("wrangler", () => {
             -v, --version  Show version number  [boolean]
 
           Options:
-            -l, --local         Run on my machine  [boolean] [default: false]
-                --binding       The binding of the namespace to write to.  [string]
-                --namespace-id  The id of the namespace to write to.  [string]
-                --env           Perform on a specific environment  [string]
+                --binding       The binding of the namespace to write to  [string]
+                --namespace-id  The id of the namespace to write to  [string]
+            -e, --env           Perform on a specific environment  [string]
                 --preview       Interact with a preview namespace  [boolean]
-                --ttl           Time for which the entries should be visible.  [number]
+                --ttl           Time for which the entries should be visible  [number]
                 --expiration    Time since the UNIX epoch after which the entry expires  [number]
-                --path          Read value from the file at a given path.  [string]
+                --path          Read value from the file at a given path  [string]"
+        `);
+        expect(std.err).toMatchInlineSnapshot(`
+          "X [ERROR] Exactly one of the arguments binding and namespace-id is required
 
-          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 () => {
-        let error: Error | undefined;
-        try {
-          await runWrangler("kv:key put foo bar --binding x --namespace-id y");
-        } catch (e) {
-          error = e;
-        }
+        await expect(
+          runWrangler("kv:key put foo bar --binding x --namespace-id y")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Arguments binding and namespace-id are mutually exclusive"`
+        );
 
-        expect(std.out).toMatchInlineSnapshot(`""`);
-        expect(std.err).toMatchInlineSnapshot(`
-          "wrangler kv:key put <key> [value]
+        expect(std.out).toMatchInlineSnapshot(`
+          "
+          wrangler kv:key put <key> [value]
 
           Writes a single key/value pair to the given namespace.
 
           Positionals:
-            key    The key to write to.  [string] [required]
-            value  The value to write.  [string]
+            key    The key to write to  [string] [required]
+            value  The value to write  [string]
 
           Flags:
             -c, --config   Path to .toml configuration file  [string]
@@ -577,39 +585,37 @@ describe("wrangler", () => {
             -v, --version  Show version number  [boolean]
 
           Options:
-            -l, --local         Run on my machine  [boolean] [default: false]
-                --binding       The binding of the namespace to write to.  [string]
-                --namespace-id  The id of the namespace to write to.  [string]
-                --env           Perform on a specific environment  [string]
+                --binding       The binding of the namespace to write to  [string]
+                --namespace-id  The id of the namespace to write to  [string]
+            -e, --env           Perform on a specific environment  [string]
                 --preview       Interact with a preview namespace  [boolean]
-                --ttl           Time for which the entries should be visible.  [number]
+                --ttl           Time for which the entries should be visible  [number]
                 --expiration    Time since the UNIX epoch after which the entry expires  [number]
-                --path          Read value from the file at a given path.  [string]
+                --path          Read value from the file at a given path  [string]"
+        `);
+        expect(std.err).toMatchInlineSnapshot(`
+          "X [ERROR] Arguments binding and namespace-id are mutually exclusive
 
-          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 () => {
-        let error: Error | undefined;
-        try {
-          await runWrangler("kv:key put key --namespace-id 12345");
-        } catch (e) {
-          error = e;
-        }
+        await expect(
+          runWrangler("kv:key put key --namespace-id 12345")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Exactly one of the arguments value and path is required"`
+        );
 
-        expect(std.out).toMatchInlineSnapshot(`""`);
-        expect(std.err).toMatchInlineSnapshot(`
-          "wrangler kv:key put <key> [value]
+        expect(std.out).toMatchInlineSnapshot(`
+          "
+          wrangler kv:key put <key> [value]
 
           Writes a single key/value pair to the given namespace.
 
           Positionals:
-            key    The key to write to.  [string] [required]
-            value  The value to write.  [string]
+            key    The key to write to  [string] [required]
+            value  The value to write  [string]
 
           Flags:
             -c, --config   Path to .toml configuration file  [string]
@@ -617,41 +623,37 @@ describe("wrangler", () => {
             -v, --version  Show version number  [boolean]
 
           Options:
-            -l, --local         Run on my machine  [boolean] [default: false]
-                --binding       The binding of the namespace to write to.  [string]
-                --namespace-id  The id of the namespace to write to.  [string]
-                --env           Perform on a specific environment  [string]
+                --binding       The binding of the namespace to write to  [string]
+                --namespace-id  The id of the namespace to write to  [string]
+            -e, --env           Perform on a specific environment  [string]
                 --preview       Interact with a preview namespace  [boolean]
-                --ttl           Time for which the entries should be visible.  [number]
+                --ttl           Time for which the entries should be visible  [number]
                 --expiration    Time since the UNIX epoch after which the entry expires  [number]
-                --path          Read value from the file at a given path.  [string]
+                --path          Read value from the file at a given path  [string]"
+        `);
+        expect(std.err).toMatchInlineSnapshot(`
+          "X [ERROR] Exactly one of the arguments value and path is required
 
-          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 () => {
-        let error: Error | undefined;
-        try {
-          await runWrangler(
-            "kv:key put key value --path xyz --namespace-id 12345"
-          );
-        } catch (e) {
-          error = e;
-        }
+        await expect(
+          runWrangler("kv:key put key value --path xyz --namespace-id 12345")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Arguments value and path are mutually exclusive"`
+        );
 
-        expect(std.out).toMatchInlineSnapshot(`""`);
-        expect(std.err).toMatchInlineSnapshot(`
-          "wrangler kv:key put <key> [value]
+        expect(std.out).toMatchInlineSnapshot(`
+          "
+          wrangler kv:key put <key> [value]
 
           Writes a single key/value pair to the given namespace.
 
           Positionals:
-            key    The key to write to.  [string] [required]
-            value  The value to write.  [string]
+            key    The key to write to  [string] [required]
+            value  The value to write  [string]
 
           Flags:
             -c, --config   Path to .toml configuration file  [string]
@@ -659,92 +661,86 @@ describe("wrangler", () => {
             -v, --version  Show version number  [boolean]
 
           Options:
-            -l, --local         Run on my machine  [boolean] [default: false]
-                --binding       The binding of the namespace to write to.  [string]
-                --namespace-id  The id of the namespace to write to.  [string]
-                --env           Perform on a specific environment  [string]
+                --binding       The binding of the namespace to write to  [string]
+                --namespace-id  The id of the namespace to write to  [string]
+            -e, --env           Perform on a specific environment  [string]
                 --preview       Interact with a preview namespace  [boolean]
-                --ttl           Time for which the entries should be visible.  [number]
+                --ttl           Time for which the entries should be visible  [number]
                 --expiration    Time since the UNIX epoch after which the entry expires  [number]
-                --path          Read value from the file at a given path.  [string]
+                --path          Read value from the file at a given path  [string]"
+        `);
+        expect(std.err).toMatchInlineSnapshot(`
+          "X [ERROR] Arguments value and path are mutually exclusive
 
-          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();
-        let error: Error | undefined;
-        try {
-          await runWrangler("kv:key put key value --binding otherBinding");
-        } catch (e) {
-          error = e;
-        }
+        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(std.out).toMatchInlineSnapshot(`""`);
+        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"
+        `);
         expect(std.err).toMatchInlineSnapshot(`
-          "A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\".
+          "X [ERROR] 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(error).toMatchInlineSnapshot(
-          `[Error: A namespace with binding name "otherBinding" was not found in the configured "kv_namespaces".]`
-        );
       });
 
       it("should error if a given binding has both preview and non-preview and --preview is not specified", async () => {
         writeWranglerConfig();
-        const requests = mockKeyPutRequest(
-          "preview-bound-id",
-          "my-key",
-          "my-value"
+        const requests = mockKeyPutRequest("preview-bound-id", {
+          key: "my-key",
+          value: "my-value",
+        });
+        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."`
         );
-        let error: Error | undefined;
-        try {
-          await runWrangler("kv:key put my-key my-value --binding someBinding");
-        } catch (e) {
-          error = e;
-        }
-        expect(std.out).toMatchInlineSnapshot(`""`);
+        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"
+        `);
         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.
+          "X [ERROR] 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(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(requests.count).toEqual(0);
       });
     });
 
     describe("list", () => {
       it("should list the keys of a namespace specified by namespace-id", async () => {
-        const keys = ["key-1", "key-2", "key-3"];
+        const keys = [
+          { name: "key-1" },
+          { name: "key-2", expiration: 123456789 },
+          { name: "key-3", expiration_ttl: 666 },
+        ];
         mockKeyListRequest("some-namespace-id", keys);
         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-1\\"
             },
             {
               \\"name\\": \\"key-2\\",
-              \\"expiration\\": 123456789,
-              \\"metadata\\": {}
+              \\"expiration\\": 123456789
             },
             {
               \\"name\\": \\"key-3\\",
-              \\"expiration\\": 123456789,
-              \\"metadata\\": {}
+              \\"expiration_ttl\\": 666
             }
           ]"
         `);
@@ -752,7 +748,7 @@ describe("wrangler", () => {
 
       it("should list the keys of a namespace specified by binding", async () => {
         writeWranglerConfig();
-        const keys = ["key-1", "key-2", "key-3"];
+        const keys = [{ name: "key-1" }, { name: "key-2" }, { name: "key-3" }];
         mockKeyListRequest("bound-id", keys);
 
         await runWrangler("kv:key list --binding someBinding");
@@ -760,19 +756,13 @@ describe("wrangler", () => {
         expect(std.out).toMatchInlineSnapshot(`
           "[
             {
-              \\"name\\": \\"key-1\\",
-              \\"expiration\\": 123456789,
-              \\"metadata\\": {}
+              \\"name\\": \\"key-1\\"
             },
             {
-              \\"name\\": \\"key-2\\",
-              \\"expiration\\": 123456789,
-              \\"metadata\\": {}
+              \\"name\\": \\"key-2\\"
             },
             {
-              \\"name\\": \\"key-3\\",
-              \\"expiration\\": 123456789,
-              \\"metadata\\": {}
+              \\"name\\": \\"key-3\\"
             }
           ]"
         `);
@@ -780,26 +770,20 @@ describe("wrangler", () => {
 
       it("should list the keys of a preview namespace specified by binding", async () => {
         writeWranglerConfig();
-        const keys = ["key-1", "key-2", "key-3"];
+        const keys = [{ name: "key-1" }, { name: "key-2" }, { name: "key-3" }];
         mockKeyListRequest("preview-bound-id", keys);
         await runWrangler("kv:key list --binding someBinding --preview");
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(std.out).toMatchInlineSnapshot(`
           "[
             {
-              \\"name\\": \\"key-1\\",
-              \\"expiration\\": 123456789,
-              \\"metadata\\": {}
+              \\"name\\": \\"key-1\\"
             },
             {
-              \\"name\\": \\"key-2\\",
-              \\"expiration\\": 123456789,
-              \\"metadata\\": {}
+              \\"name\\": \\"key-2\\"
             },
             {
-              \\"name\\": \\"key-3\\",
-              \\"expiration\\": 123456789,
-              \\"metadata\\": {}
+              \\"name\\": \\"key-3\\"
             }
           ]"
         `);
@@ -807,7 +791,7 @@ describe("wrangler", () => {
 
       it("should list the keys of a namespace specified by binding, in a given environment", async () => {
         writeWranglerConfig();
-        const keys = ["key-1", "key-2", "key-3"];
+        const keys = [{ name: "key-1" }, { name: "key-2" }, { name: "key-3" }];
         mockKeyListRequest("env-bound-id", keys);
         await runWrangler(
           "kv:key list --binding someBinding --env some-environment"
@@ -816,19 +800,13 @@ describe("wrangler", () => {
         expect(std.out).toMatchInlineSnapshot(`
           "[
             {
-              \\"name\\": \\"key-1\\",
-              \\"expiration\\": 123456789,
-              \\"metadata\\": {}
+              \\"name\\": \\"key-1\\"
             },
             {
-              \\"name\\": \\"key-2\\",
-              \\"expiration\\": 123456789,
-              \\"metadata\\": {}
+              \\"name\\": \\"key-2\\"
             },
             {
-              \\"name\\": \\"key-3\\",
-              \\"expiration\\": 123456789,
-              \\"metadata\\": {}
+              \\"name\\": \\"key-3\\"
             }
           ]"
         `);
@@ -836,7 +814,7 @@ describe("wrangler", () => {
 
       it("should list the keys of a preview namespace specified by binding, in a given environment", async () => {
         writeWranglerConfig();
-        const keys = ["key-1", "key-2", "key-3"];
+        const keys = [{ name: "key-1" }, { name: "key-2" }, { name: "key-3" }];
         mockKeyListRequest("preview-env-bound-id", keys);
         await runWrangler(
           "kv:key list --binding someBinding --preview --env some-environment"
@@ -845,19 +823,13 @@ describe("wrangler", () => {
         expect(std.out).toMatchInlineSnapshot(`
           "[
             {
-              \\"name\\": \\"key-1\\",
-              \\"expiration\\": 123456789,
-              \\"metadata\\": {}
+              \\"name\\": \\"key-1\\"
             },
             {
-              \\"name\\": \\"key-2\\",
-              \\"expiration\\": 123456789,
-              \\"metadata\\": {}
+              \\"name\\": \\"key-2\\"
             },
             {
-              \\"name\\": \\"key-3\\",
-              \\"expiration\\": 123456789,
-              \\"metadata\\": {}
+              \\"name\\": \\"key-3\\"
             }
           ]"
         `);
@@ -874,9 +846,9 @@ describe("wrangler", () => {
         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[] = [];
+            const keys: NamespaceKeyInfo[] = [];
             for (let i = 0; i < 550; i++) {
-              keys.push("key-" + i);
+              keys.push({ name: "key-" + i });
             }
             // Ask for the keys in pages of size 100.
             const requests = mockKeyListRequest(
@@ -885,11 +857,9 @@ describe("wrangler", () => {
               100,
               blankCursorValue
             );
-            await runWrangler(
-              "kv:key list --namespace-id some-namespace-id --limit 100"
-            );
+            await runWrangler("kv:key list --namespace-id some-namespace-id");
             expect(std.err).toMatchInlineSnapshot(`""`);
-            expect(JSON.parse(std.out).map((k) => k.name)).toEqual(keys);
+            expect(JSON.parse(std.out)).toEqual(keys);
             expect(requests.count).toEqual(6);
           });
         });
@@ -897,106 +867,122 @@ describe("wrangler", () => {
 
       it("should error if a given binding name is not in the configured kv namespaces", async () => {
         writeWranglerConfig();
-        let error: Error | undefined;
-        try {
-          await runWrangler("kv:key list --binding otherBinding");
-        } catch (e) {
-          error = e;
-        }
-        expect(error).toMatchInlineSnapshot(
-          `[Error: A namespace with binding name "otherBinding" was not found in the configured "kv_namespaces".]`
+        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(std.err).toMatchInlineSnapshot(`
-          "A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\".
+          "X [ERROR] 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(`
+          "
+          If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new/choose"
         `);
-        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"
         );
         await runWrangler("kv:key get my-key --namespace-id some-namespace-id");
-        expect(std.out).toMatchInlineSnapshot(`"my-value"`);
+        expect(proc.write).toEqual(Buffer.from("my-value"));
+        expect(std.err).toMatchInlineSnapshot(`""`);
+      });
+
+      it("should get a binary file by key in a given namespace specified by namespace-id", async () => {
+        const buf = Buffer.from(
+          "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAiSURBVHgB7coxEQAACMPAgH/PgAM6dGwu49fA/deIBXrgAj2cAhIFT4QxAAAAAElFTkSuQmCC",
+          "base64"
+        );
+        setMockFetchKVGetValue(
+          "some-account-id",
+          "some-namespace-id",
+          "my-key",
+          buf
+        );
+        await runWrangler("kv:key get my-key --namespace-id some-namespace-id");
+        expect(proc.write).toEqual(buf);
         expect(std.err).toMatchInlineSnapshot(`""`);
-        expect(requests.count).toEqual(1);
       });
 
       it("should get a key in a given namespace specified by binding", async () => {
         writeWranglerConfig();
-        const requests = mockKeyGetRequest("bound-id", "my-key", "my-value");
+        setMockFetchKVGetValue(
+          "some-account-id",
+          "bound-id",
+          "my-key",
+          "my-value"
+        );
         await runWrangler(
           "kv:key get my-key --binding someBinding --preview false"
         );
-        expect(std.out).toMatchInlineSnapshot(`"my-value"`);
+        expect(proc.write).toEqual(Buffer.from("my-value"));
         expect(std.err).toMatchInlineSnapshot(`""`);
-        expect(requests.count).toEqual(1);
       });
 
       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"
         );
         await runWrangler("kv:key get my-key --binding someBinding --preview");
-        expect(std.out).toMatchInlineSnapshot(`"my-value"`);
+        expect(proc.write).toEqual(Buffer.from("my-value"));
         expect(std.err).toMatchInlineSnapshot(`""`);
-        expect(requests.count).toEqual(1);
       });
 
       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"
         );
         await runWrangler(
-          "kv:key get my-key my-value --binding someBinding --env some-environment --preview false"
+          "kv:key get my-key --binding someBinding --env some-environment --preview false"
         );
-        expect(std.out).toMatchInlineSnapshot(`"my-value"`);
+        expect(proc.write).toEqual(Buffer.from("my-value"));
+        expect(std.err).toMatchInlineSnapshot(`""`);
+      });
+
+      it("should encode the key in the api request to get a value", async () => {
+        setMockFetchKVGetValue(
+          "some-account-id",
+          "some-namespace-id",
+          "%2Fmy%2Ckey",
+          "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(`""`);
-        expect(requests.count).toEqual(1);
       });
 
       it("should error if no key is provided", async () => {
-        let error: Error | undefined;
-        try {
-          await runWrangler("kv:key get");
-        } catch (e) {
-          error = e;
-        }
-        expect(std.out).toMatchInlineSnapshot(`""`);
-        expect(std.err).toMatchInlineSnapshot(`
-          "wrangler kv:key get <key>
+        await expect(
+          runWrangler("kv:key get")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Not enough non-option arguments: got 0, need at least 1"`
+        );
+        expect(std.out).toMatchInlineSnapshot(`
+          "
+          wrangler kv:key get <key>
 
           Reads a single value by key from the given namespace.
 
@@ -1009,29 +995,27 @@ describe("wrangler", () => {
             -v, --version  Show version number  [boolean]
 
           Options:
-            -l, --local         Run on my machine  [boolean] [default: false]
                 --binding       The name of the namespace to get from  [string]
                 --namespace-id  The id of the namespace to get from  [string]
-                --env           Perform on a specific environment  [string]
-                --preview       Interact with a preview namespace  [boolean] [default: false]
+            -e, --env           Perform on a specific environment  [string]
+                --preview       Interact with a preview namespace  [boolean] [default: false]"
+        `);
+        expect(std.err).toMatchInlineSnapshot(`
+          "X [ERROR] Not enough non-option arguments: got 0, need at least 1
 
-          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 () => {
-        let error: Error | undefined;
-        try {
-          await runWrangler("kv:key get foo");
-        } catch (e) {
-          error = e;
-        }
-        expect(std.out).toMatchInlineSnapshot(`""`);
-        expect(std.err).toMatchInlineSnapshot(`
-          "wrangler kv:key get <key>
+        await expect(
+          runWrangler("kv:key get foo")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Exactly one of the arguments binding and namespace-id is required"`
+        );
+        expect(std.out).toMatchInlineSnapshot(`
+          "
+          wrangler kv:key get <key>
 
           Reads a single value by key from the given namespace.
 
@@ -1044,30 +1028,28 @@ describe("wrangler", () => {
             -v, --version  Show version number  [boolean]
 
           Options:
-            -l, --local         Run on my machine  [boolean] [default: false]
                 --binding       The name of the namespace to get from  [string]
                 --namespace-id  The id of the namespace to get from  [string]
-                --env           Perform on a specific environment  [string]
-                --preview       Interact with a preview namespace  [boolean] [default: false]
+            -e, --env           Perform on a specific environment  [string]
+                --preview       Interact with a preview namespace  [boolean] [default: false]"
+        `);
+        expect(std.err).toMatchInlineSnapshot(`
+          "X [ERROR] Exactly one of the arguments binding and namespace-id is required
 
-          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 () => {
-        let error: Error | undefined;
-        try {
-          await runWrangler("kv:key get foo --binding x --namespace-id y");
-        } catch (e) {
-          error = e;
-        }
+        await expect(
+          runWrangler("kv:key get foo --binding x --namespace-id y")
+        ).rejects.toThrowErrorMatchingInlineSnapshot(
+          `"Arguments binding and namespace-id are mutually exclusive"`
+        );
 
-        expect(std.out).toMatchInlineSnapshot(`""`);
-        expect(std.err).toMatchInlineSnapshot(`
-          "wrangler kv:key get <key>
+        expect(std.out).toMatchInlineSnapshot(`
+          "
+          wrangler kv:key get <key>
 
           Reads a single value by key from the given namespace.
 
@@ -1080,37 +1062,34 @@ describe("wrangler", () => {
             -v, --version  Show version number  [boolean]
 
           Options:
-            -l, --local         Run on my machine  [boolean] [default: false]
                 --binding       The name of the namespace to get from  [string]
                 --namespace-id  The id of the namespace to get from  [string]
-                --env           Perform on a specific environment  [string]
-                --preview       Interact with a preview namespace  [boolean] [default: false]
+            -e, --env           Perform on a specific environment  [string]
+                --preview       Interact with a preview namespace  [boolean] [default: false]"
+        `);
+        expect(std.err).toMatchInlineSnapshot(`
+          "X [ERROR] Arguments binding and namespace-id are mutually exclusive
 
-          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();
-        let error: Error | undefined;
-        try {
-          await runWrangler("kv:key get key --binding otherBinding");
-        } catch (e) {
-          error = e;
-        }
-        expect(std.out).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(std.out).toMatchInlineSnapshot(`
+          "
+          If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new/choose"
+        `);
         expect(std.err).toMatchInlineSnapshot(`
-          "A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\".
+          "X [ERROR] 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(error).toMatchInlineSnapshot(
-          `[Error: A namespace with binding name "otherBinding" was not found in the configured "kv_namespaces".]`
-        );
       });
     });
 
@@ -1142,6 +1121,16 @@ describe("wrangler", () => {
         expect(requests.count).toEqual(1);
       });
 
+      it("should encode the key in the api request to delete a value", async () => {
+        const requests = mockDeleteRequest("voyager", "%2FNCC-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."`
+        );
+        expect(std.err).toMatchInlineSnapshot(`""`);
+      });
+
       it("should delete a key in a namespace specified by binding name", async () => {
         writeWranglerConfig();
         const requests = mockDeleteRequest("bound-id", "someKey");
@@ -1162,22 +1151,17 @@ describe("wrangler", () => {
 
       it("should error if a given binding name is not in the configured kv namespaces", async () => {
         writeWranglerConfig();
-        let error: Error | undefined;
-        try {
-          await runWrangler(`kv:key delete --binding otherBinding someKey`);
-        } catch (e) {
-          error = e;
-        }
+        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\\".
+          "X [ERROR] 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(error).toMatchInlineSnapshot(
-          `[Error: A namespace with binding name "otherBinding" was not found in the configured "kv_namespaces".]`
-        );
       });
 
       it("should delete a key in a namespace specified by binding name in a given environment", async () => {
@@ -1187,7 +1171,7 @@ describe("wrangler", () => {
           `kv:key delete --binding someBinding --env some-environment --preview false someKey`
         );
         expect(std.out).toMatchInlineSnapshot(
-          `"deleting the key \\"someKey\\" on namespace env-bound-id"`
+          `"Deleting the key \\"someKey\\" on namespace env-bound-id."`
         );
         expect(std.err).toMatchInlineSnapshot(`""`);
         expect(requests.count).toEqual(1);
@@ -1203,13 +1187,325 @@ describe("wrangler", () => {
       });
     });
   });
+
+  describe("kv:bulk", () => {
+    describe("put", () => {
+      function mockPutRequest(
+        expectedNamespaceId: string,
+        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;
+          }
+        );
+        return requests;
+      }
+
+      it("should put the key-values parsed from a file", async () => {
+        const keyValues: KeyValue[] = [
+          { key: "someKey1", value: "someValue1" },
+          { key: "ns:someKey2", value: "123", base64: true },
+          { key: "someKey3", value: "someValue3", expiration: 100 },
+          { key: "someKey4", value: "someValue4", expiration_ttl: 500 },
+        ];
+        writeFileSync("./keys.json", JSON.stringify(keyValues));
+        const requests = mockPutRequest("some-namespace-id", keyValues);
+        await runWrangler(
+          `kv:bulk put --namespace-id some-namespace-id keys.json`
+        );
+        expect(requests.count).toEqual(1);
+        expect(std.out).toMatchInlineSnapshot(`"Success!"`);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+      });
+
+      it("should put the key-values in batches of 5000 parsed from a file", async () => {
+        const keyValues: KeyValue[] = new Array(12000).fill({
+          key: "someKey1",
+          value: "someValue1",
+        });
+        writeFileSync("./keys.json", JSON.stringify(keyValues));
+        const requests = mockPutRequest("some-namespace-id", keyValues);
+        await runWrangler(
+          `kv:bulk put --namespace-id some-namespace-id keys.json`
+        );
+        expect(requests.count).toEqual(3);
+        expect(std.out).toMatchInlineSnapshot(`
+          "Uploaded 0% (0 out of 12,000)
+          Uploaded 41% (5,000 out of 12,000)
+          Uploaded 83% (10,000 out of 12,000)
+          Uploaded 100% (12,000 out of 12,000)
+          Success!"
+        `);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+      });
+
+      it("should error if the file is not a JSON array", async () => {
+        const keyValues = { key: "someKey1", value: "someValue1" };
+        writeFileSync("./keys.json", JSON.stringify(keyValues));
+        await expect(
+          runWrangler(`kv:bulk put --namespace-id some-namespace-id keys.json`)
+        ).rejects.toThrowErrorMatchingInlineSnapshot(`
+                "Unexpected JSON input from \\"keys.json\\".
+                Expected an array of key-value objects but got type \\"object\\"."
+              `);
+        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"
+        `);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+      });
+
+      it("should error if the array contains items that are not key-value objects", async () => {
+        const keyValues = [
+          123,
+          "a string",
+          { key: "someKey" },
+          { value: "someValue" },
+          // add a valid object here to make sure it's not included
+          { key: "someKey1", value: "someValue1" },
+          // this one will only add a warning
+          { key: "someKey1", value: "someValue1", invalid: true },
+          // back to the invalid ones
+          { key: 123, value: "somevalue" },
+          { key: "somekey", value: 123 },
+          { key: "someKey1", value: "someValue1", expiration: "string" },
+          { key: "someKey1", value: "someValue1", expiration_ttl: "string" },
+          {
+            key: 123,
+            value: {
+              a: {
+                nested: "object",
+              },
+            },
+          },
+          { key: "someKey1", value: "someValue1", metadata: 123 },
+          { key: "someKey1", value: "someValue1", base64: "string" },
+        ];
+        writeFileSync("./keys.json", JSON.stringify(keyValues));
+        await expect(
+          runWrangler(`kv:bulk put --namespace-id some-namespace-id keys.json`)
+        ).rejects.toThrowErrorMatchingInlineSnapshot(`
+                "Unexpected JSON input from \\"keys.json\\".
+                Each item in the array should be an object that matches:
+
+                interface KeyValue {
+                  key: string;
+                  value: string;
+                  expiration?: number;
+                  expiration_ttl?: number;
+                  metadata?: object;
+                  base64?: boolean;
+                }
+
+                The item at index 0 is 123
+                The item at index 1 is \\"a string\\"
+                The item at index 2 is {\\"key\\":\\"someKey\\"}
+                The item at index 3 is {\\"value\\":\\"someValue\\"}
+                The item at index 6 is {\\"key\\":123,\\"value\\":\\"somevalue\\"}
+                The item at index 7 is {\\"key\\":\\"somekey\\",\\"value\\":123}
+                The item at index 8 is {\\"key\\":\\"someKey1\\",\\"value\\":\\"someValue1\\",\\"expiration\\":\\"string\\"}
+                The item at index 9 is {\\"key\\":\\"someKey1\\",\\"value\\":\\"someValue1\\",\\"expiration_ttl\\":\\"string\\"}
+                The item at index 10 is {\\"key\\":123,\\"value\\":{\\"a\\":{\\"nested\\":\\"object\\"}}}
+                The item at index 11 is {\\"key\\":\\"someKey1\\",\\"value\\":\\"someValue1\\",\\"metadata\\":123}
+                The item at index 12 is {\\"key\\":\\"someKey1\\",\\"value\\":\\"someValue1\\",\\"base64\\":\\"string\\"}"
+              `);
+
+        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"
+        `);
+        expect(std.warn).toMatchInlineSnapshot(`
+          "▲ [WARNING] Unexpected key-value properties in \\"keys.json\\".
+
+            The item at index 5 contains unexpected properties: [\\"invalid\\"].
+
+          "
+        `);
+      });
+    });
+
+    describe("delete", () => {
+      function mockDeleteRequest(
+        expectedNamespaceId: string,
+        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;
+          }
+        );
+        return requests;
+      }
+
+      it("should delete the keys parsed from a file", async () => {
+        const keys = ["someKey1", "ns:someKey2"];
+        writeFileSync("./keys.json", JSON.stringify(keys));
+        mockConfirm({
+          text: `Are you sure you want to delete all the keys read from "keys.json" from kv-namespace with id "some-namespace-id"?`,
+          result: true,
+        });
+        const requests = mockDeleteRequest("some-namespace-id", keys);
+        await runWrangler(
+          `kv:bulk delete --namespace-id some-namespace-id keys.json`
+        );
+        expect(requests.count).toEqual(1);
+        expect(std.out).toMatchInlineSnapshot(`"Success!"`);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+      });
+
+      it("should delete the keys in batches of 5000 parsed from a file", async () => {
+        const keys = new Array(12000).fill("some-key");
+        writeFileSync("./keys.json", JSON.stringify(keys));
+        mockConfirm({
+          text: `Are you sure you want to delete all the keys read from "keys.json" from kv-namespace with id "some-namespace-id"?`,
+          result: true,
+        });
+        const requests = mockDeleteRequest("some-namespace-id", keys);
+        await runWrangler(
+          `kv:bulk delete --namespace-id some-namespace-id keys.json`
+        );
+        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!"
+        `);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+      });
+
+      it("should not delete the keys if the user confirms no", async () => {
+        const keys = ["someKey1", "ns:someKey2"];
+        writeFileSync("./keys.json", JSON.stringify(keys));
+        mockConfirm({
+          text: `Are you sure you want to delete all the keys read from "keys.json" from kv-namespace with id "some-namespace-id"?`,
+          result: false,
+        });
+        await runWrangler(
+          `kv:bulk delete --namespace-id some-namespace-id keys.json`
+        );
+        expect(std.out).toMatchInlineSnapshot(
+          `"Not deleting keys read from \\"keys.json\\"."`
+        );
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+      });
+
+      it("should delete the keys without asking if --force is provided", async () => {
+        const keys = ["someKey1", "ns:someKey2"];
+        writeFileSync("./keys.json", JSON.stringify(keys));
+        const requests = mockDeleteRequest("some-namespace-id", keys);
+        await runWrangler(
+          `kv:bulk delete --namespace-id some-namespace-id keys.json --force`
+        );
+        expect(requests.count).toEqual(1);
+        expect(std.out).toMatchInlineSnapshot(`"Success!"`);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+      });
+
+      it("should delete the keys without asking if -f is provided", async () => {
+        const keys = ["someKey1", "ns:someKey2"];
+        writeFileSync("./keys.json", JSON.stringify(keys));
+        const requests = mockDeleteRequest("some-namespace-id", keys);
+        await runWrangler(
+          `kv:bulk delete --namespace-id some-namespace-id keys.json -f`
+        );
+        expect(requests.count).toEqual(1);
+        expect(std.out).toMatchInlineSnapshot(`"Success!"`);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+      });
+
+      it("should error if the file is not a JSON array", async () => {
+        const keys = 12354;
+        writeFileSync("./keys.json", JSON.stringify(keys));
+        mockConfirm({
+          text: `Are you sure you want to delete all the keys read from "keys.json" from kv-namespace with id "some-namespace-id"?`,
+          result: true,
+        });
+        await expect(
+          runWrangler(
+            `kv:bulk delete --namespace-id some-namespace-id keys.json`
+          )
+        ).rejects.toThrowErrorMatchingInlineSnapshot(`
+                "Unexpected JSON input from \\"keys.json\\".
+                Expected an array of strings but got:
+                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"
+        `);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+      });
+
+      it("should error if the file contains non-string items", async () => {
+        const keys = ["good", 12354, { key: "someKey" }, null];
+        writeFileSync("./keys.json", JSON.stringify(keys));
+        mockConfirm({
+          text: `Are you sure you want to delete all the keys read from "keys.json" from kv-namespace with id "some-namespace-id"?`,
+          result: true,
+        });
+        await expect(
+          runWrangler(
+            `kv:bulk delete --namespace-id some-namespace-id keys.json`
+          )
+        ).rejects.toThrowErrorMatchingInlineSnapshot(`
+                "Unexpected JSON input from \\"keys.json\\".
+                Expected an array of strings.
+                The item at index 1 is type: \\"number\\" - 12354
+                The item at index 2 is type: \\"object\\" - {\\"key\\":\\"someKey\\"}
+                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"
+        `);
+        expect(std.warn).toMatchInlineSnapshot(`""`);
+      });
+    });
+  });
 });
 
 function writeWranglerConfig() {
   writeFileSync(
     "./wrangler.toml",
     [
-      'name = "otherWorker"',
+      'name = "other-worker"',
       "kv_namespaces = [",
       '  { binding = "someBinding", id = "bound-id", preview_id = "preview-bound-id" }',
       "]",