wrangler 0.0.0-e9ab55a → 0.0.0-ea7ee45

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (197) hide show
  1. package/Cloudflare_CA.pem +18 -0
  2. package/README.md +33 -14
  3. package/bin/wrangler.js +123 -25
  4. package/kv-asset-handler.js +1 -0
  5. package/miniflare-dist/index.mjs +4893 -0
  6. package/package.json +156 -125
  7. package/src/__tests__/config-cache.test.ts +36 -0
  8. package/src/__tests__/configuration.test.ts +3829 -0
  9. package/src/__tests__/dev.test.tsx +1155 -63
  10. package/src/__tests__/guess-worker-format.test.ts +85 -0
  11. package/src/__tests__/{clipboardy-mock.js → helpers/clipboardy-mock.js} +0 -0
  12. package/src/__tests__/helpers/cmd-shim.d.ts +11 -0
  13. package/src/__tests__/helpers/faye-websocket.d.ts +6 -0
  14. package/src/__tests__/helpers/mock-account-id.ts +48 -0
  15. package/src/__tests__/helpers/mock-bin.ts +36 -0
  16. package/src/__tests__/helpers/mock-cfetch.ts +211 -0
  17. package/src/__tests__/helpers/mock-console.ts +97 -0
  18. package/src/__tests__/helpers/mock-dialogs.ts +153 -0
  19. package/src/__tests__/helpers/mock-http-server.ts +46 -0
  20. package/src/__tests__/helpers/mock-istty.ts +74 -0
  21. package/src/__tests__/helpers/mock-kv.ts +33 -0
  22. package/src/__tests__/helpers/mock-oauth-flow.ts +250 -0
  23. package/src/__tests__/helpers/mock-process.ts +39 -0
  24. package/src/__tests__/helpers/mock-stdin.ts +108 -0
  25. package/src/__tests__/helpers/mock-web-socket.ts +29 -0
  26. package/src/__tests__/helpers/run-in-tmp.ts +39 -0
  27. package/src/__tests__/helpers/run-wrangler.ts +16 -0
  28. package/src/__tests__/helpers/write-worker-source.ts +31 -0
  29. package/src/__tests__/helpers/write-wrangler-toml.ts +17 -0
  30. package/src/__tests__/https-options.test.ts +130 -0
  31. package/src/__tests__/index.test.ts +259 -284
  32. package/src/__tests__/init.test.ts +1992 -0
  33. package/src/__tests__/jest.setup.ts +95 -10
  34. package/src/__tests__/kv.test.ts +1402 -909
  35. package/src/__tests__/logger.test.ts +141 -0
  36. package/src/__tests__/package-manager.test.ts +353 -0
  37. package/src/__tests__/pages.test.ts +1254 -0
  38. package/src/__tests__/parse.test.ts +330 -0
  39. package/src/__tests__/publish.test.ts +6504 -93
  40. package/src/__tests__/pubsub.test.ts +276 -0
  41. package/src/__tests__/r2.test.ts +233 -0
  42. package/src/__tests__/route.test.ts +45 -0
  43. package/src/__tests__/secret.test.ts +486 -0
  44. package/src/__tests__/tail.test.ts +690 -0
  45. package/src/__tests__/user.test.ts +143 -0
  46. package/src/__tests__/whoami.test.tsx +220 -0
  47. package/src/__tests__/worker-namespace.test.ts +327 -0
  48. package/src/abort.d.ts +3 -0
  49. package/src/api/dev.ts +39 -0
  50. package/src/api/index.ts +1 -0
  51. package/src/bundle-reporter.tsx +29 -0
  52. package/src/bundle.ts +212 -0
  53. package/src/cfetch/index.ts +88 -69
  54. package/src/cfetch/internal.ts +124 -44
  55. package/src/cli.ts +24 -6
  56. package/src/config/README.md +107 -0
  57. package/src/config/config.ts +243 -0
  58. package/src/config/diagnostics.ts +80 -0
  59. package/src/config/environment.ts +430 -0
  60. package/src/config/index.ts +225 -0
  61. package/src/config/validation-helpers.ts +584 -0
  62. package/src/config/validation.ts +1693 -0
  63. package/src/config-cache.ts +44 -0
  64. package/src/create-worker-preview.ts +255 -0
  65. package/src/create-worker-upload-form.ts +254 -0
  66. package/src/dev/dev-vars.ts +36 -0
  67. package/src/dev/dev.tsx +417 -0
  68. package/src/dev/local.tsx +350 -0
  69. package/src/dev/remote.tsx +367 -0
  70. package/src/dev/use-esbuild.ts +150 -0
  71. package/src/dev.tsx +515 -773
  72. package/src/dialogs.tsx +117 -59
  73. package/src/durable.ts +102 -0
  74. package/src/entry.ts +328 -0
  75. package/src/environment-variables.ts +35 -0
  76. package/src/errors.ts +11 -0
  77. package/src/generate.ts +33 -0
  78. package/src/git-client.ts +42 -0
  79. package/src/https-options.ts +123 -0
  80. package/src/index.tsx +1844 -1901
  81. package/src/init.ts +549 -0
  82. package/src/inspect.ts +615 -496
  83. package/src/intl-polyfill.d.ts +139 -0
  84. package/src/kv.ts +408 -0
  85. package/src/logger.ts +73 -0
  86. package/src/miniflare-cli/README.md +30 -0
  87. package/src/miniflare-cli/enum-keys.ts +17 -0
  88. package/src/miniflare-cli/index.ts +52 -0
  89. package/src/miniflare-cli/request-context.ts +40 -0
  90. package/src/module-collection.ts +247 -53
  91. package/src/open-in-browser.ts +17 -0
  92. package/src/package-manager.ts +174 -0
  93. package/src/pages/build.tsx +202 -0
  94. package/src/pages/constants.ts +7 -0
  95. package/src/pages/deployments.tsx +101 -0
  96. package/src/pages/dev.tsx +964 -0
  97. package/src/pages/functions/buildPlugin.ts +105 -0
  98. package/src/pages/functions/buildWorker.ts +151 -0
  99. package/src/pages/functions/filepath-routing.test.ts +234 -0
  100. package/src/pages/functions/filepath-routing.ts +189 -0
  101. package/src/pages/functions/identifiers.ts +78 -0
  102. package/src/pages/functions/routes.ts +151 -0
  103. package/src/pages/index.tsx +84 -0
  104. package/src/pages/projects.tsx +157 -0
  105. package/src/pages/publish.tsx +335 -0
  106. package/src/pages/types.ts +40 -0
  107. package/src/pages/upload.tsx +384 -0
  108. package/src/pages/utils.ts +12 -0
  109. package/src/parse.ts +286 -0
  110. package/src/paths.ts +26 -0
  111. package/src/preview.ts +31 -0
  112. package/src/proxy.ts +428 -254
  113. package/src/publish.ts +750 -366
  114. package/src/pubsub/index.ts +286 -0
  115. package/src/pubsub/pubsub-commands.tsx +594 -0
  116. package/src/r2.ts +50 -0
  117. package/src/selfsigned.d.ts +29 -0
  118. package/src/sites.tsx +357 -103
  119. package/src/tail/filters.ts +279 -0
  120. package/src/tail/index.ts +299 -0
  121. package/src/tail/printing.ts +67 -0
  122. package/src/update-check.ts +19 -0
  123. package/src/user/choose-account.tsx +60 -0
  124. package/src/user/env-vars.ts +46 -0
  125. package/src/user/generate-auth-url.ts +33 -0
  126. package/src/user/generate-random-state.ts +16 -0
  127. package/src/user/index.ts +3 -0
  128. package/src/user/user.tsx +1130 -0
  129. package/src/whoami.tsx +90 -0
  130. package/src/worker-namespace.ts +190 -0
  131. package/src/worker.ts +185 -0
  132. package/src/zones.ts +76 -0
  133. package/templates/checked-fetch.js +17 -0
  134. package/templates/gitignore +171 -0
  135. package/templates/new-worker-scheduled.js +17 -0
  136. package/templates/new-worker-scheduled.ts +32 -0
  137. package/templates/new-worker.js +15 -0
  138. package/templates/new-worker.ts +30 -0
  139. package/templates/no-op-worker.js +10 -0
  140. package/templates/pages-template-plugin.ts +155 -0
  141. package/templates/pages-template-worker.ts +161 -0
  142. package/templates/static-asset-facade.js +43 -0
  143. package/templates/tsconfig.json +105 -0
  144. package/wrangler-dist/cli.js +107117 -103435
  145. package/pages/functions/buildWorker.ts +0 -62
  146. package/pages/functions/filepath-routing.test.ts +0 -39
  147. package/pages/functions/filepath-routing.ts +0 -228
  148. package/pages/functions/identifiers.ts +0 -78
  149. package/pages/functions/routes.ts +0 -158
  150. package/pages/functions/template-worker.ts +0 -136
  151. package/src/__tests__/mock-cfetch.ts +0 -171
  152. package/src/__tests__/mock-dialogs.ts +0 -65
  153. package/src/__tests__/run-in-tmp.ts +0 -19
  154. package/src/__tests__/run-wrangler.ts +0 -32
  155. package/src/api/form_data.ts +0 -131
  156. package/src/api/preview.ts +0 -128
  157. package/src/api/worker.ts +0 -155
  158. package/src/config.ts +0 -646
  159. package/src/kv.tsx +0 -276
  160. package/src/pages.tsx +0 -1040
  161. package/src/tail.tsx +0 -73
  162. package/src/user.tsx +0 -1027
  163. package/static-asset-facade.js +0 -47
  164. package/vendor/@cloudflare/kv-asset-handler/CHANGELOG.md +0 -332
  165. package/vendor/@cloudflare/kv-asset-handler/LICENSE_APACHE +0 -176
  166. package/vendor/@cloudflare/kv-asset-handler/LICENSE_MIT +0 -25
  167. package/vendor/@cloudflare/kv-asset-handler/README.md +0 -245
  168. package/vendor/@cloudflare/kv-asset-handler/dist/index.d.ts +0 -32
  169. package/vendor/@cloudflare/kv-asset-handler/dist/index.js +0 -354
  170. package/vendor/@cloudflare/kv-asset-handler/dist/mocks.d.ts +0 -13
  171. package/vendor/@cloudflare/kv-asset-handler/dist/mocks.js +0 -148
  172. package/vendor/@cloudflare/kv-asset-handler/dist/test/getAssetFromKV.d.ts +0 -1
  173. package/vendor/@cloudflare/kv-asset-handler/dist/test/getAssetFromKV.js +0 -436
  174. package/vendor/@cloudflare/kv-asset-handler/dist/test/mapRequestToAsset.d.ts +0 -1
  175. package/vendor/@cloudflare/kv-asset-handler/dist/test/mapRequestToAsset.js +0 -40
  176. package/vendor/@cloudflare/kv-asset-handler/dist/test/serveSinglePageApp.d.ts +0 -1
  177. package/vendor/@cloudflare/kv-asset-handler/dist/test/serveSinglePageApp.js +0 -42
  178. package/vendor/@cloudflare/kv-asset-handler/dist/types.d.ts +0 -26
  179. package/vendor/@cloudflare/kv-asset-handler/dist/types.js +0 -31
  180. package/vendor/@cloudflare/kv-asset-handler/package.json +0 -52
  181. package/vendor/@cloudflare/kv-asset-handler/src/index.ts +0 -296
  182. package/vendor/@cloudflare/kv-asset-handler/src/mocks.ts +0 -136
  183. package/vendor/@cloudflare/kv-asset-handler/src/test/getAssetFromKV.ts +0 -464
  184. package/vendor/@cloudflare/kv-asset-handler/src/test/mapRequestToAsset.ts +0 -33
  185. package/vendor/@cloudflare/kv-asset-handler/src/test/serveSinglePageApp.ts +0 -42
  186. package/vendor/@cloudflare/kv-asset-handler/src/types.ts +0 -39
  187. package/vendor/wrangler-mime/CHANGELOG.md +0 -289
  188. package/vendor/wrangler-mime/LICENSE +0 -21
  189. package/vendor/wrangler-mime/Mime.js +0 -97
  190. package/vendor/wrangler-mime/README.md +0 -187
  191. package/vendor/wrangler-mime/cli.js +0 -46
  192. package/vendor/wrangler-mime/index.js +0 -4
  193. package/vendor/wrangler-mime/lite.js +0 -4
  194. package/vendor/wrangler-mime/package.json +0 -52
  195. package/vendor/wrangler-mime/types/other.js +0 -1
  196. package/vendor/wrangler-mime/types/standard.js +0 -1
  197. package/wrangler-dist/cli.js.map +0 -7
@@ -1,47 +1,58 @@
1
- import { writeFileSync } from "fs";
1
+ import { writeFileSync } from "node:fs";
2
+ import { Headers } from "undici";
3
+ import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
2
4
  import {
3
- setMockResponse,
4
- setMockRawResponse,
5
- unsetAllMocks,
6
- createFetchResult,
7
- } from "./mock-cfetch";
8
- import { runWrangler } from "./run-wrangler";
9
- import { runInTempDir } from "./run-in-tmp";
10
-
11
- interface KVNamespaceInfo {
12
- title: string;
13
- id: string;
14
- }
5
+ setMockResponse,
6
+ unsetAllMocks,
7
+ unsetMockFetchKVGetValues,
8
+ setMockFetchKVGetValue,
9
+ } from "./helpers/mock-cfetch";
10
+ import { mockConsoleMethods } from "./helpers/mock-console";
11
+ import { clearConfirmMocks, mockConfirm } from "./helpers/mock-dialogs";
12
+ import { useMockIsTTY } from "./helpers/mock-istty";
13
+ import { mockKeyListRequest } from "./helpers/mock-kv";
14
+ import { mockGetMemberships } from "./helpers/mock-oauth-flow";
15
+ import { mockProcess } from "./helpers/mock-process";
16
+ import { runInTempDir } from "./helpers/run-in-tmp";
17
+ import { runWrangler } from "./helpers/run-wrangler";
18
+ import type { KeyValue, KVNamespaceInfo, NamespaceKeyInfo } from "../kv";
15
19
 
16
20
  describe("wrangler", () => {
17
- runInTempDir();
18
-
19
- afterEach(() => {
20
- unsetAllMocks();
21
- });
22
-
23
- describe("kv:namespace", () => {
24
- describe("create", () => {
25
- function mockCreateRequest(expectedTitle: string) {
26
- setMockResponse(
27
- "/accounts/:accountId/storage/kv/namespaces",
28
- "POST",
29
- ([_url, accountId], { body }) => {
30
- expect(accountId).toEqual("some-account-id");
31
- const title = JSON.parse(body as string).title;
32
- expect(title).toEqual(expectedTitle);
33
- return { id: "some-namespace-id" };
34
- }
35
- );
36
- }
37
-
38
- it("should error if no namespace is given", async () => {
39
- const { error, stdout, stderr } = await runWrangler(
40
- "kv:namespace create"
41
- );
42
- expect(stdout).toMatchInlineSnapshot(`""`);
43
- expect(stderr).toMatchInlineSnapshot(`
44
- "wrangler kv:namespace create <namespace>
21
+ mockAccountId();
22
+ mockApiToken();
23
+ runInTempDir();
24
+ const std = mockConsoleMethods();
25
+ const proc = mockProcess();
26
+
27
+ afterEach(() => {
28
+ unsetAllMocks();
29
+ clearConfirmMocks();
30
+ });
31
+
32
+ describe("kv:namespace", () => {
33
+ describe("create", () => {
34
+ function mockCreateRequest(expectedTitle: string) {
35
+ setMockResponse(
36
+ "/accounts/:accountId/storage/kv/namespaces",
37
+ "POST",
38
+ ([_url, accountId], { body }) => {
39
+ expect(accountId).toEqual("some-account-id");
40
+ const title = JSON.parse(body as string).title;
41
+ expect(title).toEqual(expectedTitle);
42
+ return { id: "some-namespace-id" };
43
+ }
44
+ );
45
+ }
46
+
47
+ it("should error if no namespace is given", async () => {
48
+ await expect(
49
+ runWrangler("kv:namespace create")
50
+ ).rejects.toThrowErrorMatchingInlineSnapshot(
51
+ `"Not enough non-option arguments: got 0, need at least 1"`
52
+ );
53
+ expect(std.out).toMatchInlineSnapshot(`
54
+ "
55
+ wrangler kv:namespace create <namespace>
45
56
 
46
57
  Create a new namespace
47
58
 
@@ -54,24 +65,25 @@ describe("wrangler", () => {
54
65
  -v, --version Show version number [boolean]
55
66
 
56
67
  Options:
57
- -l, --local Run on my machine [boolean] [default: false]
58
- --env Perform on a specific environment [string]
59
- --preview Interact with a preview namespace [boolean]
68
+ -e, --env Perform on a specific environment [string]
69
+ --preview Interact with a preview namespace [boolean]"
70
+ `);
71
+ expect(std.err).toMatchInlineSnapshot(`
72
+ "X [ERROR] Not enough non-option arguments: got 0, need at least 1
60
73
 
61
- Not enough non-option arguments: got 0, need at least 1"
74
+ "
62
75
  `);
63
- expect(error).toMatchInlineSnapshot(
64
- `[Error: Not enough non-option arguments: got 0, need at least 1]`
65
- );
66
- });
67
-
68
- it("should error if the namespace to create contains spaces", async () => {
69
- const { error, stdout, stderr } = await runWrangler(
70
- "kv:namespace create abc def ghi"
71
- );
72
- expect(stdout).toMatchInlineSnapshot(`""`);
73
- expect(stderr).toMatchInlineSnapshot(`
74
- "wrangler kv:namespace create <namespace>
76
+ });
77
+
78
+ it("should error if the namespace to create contains spaces", async () => {
79
+ await expect(
80
+ runWrangler("kv:namespace create abc def ghi")
81
+ ).rejects.toThrowErrorMatchingInlineSnapshot(
82
+ `"Unknown arguments: def, ghi"`
83
+ );
84
+ expect(std.out).toMatchInlineSnapshot(`
85
+ "
86
+ wrangler kv:namespace create <namespace>
75
87
 
76
88
  Create a new namespace
77
89
 
@@ -84,24 +96,26 @@ describe("wrangler", () => {
84
96
  -v, --version Show version number [boolean]
85
97
 
86
98
  Options:
87
- -l, --local Run on my machine [boolean] [default: false]
88
- --env Perform on a specific environment [string]
89
- --preview Interact with a preview namespace [boolean]
99
+ -e, --env Perform on a specific environment [string]
100
+ --preview Interact with a preview namespace [boolean]"
101
+ `);
102
+ expect(std.err).toMatchInlineSnapshot(`
103
+ "X [ERROR] Unknown arguments: def, ghi
90
104
 
91
- Unexpected additional positional arguments \\"def ghi\\"."
105
+ "
92
106
  `);
93
- expect(error).toMatchInlineSnapshot(
94
- `[Error: Unexpected additional positional arguments "def ghi".]`
95
- );
96
- });
97
-
98
- it("should error if the namespace to create is not valid", async () => {
99
- const { error, stdout, stderr } = await runWrangler(
100
- "kv:namespace create abc-def"
101
- );
102
- expect(stdout).toMatchInlineSnapshot(`""`);
103
- expect(stderr).toMatchInlineSnapshot(`
104
- "wrangler kv:namespace create <namespace>
107
+ });
108
+
109
+ it("should error if the namespace to create is not valid", async () => {
110
+ await expect(
111
+ runWrangler("kv:namespace create abc-def")
112
+ ).rejects.toThrowErrorMatchingInlineSnapshot(
113
+ `"The namespace binding name \\"abc-def\\" is invalid. It can only have alphanumeric and _ characters, and cannot begin with a number."`
114
+ );
115
+
116
+ expect(std.out).toMatchInlineSnapshot(`
117
+ "
118
+ wrangler kv:namespace create <namespace>
105
119
 
106
120
  Create a new namespace
107
121
 
@@ -114,364 +128,382 @@ describe("wrangler", () => {
114
128
  -v, --version Show version number [boolean]
115
129
 
116
130
  Options:
117
- -l, --local Run on my machine [boolean] [default: false]
118
- --env Perform on a specific environment [string]
119
- --preview Interact with a preview namespace [boolean]
131
+ -e, --env Perform on a specific environment [string]
132
+ --preview Interact with a preview namespace [boolean]"
133
+ `);
134
+ expect(std.err).toMatchInlineSnapshot(`
135
+ "X [ERROR] The namespace binding name \\"abc-def\\" is invalid. It can only have alphanumeric and _ characters, and cannot begin with a number.
120
136
 
121
- The namespace binding name \\"abc-def\\" is invalid. It can only have alphanumeric and _ characters, and cannot begin with a number."
137
+ "
122
138
  `);
123
- expect(error).toMatchInlineSnapshot(
124
- `[Error: The namespace binding name "abc-def" is invalid. It can only have alphanumeric and _ characters, and cannot begin with a number.]`
125
- );
126
- });
127
-
128
- it("should create a namespace", async () => {
129
- mockCreateRequest("worker-UnitTestNamespace");
130
- const { stdout } = await runWrangler(
131
- "kv:namespace create UnitTestNamespace"
132
- );
133
- expect(stdout).toMatchInlineSnapshot(`
139
+ });
140
+
141
+ it("should create a namespace", async () => {
142
+ mockCreateRequest("worker-UnitTestNamespace");
143
+ await runWrangler("kv:namespace create UnitTestNamespace");
144
+ expect(std.out).toMatchInlineSnapshot(`
134
145
  "🌀 Creating namespace with title \\"worker-UnitTestNamespace\\"
135
146
  ✨ Success!
136
147
  Add the following to your configuration file in your kv_namespaces array:
137
148
  { binding = \\"UnitTestNamespace\\", id = \\"some-namespace-id\\" }"
138
149
  `);
139
- });
140
-
141
- it("should create a preview namespace if configured to do so", async () => {
142
- mockCreateRequest("worker-UnitTestNamespace_preview");
143
- const { stdout } = await runWrangler(
144
- "kv:namespace create UnitTestNamespace --preview"
145
- );
146
- expect(stdout).toMatchInlineSnapshot(`
150
+ });
151
+
152
+ it("should create a preview namespace if configured to do so", async () => {
153
+ mockCreateRequest("worker-UnitTestNamespace_preview");
154
+ await runWrangler("kv:namespace create UnitTestNamespace --preview");
155
+ expect(std.out).toMatchInlineSnapshot(`
147
156
  "🌀 Creating namespace with title \\"worker-UnitTestNamespace_preview\\"
148
157
  ✨ Success!
149
158
  Add the following to your configuration file in your kv_namespaces array:
150
159
  { binding = \\"UnitTestNamespace\\", preview_id = \\"some-namespace-id\\" }"
151
160
  `);
152
- });
153
-
154
- it("should create a namespace using configured worker name", async () => {
155
- writeFileSync("./wrangler.toml", 'name = "otherWorker"', "utf-8");
156
- mockCreateRequest("otherWorker-UnitTestNamespace");
157
- const { stdout } = await runWrangler(
158
- "kv:namespace create UnitTestNamespace"
159
- );
160
- expect(stdout).toMatchInlineSnapshot(`
161
- "🌀 Creating namespace with title \\"otherWorker-UnitTestNamespace\\"
161
+ });
162
+
163
+ it("should create a namespace using configured worker name", async () => {
164
+ writeFileSync("./wrangler.toml", 'name = "other-worker"', "utf-8");
165
+ mockCreateRequest("other-worker-UnitTestNamespace");
166
+ await runWrangler("kv:namespace create UnitTestNamespace");
167
+ expect(std.out).toMatchInlineSnapshot(`
168
+ "🌀 Creating namespace with title \\"other-worker-UnitTestNamespace\\"
162
169
  ✨ Success!
163
170
  Add the following to your configuration file in your kv_namespaces array:
164
171
  { binding = \\"UnitTestNamespace\\", id = \\"some-namespace-id\\" }"
165
172
  `);
166
- });
167
-
168
- it("should create a namespace in an environment if configured to do so", async () => {
169
- mockCreateRequest("worker-customEnv-UnitTestNamespace");
170
- const { stdout } = await runWrangler(
171
- "kv:namespace create UnitTestNamespace --env customEnv"
172
- );
173
- expect(stdout).toMatchInlineSnapshot(`
173
+ });
174
+
175
+ it("should create a namespace in an environment if configured to do so", async () => {
176
+ mockCreateRequest("worker-customEnv-UnitTestNamespace");
177
+ await runWrangler(
178
+ "kv:namespace create UnitTestNamespace --env customEnv"
179
+ );
180
+ expect(std.out).toMatchInlineSnapshot(`
174
181
  "🌀 Creating namespace with title \\"worker-customEnv-UnitTestNamespace\\"
175
182
  ✨ Success!
176
183
  Add the following to your configuration file in your kv_namespaces array under [env.customEnv]:
177
184
  { binding = \\"UnitTestNamespace\\", id = \\"some-namespace-id\\" }"
178
185
  `);
179
- });
180
- });
181
-
182
- describe("list", () => {
183
- function mockListRequest(namespaces: unknown[]) {
184
- const requests = { count: 0 };
185
- setMockResponse(
186
- "/accounts/:accountId/storage/kv/namespaces",
187
- ([_url, accountId], init, query) => {
188
- requests.count++;
189
- expect(accountId).toEqual("some-account-id");
190
- expect(query.get("per_page")).toEqual("100");
191
- expect(query.get("order")).toEqual("title");
192
- expect(query.get("direction")).toEqual("asc");
193
- expect(query.get("page")).toEqual(`${requests.count}`);
194
- expect(init).toEqual({});
195
- const pageSize = Number(query.get("per_page"));
196
- const page = Number(query.get("page"));
197
- return namespaces.slice((page - 1) * pageSize, page * pageSize);
198
- }
199
- );
200
- return requests;
201
- }
202
-
203
- it("should list namespaces", async () => {
204
- const kvNamespaces: KVNamespaceInfo[] = [
205
- { title: "title-1", id: "id-1" },
206
- { title: "title-2", id: "id-2" },
207
- ];
208
- mockListRequest(kvNamespaces);
209
- const { error, stdout, stderr } = await runWrangler(
210
- "kv:namespace list"
211
- );
212
- expect(error).toMatchInlineSnapshot(`undefined`);
213
- expect(stderr).toMatchInlineSnapshot(`""`);
214
- const namespaces = JSON.parse(stdout);
215
- expect(namespaces).toEqual(kvNamespaces);
216
- });
217
-
218
- it("should make multiple requests for paginated results", async () => {
219
- // Create a lot of mock namespaces, so that the fetch requests will be paginated
220
- const kvNamespaces: KVNamespaceInfo[] = [];
221
- for (let i = 0; i < 550; i++) {
222
- kvNamespaces.push({ title: "title-" + i, id: "id-" + i });
223
- }
224
- const requests = mockListRequest(kvNamespaces);
225
- const { stdout } = await runWrangler("kv:namespace list");
226
- const namespaces = JSON.parse(stdout);
227
- expect(namespaces).toEqual(kvNamespaces);
228
- expect(requests.count).toEqual(6);
229
- });
230
- });
231
-
232
- describe("delete", () => {
233
- function mockDeleteRequest(expectedNamespaceId: string) {
234
- const requests = { count: 0 };
235
- setMockResponse(
236
- "/accounts/:accountId/storage/kv/namespaces/:namespaceId",
237
- "DELETE",
238
- ([_url, accountId, namespaceId]) => {
239
- requests.count++;
240
- expect(accountId).toEqual("some-account-id");
241
- expect(namespaceId).toEqual(expectedNamespaceId);
242
- return null;
243
- }
244
- );
245
- return requests;
246
- }
247
-
248
- it("should delete a namespace specified by id", async () => {
249
- const requests = mockDeleteRequest("some-namespace-id");
250
- await runWrangler(
251
- `kv:namespace delete --namespace-id some-namespace-id`
252
- );
253
- expect(requests.count).toEqual(1);
254
- });
255
-
256
- it("should delete a namespace specified by binding name", async () => {
257
- writeWranglerConfig();
258
- const requests = mockDeleteRequest("bound-id");
259
- await runWrangler(
260
- `kv:namespace delete --binding someBinding --preview false`
261
- );
262
- expect(requests.count).toEqual(1);
263
- });
264
-
265
- it("should delete a preview namespace specified by binding name", async () => {
266
- writeWranglerConfig();
267
- const requests = mockDeleteRequest("preview-bound-id");
268
- await runWrangler(
269
- `kv:namespace delete --binding someBinding --preview`
270
- );
271
- expect(requests.count).toEqual(1);
272
- });
273
-
274
- it("should error if a given binding name is not in the configured kv namespaces", async () => {
275
- writeWranglerConfig();
276
- const { stderr } = await runWrangler(
277
- `kv:namespace delete --binding otherBinding`
278
- );
279
- expect(stderr).toMatchInlineSnapshot(`
280
- "wrangler kv:namespace delete
281
-
282
- Deletes a given namespace.
283
-
284
- Flags:
285
- -c, --config Path to .toml configuration file [string]
286
- -h, --help Show help [boolean]
287
- -v, --version Show version number [boolean]
288
-
289
- Options:
290
- -l, --local Run on my machine [boolean] [default: false]
291
- --binding The name of the namespace to delete [string]
292
- --namespace-id The id of the namespace to delete [string]
293
- --env Perform on a specific environment [string]
294
- --preview Interact with a preview namespace [boolean]
295
-
296
- Not able to delete namespace.
297
- A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\"."
186
+ });
187
+ });
188
+
189
+ describe("list", () => {
190
+ function mockListRequest(namespaces: unknown[]) {
191
+ const requests = { count: 0 };
192
+ setMockResponse(
193
+ "/accounts/:accountId/storage/kv/namespaces",
194
+ ([_url, accountId], init, query) => {
195
+ requests.count++;
196
+ expect(accountId).toEqual("some-account-id");
197
+ expect(query.get("per_page")).toEqual("100");
198
+ expect(query.get("order")).toEqual("title");
199
+ expect(query.get("direction")).toEqual("asc");
200
+ expect(query.get("page")).toEqual(`${requests.count}`);
201
+ expect(init).toEqual({});
202
+ const pageSize = Number(query.get("per_page"));
203
+ const page = Number(query.get("page"));
204
+ return namespaces.slice((page - 1) * pageSize, page * pageSize);
205
+ }
206
+ );
207
+ return requests;
208
+ }
209
+
210
+ it("should list namespaces", async () => {
211
+ const kvNamespaces: KVNamespaceInfo[] = [
212
+ { title: "title-1", id: "id-1" },
213
+ { title: "title-2", id: "id-2" },
214
+ ];
215
+ mockListRequest(kvNamespaces);
216
+ await runWrangler("kv:namespace list");
217
+
218
+ expect(std.err).toMatchInlineSnapshot(`""`);
219
+ const namespaces = JSON.parse(std.out);
220
+ expect(namespaces).toEqual(kvNamespaces);
221
+ });
222
+
223
+ it("should make multiple requests for paginated results", async () => {
224
+ // Create a lot of mock namespaces, so that the fetch requests will be paginated
225
+ const kvNamespaces: KVNamespaceInfo[] = [];
226
+ for (let i = 0; i < 550; i++) {
227
+ kvNamespaces.push({ title: "title-" + i, id: "id-" + i });
228
+ }
229
+ const requests = mockListRequest(kvNamespaces);
230
+ await runWrangler("kv:namespace list");
231
+ const namespaces = JSON.parse(std.out);
232
+ expect(namespaces).toEqual(kvNamespaces);
233
+ expect(requests.count).toEqual(6);
234
+ });
235
+ });
236
+
237
+ describe("delete", () => {
238
+ function mockDeleteRequest(expectedNamespaceId: string) {
239
+ const requests = { count: 0 };
240
+ setMockResponse(
241
+ "/accounts/:accountId/storage/kv/namespaces/:namespaceId",
242
+ "DELETE",
243
+ ([_url, accountId, namespaceId]) => {
244
+ requests.count++;
245
+ expect(accountId).toEqual("some-account-id");
246
+ expect(namespaceId).toEqual(expectedNamespaceId);
247
+ return null;
248
+ }
249
+ );
250
+ return requests;
251
+ }
252
+
253
+ it("should delete a namespace specified by id", async () => {
254
+ const requests = mockDeleteRequest("some-namespace-id");
255
+ await runWrangler(
256
+ `kv:namespace delete --namespace-id some-namespace-id`
257
+ );
258
+ expect(requests.count).toEqual(1);
259
+ });
260
+
261
+ it("should delete a namespace specified by binding name", async () => {
262
+ writeWranglerConfig();
263
+ const requests = mockDeleteRequest("bound-id");
264
+ await runWrangler(
265
+ `kv:namespace delete --binding someBinding --preview false`
266
+ );
267
+ expect(requests.count).toEqual(1);
268
+ });
269
+
270
+ it("should delete a preview namespace specified by binding name", async () => {
271
+ writeWranglerConfig();
272
+ const requests = mockDeleteRequest("preview-bound-id");
273
+ await runWrangler(
274
+ `kv:namespace delete --binding someBinding --preview`
275
+ );
276
+ expect(requests.count).toEqual(1);
277
+ });
278
+
279
+ it("should error if a given binding name is not in the configured kv namespaces", async () => {
280
+ writeWranglerConfig();
281
+ await expect(runWrangler("kv:namespace delete --binding otherBinding"))
282
+ .rejects.toThrowErrorMatchingInlineSnapshot(`
283
+ "Not able to delete namespace.
284
+ A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\"."
285
+ `);
286
+ expect(std.err).toMatchInlineSnapshot(`
287
+ "X [ERROR] Not able to delete namespace.
288
+
289
+ A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\".
290
+
291
+ "
298
292
  `);
299
- });
300
-
301
- it("should delete a namespace specified by binding name in a given environment", async () => {
302
- writeWranglerConfig();
303
- const requests = mockDeleteRequest("env-bound-id");
304
- const { stdout, stderr, error } = await runWrangler(
305
- `kv:namespace delete --binding someBinding --env some-environment --preview false`
306
- );
307
- expect(stdout).toMatchInlineSnapshot(`""`);
308
- expect(stderr).toMatchInlineSnapshot(`""`);
309
- expect(error).toMatchInlineSnapshot(`undefined`);
310
- expect(requests.count).toEqual(1);
311
- });
312
-
313
- it("should delete a preview namespace specified by binding name in a given environment", async () => {
314
- writeWranglerConfig();
315
- const requests = mockDeleteRequest("preview-env-bound-id");
316
- await runWrangler(
317
- `kv:namespace delete --binding someBinding --env some-environment --preview`
318
- );
319
- expect(requests.count).toEqual(1);
320
- });
321
- });
322
- });
323
-
324
- describe("kv:key", () => {
325
- describe("put", () => {
326
- function mockKeyPutRequest(
327
- expectedNamespaceId: string,
328
- expectedKey: string,
329
- expectedValue: string,
330
- expiration?: number,
331
- expirationTtl?: number
332
- ) {
333
- const requests = { count: 0 };
334
- setMockResponse(
335
- "/accounts/:accountId/storage/kv/namespaces/:namespaceId/values/:key",
336
- "PUT",
337
- ([_url, accountId, namespaceId, key], { body }, query) => {
338
- requests.count++;
339
- expect(accountId).toEqual("some-account-id");
340
- expect(namespaceId).toEqual(expectedNamespaceId);
341
- expect(key).toEqual(expectedKey);
342
- expect(body).toEqual(expectedValue);
343
- if (expiration !== undefined) {
344
- expect(query.get("expiration")).toEqual(`${expiration}`);
345
- } else {
346
- expect(query.has("expiration")).toBe(false);
347
- }
348
- if (expirationTtl) {
349
- expect(query.get("expiration_ttl")).toEqual(`${expirationTtl}`);
350
- } else {
351
- expect(query.has("expiration_ttl")).toBe(false);
352
- }
353
- return null;
354
- }
355
- );
356
- return requests;
357
- }
358
-
359
- it("should put a key in a given namespace specified by namespace-id", async () => {
360
- const requests = mockKeyPutRequest(
361
- "some-namespace-id",
362
- "my-key",
363
- "my-value"
364
- );
365
- const { error, stderr, stdout } = await runWrangler(
366
- "kv:key put my-key my-value --namespace-id some-namespace-id"
367
- );
368
- expect(requests.count).toEqual(1);
369
- expect(stdout).toMatchInlineSnapshot(
370
- `"writing the value \\"my-value\\" to key \\"my-key\\" on namespace some-namespace-id"`
371
- );
372
- expect(stderr).toMatchInlineSnapshot(`""`);
373
- expect(error).toMatchInlineSnapshot(`undefined`);
374
- });
375
-
376
- it("should put a key in a given namespace specified by binding", async () => {
377
- writeWranglerConfig();
378
- const requests = mockKeyPutRequest("bound-id", "my-key", "my-value");
379
- const { error, stderr, stdout } = await runWrangler(
380
- "kv:key put my-key my-value --binding someBinding --preview false"
381
- );
382
- expect(stdout).toMatchInlineSnapshot(
383
- `"writing the value \\"my-value\\" to key \\"my-key\\" on namespace bound-id"`
384
- );
385
- expect(stderr).toMatchInlineSnapshot(`""`);
386
- expect(error).toMatchInlineSnapshot(`undefined`);
387
- expect(requests.count).toEqual(1);
388
- });
389
-
390
- it("should put a key in a given preview namespace specified by binding", async () => {
391
- writeWranglerConfig();
392
- const requests = mockKeyPutRequest(
393
- "preview-bound-id",
394
- "my-key",
395
- "my-value"
396
- );
397
- const { error, stderr, stdout } = await runWrangler(
398
- "kv:key put my-key my-value --binding someBinding --preview"
399
- );
400
- expect(stdout).toMatchInlineSnapshot(
401
- `"writing the value \\"my-value\\" to key \\"my-key\\" on namespace preview-bound-id"`
402
- );
403
- expect(stderr).toMatchInlineSnapshot(`""`);
404
- expect(error).toMatchInlineSnapshot(`undefined`);
405
- expect(requests.count).toEqual(1);
406
- });
407
-
408
- it("should add expiration and ttl properties when putting a key", async () => {
409
- const requests = mockKeyPutRequest(
410
- "some-namespace-id",
411
- "my-key",
412
- "my-value",
413
- 10,
414
- 20
415
- );
416
- const { error, stderr, stdout } = await runWrangler(
417
- "kv:key put my-key my-value --namespace-id some-namespace-id --expiration 10 --ttl 20"
418
- );
419
- expect(requests.count).toEqual(1);
420
- expect(stdout).toMatchInlineSnapshot(
421
- `"writing the value \\"my-value\\" to key \\"my-key\\" on namespace some-namespace-id"`
422
- );
423
- expect(stderr).toMatchInlineSnapshot(`""`);
424
- expect(error).toMatchInlineSnapshot(`undefined`);
425
- });
426
-
427
- it("should put a key to the specified environment in a given namespace", async () => {
428
- writeWranglerConfig();
429
- const requests = mockKeyPutRequest(
430
- "env-bound-id",
431
- "my-key",
432
- "my-value"
433
- );
434
- const { error, stderr, stdout } = await runWrangler(
435
- "kv:key put my-key my-value --binding someBinding --env some-environment --preview false"
436
- );
437
- expect(stdout).toMatchInlineSnapshot(
438
- `"writing the value \\"my-value\\" to key \\"my-key\\" on namespace env-bound-id"`
439
- );
440
- expect(stderr).toMatchInlineSnapshot(`""`);
441
- expect(error).toMatchInlineSnapshot(`undefined`);
442
- expect(requests.count).toEqual(1);
443
- });
444
-
445
- it("should put a key with a value loaded from a given path", async () => {
446
- writeFileSync("foo.txt", "file-contents", "utf-8");
447
- const requests = mockKeyPutRequest(
448
- "some-namespace-id",
449
- "my-key",
450
- "file-contents"
451
- );
452
- const { error, stderr, stdout } = await runWrangler(
453
- "kv:key put my-key --namespace-id some-namespace-id --path foo.txt"
454
- );
455
- expect(stdout).toMatchInlineSnapshot(
456
- `"writing the contents of foo.txt to the key \\"my-key\\" on namespace some-namespace-id"`
457
- );
458
- expect(stderr).toMatchInlineSnapshot(`""`);
459
- expect(error).toMatchInlineSnapshot(`undefined`);
460
- expect(requests.count).toEqual(1);
461
- });
462
-
463
- it("should error if no key is provided", async () => {
464
- const { error, stdout, stderr } = await runWrangler("kv:key put");
465
-
466
- expect(stdout).toMatchInlineSnapshot(`""`);
467
- expect(stderr).toMatchInlineSnapshot(`
468
- "wrangler kv:key put <key> [value]
293
+ });
294
+
295
+ it("should delete a namespace specified by binding name in a given environment", async () => {
296
+ writeWranglerConfig();
297
+ const requests = mockDeleteRequest("env-bound-id");
298
+ await runWrangler(
299
+ "kv:namespace delete --binding someBinding --env some-environment --preview false"
300
+ );
301
+
302
+ expect(std.out).toMatchInlineSnapshot(`""`);
303
+ expect(std.err).toMatchInlineSnapshot(`""`);
304
+ expect(requests.count).toEqual(1);
305
+ });
306
+
307
+ it("should delete a preview namespace specified by binding name in a given environment", async () => {
308
+ writeWranglerConfig();
309
+ const requests = mockDeleteRequest("preview-env-bound-id");
310
+ await runWrangler(
311
+ `kv:namespace delete --binding someBinding --env some-environment --preview`
312
+ );
313
+ expect(requests.count).toEqual(1);
314
+ });
315
+ });
316
+ });
317
+
318
+ describe("kv:key", () => {
319
+ describe("put", () => {
320
+ function mockKeyPutRequest(
321
+ expectedNamespaceId: string,
322
+ expectedKV: KeyValue
323
+ ) {
324
+ const requests = { count: 0 };
325
+ setMockResponse(
326
+ "/accounts/:accountId/storage/kv/namespaces/:namespaceId/values/:key",
327
+ "PUT",
328
+ ([_url, accountId, namespaceId, key], { body }, query) => {
329
+ requests.count++;
330
+ expect(accountId).toEqual("some-account-id");
331
+ expect(namespaceId).toEqual(expectedNamespaceId);
332
+ expect(key).toEqual(expectedKV.key);
333
+ expect(body).toEqual(expectedKV.value);
334
+ if (expectedKV.expiration !== undefined) {
335
+ expect(query.get("expiration")).toEqual(
336
+ `${expectedKV.expiration}`
337
+ );
338
+ } else {
339
+ expect(query.has("expiration")).toBe(false);
340
+ }
341
+ if (expectedKV.expiration_ttl) {
342
+ expect(query.get("expiration_ttl")).toEqual(
343
+ `${expectedKV.expiration_ttl}`
344
+ );
345
+ } else {
346
+ expect(query.has("expiration_ttl")).toBe(false);
347
+ }
348
+ return null;
349
+ }
350
+ );
351
+ return requests;
352
+ }
353
+
354
+ it("should put a key in a given namespace specified by namespace-id", async () => {
355
+ const requests = mockKeyPutRequest("some-namespace-id", {
356
+ key: "my-key",
357
+ value: "my-value",
358
+ });
359
+
360
+ await runWrangler(
361
+ "kv:key put my-key my-value --namespace-id some-namespace-id"
362
+ );
363
+
364
+ expect(requests.count).toEqual(1);
365
+ expect(std.out).toMatchInlineSnapshot(
366
+ `"Writing the value \\"my-value\\" to key \\"my-key\\" on namespace some-namespace-id."`
367
+ );
368
+ expect(std.err).toMatchInlineSnapshot(`""`);
369
+ });
370
+
371
+ it("should encode the key in the api request to put a value", async () => {
372
+ const requests = mockKeyPutRequest("DS9", {
373
+ key: "%2Fmy-key",
374
+ value: "my-value",
375
+ });
376
+
377
+ await runWrangler("kv:key put /my-key my-value --namespace-id DS9");
378
+
379
+ expect(requests.count).toEqual(1);
380
+ expect(std.out).toMatchInlineSnapshot(
381
+ `"Writing the value \\"my-value\\" to key \\"/my-key\\" on namespace DS9."`
382
+ );
383
+ expect(std.err).toMatchInlineSnapshot(`""`);
384
+ });
385
+
386
+ it("should put a key in a given namespace specified by binding", async () => {
387
+ writeWranglerConfig();
388
+ const requests = mockKeyPutRequest("bound-id", {
389
+ key: "my-key",
390
+ value: "my-value",
391
+ });
392
+ await runWrangler(
393
+ "kv:key put my-key my-value --binding someBinding --preview false"
394
+ );
395
+
396
+ expect(std.out).toMatchInlineSnapshot(
397
+ `"Writing the value \\"my-value\\" to key \\"my-key\\" on namespace bound-id."`
398
+ );
399
+ expect(std.err).toMatchInlineSnapshot(`""`);
400
+ expect(requests.count).toEqual(1);
401
+ });
402
+
403
+ it("should put a key in a given preview namespace specified by binding", async () => {
404
+ writeWranglerConfig();
405
+ const requests = mockKeyPutRequest("preview-bound-id", {
406
+ key: "my-key",
407
+ value: "my-value",
408
+ });
409
+
410
+ await runWrangler(
411
+ "kv:key put my-key my-value --binding someBinding --preview"
412
+ );
413
+
414
+ expect(std.out).toMatchInlineSnapshot(
415
+ `"Writing the value \\"my-value\\" to key \\"my-key\\" on namespace preview-bound-id."`
416
+ );
417
+ expect(std.err).toMatchInlineSnapshot(`""`);
418
+ expect(requests.count).toEqual(1);
419
+ });
420
+
421
+ it("should add expiration and ttl properties when putting a key", async () => {
422
+ const requests = mockKeyPutRequest("some-namespace-id", {
423
+ key: "my-key",
424
+ value: "my-value",
425
+ expiration: 10,
426
+ expiration_ttl: 20,
427
+ });
428
+ await runWrangler(
429
+ "kv:key put my-key my-value --namespace-id some-namespace-id --expiration 10 --ttl 20"
430
+ );
431
+ expect(requests.count).toEqual(1);
432
+ expect(std.out).toMatchInlineSnapshot(
433
+ `"Writing the value \\"my-value\\" to key \\"my-key\\" on namespace some-namespace-id."`
434
+ );
435
+ expect(std.err).toMatchInlineSnapshot(`""`);
436
+ });
437
+
438
+ it("should put a key to the specified environment in a given namespace", async () => {
439
+ writeWranglerConfig();
440
+ const requests = mockKeyPutRequest("env-bound-id", {
441
+ key: "my-key",
442
+ value: "my-value",
443
+ });
444
+ await runWrangler(
445
+ "kv:key put my-key my-value --binding someBinding --env some-environment --preview false"
446
+ );
447
+ expect(std.out).toMatchInlineSnapshot(
448
+ `"Writing the value \\"my-value\\" to key \\"my-key\\" on namespace env-bound-id."`
449
+ );
450
+ expect(std.err).toMatchInlineSnapshot(`""`);
451
+ expect(requests.count).toEqual(1);
452
+ });
453
+
454
+ it("should put a key with a value loaded from a given path", async () => {
455
+ const buf = Buffer.from("file-contents", "utf-8");
456
+ writeFileSync("foo.txt", buf);
457
+ const requests = mockKeyPutRequest("some-namespace-id", {
458
+ key: "my-key",
459
+ value: buf,
460
+ });
461
+ await runWrangler(
462
+ "kv:key put my-key --namespace-id some-namespace-id --path foo.txt"
463
+ );
464
+ expect(std.out).toMatchInlineSnapshot(
465
+ `"Writing the contents of foo.txt to the key \\"my-key\\" on namespace some-namespace-id."`
466
+ );
467
+ expect(std.err).toMatchInlineSnapshot(`""`);
468
+ expect(requests.count).toEqual(1);
469
+ });
470
+
471
+ it("should put a key with a binary value loaded from a given path", async () => {
472
+ const buf = Buffer.from(
473
+ "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAiSURBVHgB7coxEQAACMPAgH/PgAM6dGwu49fA/deIBXrgAj2cAhIFT4QxAAAAAElFTkSuQmCC",
474
+ "base64"
475
+ );
476
+ writeFileSync("test.png", buf);
477
+ const requests = mockKeyPutRequest("another-namespace-id", {
478
+ key: "my-key",
479
+ value: buf,
480
+ });
481
+ await runWrangler(
482
+ "kv:key put my-key --namespace-id another-namespace-id --path test.png"
483
+ );
484
+ expect(std.out).toMatchInlineSnapshot(
485
+ `"Writing the contents of test.png to the key \\"my-key\\" on namespace another-namespace-id."`
486
+ );
487
+ expect(std.err).toMatchInlineSnapshot(`""`);
488
+ expect(requests.count).toEqual(1);
489
+ });
490
+
491
+ it("should error if no key is provided", async () => {
492
+ await expect(
493
+ runWrangler("kv:key put")
494
+ ).rejects.toThrowErrorMatchingInlineSnapshot(
495
+ `"Not enough non-option arguments: got 0, need at least 1"`
496
+ );
497
+
498
+ expect(std.out).toMatchInlineSnapshot(`
499
+ "
500
+ wrangler kv:key put <key> [value]
469
501
 
470
502
  Writes a single key/value pair to the given namespace.
471
503
 
472
504
  Positionals:
473
- key The key to write to. [string] [required]
474
- value The value to write. [string]
505
+ key The key to write to [string] [required]
506
+ value The value to write [string]
475
507
 
476
508
  Flags:
477
509
  -c, --config Path to .toml configuration file [string]
@@ -479,36 +511,37 @@ describe("wrangler", () => {
479
511
  -v, --version Show version number [boolean]
480
512
 
481
513
  Options:
482
- -l, --local Run on my machine [boolean] [default: false]
483
- --binding The binding of the namespace to write to. [string]
484
- --namespace-id The id of the namespace to write to. [string]
485
- --env Perform on a specific environment [string]
514
+ --binding The binding of the namespace to write to [string]
515
+ --namespace-id The id of the namespace to write to [string]
516
+ -e, --env Perform on a specific environment [string]
486
517
  --preview Interact with a preview namespace [boolean]
487
- --ttl Time for which the entries should be visible. [number]
518
+ --ttl Time for which the entries should be visible [number]
488
519
  --expiration Time since the UNIX epoch after which the entry expires [number]
489
- --path Read value from the file at a given path. [string]
520
+ --path Read value from the file at a given path [string]"
521
+ `);
522
+ expect(std.err).toMatchInlineSnapshot(`
523
+ "X [ERROR] Not enough non-option arguments: got 0, need at least 1
490
524
 
491
- Not enough non-option arguments: got 0, need at least 1"
525
+ "
492
526
  `);
493
- expect(error).toMatchInlineSnapshot(
494
- `[Error: Not enough non-option arguments: got 0, need at least 1]`
495
- );
496
- });
527
+ });
497
528
 
498
- it("should error if no binding nor namespace is provided", async () => {
499
- const { error, stdout, stderr } = await runWrangler(
500
- "kv:key put foo bar"
501
- );
529
+ it("should error if no binding nor namespace is provided", async () => {
530
+ await expect(
531
+ runWrangler("kv:key put foo bar")
532
+ ).rejects.toThrowErrorMatchingInlineSnapshot(
533
+ `"Exactly one of the arguments binding and namespace-id is required"`
534
+ );
502
535
 
503
- expect(stdout).toMatchInlineSnapshot(`""`);
504
- expect(stderr).toMatchInlineSnapshot(`
505
- "wrangler kv:key put <key> [value]
536
+ expect(std.out).toMatchInlineSnapshot(`
537
+ "
538
+ wrangler kv:key put <key> [value]
506
539
 
507
540
  Writes a single key/value pair to the given namespace.
508
541
 
509
542
  Positionals:
510
- key The key to write to. [string] [required]
511
- value The value to write. [string]
543
+ key The key to write to [string] [required]
544
+ value The value to write [string]
512
545
 
513
546
  Flags:
514
547
  -c, --config Path to .toml configuration file [string]
@@ -516,36 +549,37 @@ describe("wrangler", () => {
516
549
  -v, --version Show version number [boolean]
517
550
 
518
551
  Options:
519
- -l, --local Run on my machine [boolean] [default: false]
520
- --binding The binding of the namespace to write to. [string]
521
- --namespace-id The id of the namespace to write to. [string]
522
- --env Perform on a specific environment [string]
552
+ --binding The binding of the namespace to write to [string]
553
+ --namespace-id The id of the namespace to write to [string]
554
+ -e, --env Perform on a specific environment [string]
523
555
  --preview Interact with a preview namespace [boolean]
524
- --ttl Time for which the entries should be visible. [number]
556
+ --ttl Time for which the entries should be visible [number]
525
557
  --expiration Time since the UNIX epoch after which the entry expires [number]
526
- --path Read value from the file at a given path. [string]
558
+ --path Read value from the file at a given path [string]"
559
+ `);
560
+ expect(std.err).toMatchInlineSnapshot(`
561
+ "X [ERROR] Exactly one of the arguments binding and namespace-id is required
527
562
 
528
- Exactly one of the arguments binding and namespace-id is required"
563
+ "
529
564
  `);
530
- expect(error).toMatchInlineSnapshot(
531
- `[Error: Exactly one of the arguments binding and namespace-id is required]`
532
- );
533
- });
565
+ });
534
566
 
535
- it("should error if both binding and namespace is provided", async () => {
536
- const { error, stdout, stderr } = await runWrangler(
537
- "kv:key put foo bar --binding x --namespace-id y"
538
- );
567
+ it("should error if both binding and namespace is provided", async () => {
568
+ await expect(
569
+ runWrangler("kv:key put foo bar --binding x --namespace-id y")
570
+ ).rejects.toThrowErrorMatchingInlineSnapshot(
571
+ `"Arguments binding and namespace-id are mutually exclusive"`
572
+ );
539
573
 
540
- expect(stdout).toMatchInlineSnapshot(`""`);
541
- expect(stderr).toMatchInlineSnapshot(`
542
- "wrangler kv:key put <key> [value]
574
+ expect(std.out).toMatchInlineSnapshot(`
575
+ "
576
+ wrangler kv:key put <key> [value]
543
577
 
544
578
  Writes a single key/value pair to the given namespace.
545
579
 
546
580
  Positionals:
547
- key The key to write to. [string] [required]
548
- value The value to write. [string]
581
+ key The key to write to [string] [required]
582
+ value The value to write [string]
549
583
 
550
584
  Flags:
551
585
  -c, --config Path to .toml configuration file [string]
@@ -553,36 +587,37 @@ describe("wrangler", () => {
553
587
  -v, --version Show version number [boolean]
554
588
 
555
589
  Options:
556
- -l, --local Run on my machine [boolean] [default: false]
557
- --binding The binding of the namespace to write to. [string]
558
- --namespace-id The id of the namespace to write to. [string]
559
- --env Perform on a specific environment [string]
590
+ --binding The binding of the namespace to write to [string]
591
+ --namespace-id The id of the namespace to write to [string]
592
+ -e, --env Perform on a specific environment [string]
560
593
  --preview Interact with a preview namespace [boolean]
561
- --ttl Time for which the entries should be visible. [number]
594
+ --ttl Time for which the entries should be visible [number]
562
595
  --expiration Time since the UNIX epoch after which the entry expires [number]
563
- --path Read value from the file at a given path. [string]
596
+ --path Read value from the file at a given path [string]"
597
+ `);
598
+ expect(std.err).toMatchInlineSnapshot(`
599
+ "X [ERROR] Arguments binding and namespace-id are mutually exclusive
564
600
 
565
- Arguments binding and namespace-id are mutually exclusive"
601
+ "
566
602
  `);
567
- expect(error).toMatchInlineSnapshot(
568
- `[Error: Arguments binding and namespace-id are mutually exclusive]`
569
- );
570
- });
603
+ });
571
604
 
572
- it("should error if no value nor path is provided", async () => {
573
- const { error, stdout, stderr } = await runWrangler(
574
- "kv:key put key --namespace-id 12345"
575
- );
605
+ it("should error if no value nor path is provided", async () => {
606
+ await expect(
607
+ runWrangler("kv:key put key --namespace-id 12345")
608
+ ).rejects.toThrowErrorMatchingInlineSnapshot(
609
+ `"Exactly one of the arguments value and path is required"`
610
+ );
576
611
 
577
- expect(stdout).toMatchInlineSnapshot(`""`);
578
- expect(stderr).toMatchInlineSnapshot(`
579
- "wrangler kv:key put <key> [value]
612
+ expect(std.out).toMatchInlineSnapshot(`
613
+ "
614
+ wrangler kv:key put <key> [value]
580
615
 
581
616
  Writes a single key/value pair to the given namespace.
582
617
 
583
618
  Positionals:
584
- key The key to write to. [string] [required]
585
- value The value to write. [string]
619
+ key The key to write to [string] [required]
620
+ value The value to write [string]
586
621
 
587
622
  Flags:
588
623
  -c, --config Path to .toml configuration file [string]
@@ -590,36 +625,37 @@ describe("wrangler", () => {
590
625
  -v, --version Show version number [boolean]
591
626
 
592
627
  Options:
593
- -l, --local Run on my machine [boolean] [default: false]
594
- --binding The binding of the namespace to write to. [string]
595
- --namespace-id The id of the namespace to write to. [string]
596
- --env Perform on a specific environment [string]
628
+ --binding The binding of the namespace to write to [string]
629
+ --namespace-id The id of the namespace to write to [string]
630
+ -e, --env Perform on a specific environment [string]
597
631
  --preview Interact with a preview namespace [boolean]
598
- --ttl Time for which the entries should be visible. [number]
632
+ --ttl Time for which the entries should be visible [number]
599
633
  --expiration Time since the UNIX epoch after which the entry expires [number]
600
- --path Read value from the file at a given path. [string]
634
+ --path Read value from the file at a given path [string]"
635
+ `);
636
+ expect(std.err).toMatchInlineSnapshot(`
637
+ "X [ERROR] Exactly one of the arguments value and path is required
601
638
 
602
- Exactly one of the arguments value and path is required"
639
+ "
603
640
  `);
604
- expect(error).toMatchInlineSnapshot(
605
- `[Error: Exactly one of the arguments value and path is required]`
606
- );
607
- });
641
+ });
608
642
 
609
- it("should error if both value and path is provided", async () => {
610
- const { error, stdout, stderr } = await runWrangler(
611
- "kv:key put key value --path xyz --namespace-id 12345"
612
- );
643
+ it("should error if both value and path is provided", async () => {
644
+ await expect(
645
+ runWrangler("kv:key put key value --path xyz --namespace-id 12345")
646
+ ).rejects.toThrowErrorMatchingInlineSnapshot(
647
+ `"Arguments value and path are mutually exclusive"`
648
+ );
613
649
 
614
- expect(stdout).toMatchInlineSnapshot(`""`);
615
- expect(stderr).toMatchInlineSnapshot(`
616
- "wrangler kv:key put <key> [value]
650
+ expect(std.out).toMatchInlineSnapshot(`
651
+ "
652
+ wrangler kv:key put <key> [value]
617
653
 
618
654
  Writes a single key/value pair to the given namespace.
619
655
 
620
656
  Positionals:
621
- key The key to write to. [string] [required]
622
- value The value to write. [string]
657
+ key The key to write to [string] [required]
658
+ value The value to write [string]
623
659
 
624
660
  Flags:
625
661
  -c, --config Path to .toml configuration file [string]
@@ -627,294 +663,369 @@ describe("wrangler", () => {
627
663
  -v, --version Show version number [boolean]
628
664
 
629
665
  Options:
630
- -l, --local Run on my machine [boolean] [default: false]
631
- --binding The binding of the namespace to write to. [string]
632
- --namespace-id The id of the namespace to write to. [string]
633
- --env Perform on a specific environment [string]
666
+ --binding The binding of the namespace to write to [string]
667
+ --namespace-id The id of the namespace to write to [string]
668
+ -e, --env Perform on a specific environment [string]
634
669
  --preview Interact with a preview namespace [boolean]
635
- --ttl Time for which the entries should be visible. [number]
670
+ --ttl Time for which the entries should be visible [number]
636
671
  --expiration Time since the UNIX epoch after which the entry expires [number]
637
- --path Read value from the file at a given path. [string]
672
+ --path Read value from the file at a given path [string]"
673
+ `);
674
+ expect(std.err).toMatchInlineSnapshot(`
675
+ "X [ERROR] Arguments value and path are mutually exclusive
638
676
 
639
- Arguments value and path are mutually exclusive"
677
+ "
640
678
  `);
641
- expect(error).toMatchInlineSnapshot(
642
- `[Error: Arguments value and path are mutually exclusive]`
643
- );
644
- });
645
-
646
- it("should error if a given binding name is not in the configured kv namespaces", async () => {
647
- writeWranglerConfig();
648
- const { error, stdout, stderr } = await runWrangler(
649
- `kv:key put key value --binding otherBinding`
650
- );
651
- expect(stdout).toMatchInlineSnapshot(`""`);
652
- expect(stderr).toMatchInlineSnapshot(`
653
- "A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\".
654
-
655
- %s
656
- If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
679
+ });
680
+
681
+ it("should error if a given binding name is not in the configured kv namespaces", async () => {
682
+ writeWranglerConfig();
683
+ await expect(
684
+ runWrangler("kv:key put key value --binding otherBinding")
685
+ ).rejects.toThrowErrorMatchingInlineSnapshot(
686
+ `"A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\"."`
687
+ );
688
+
689
+ expect(std.out).toMatchInlineSnapshot(`
690
+ "
691
+ If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new/choose"
657
692
  `);
658
- expect(error).toMatchInlineSnapshot(
659
- `[Error: A namespace with binding name "otherBinding" was not found in the configured "kv_namespaces".]`
660
- );
661
- });
662
-
663
- it("should error if a given binding has both preview and non-preview and --preview is not specified", async () => {
664
- writeWranglerConfig();
665
- const requests = mockKeyPutRequest(
666
- "preview-bound-id",
667
- "my-key",
668
- "my-value"
669
- );
670
- const { error, stderr, stdout } = await runWrangler(
671
- "kv:key put my-key my-value --binding someBinding"
672
- );
673
- expect(stdout).toMatchInlineSnapshot(`""`);
674
- expect(stderr).toMatchInlineSnapshot(`
675
- "someBinding has both a namespace ID and a preview ID. Specify \\"--preview\\" or \\"--preview false\\" to avoid writing data to the wrong namespace.
676
-
677
- %s
678
- If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
693
+ expect(std.err).toMatchInlineSnapshot(`
694
+ "X [ERROR] A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\".
695
+
696
+ "
697
+ `);
698
+ });
699
+
700
+ it("should error if a given binding has both preview and non-preview and --preview is not specified", async () => {
701
+ writeWranglerConfig();
702
+ const requests = mockKeyPutRequest("preview-bound-id", {
703
+ key: "my-key",
704
+ value: "my-value",
705
+ });
706
+ await expect(
707
+ runWrangler("kv:key put my-key my-value --binding someBinding")
708
+ ).rejects.toThrowErrorMatchingInlineSnapshot(
709
+ `"someBinding has both a namespace ID and a preview ID. Specify \\"--preview\\" or \\"--preview false\\" to avoid writing data to the wrong namespace."`
710
+ );
711
+ expect(std.out).toMatchInlineSnapshot(`
712
+ "
713
+ If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new/choose"
714
+ `);
715
+ expect(std.err).toMatchInlineSnapshot(`
716
+ "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.
717
+
718
+ "
679
719
  `);
680
- expect(error).toMatchInlineSnapshot(
681
- `[Error: someBinding has both a namespace ID and a preview ID. Specify "--preview" or "--preview false" to avoid writing data to the wrong namespace.]`
682
- );
683
- expect(requests.count).toEqual(0);
684
- });
685
- });
686
-
687
- describe("list", () => {
688
- function mockKeyListRequest(
689
- expectedNamespaceId: string,
690
- expectedKeys: string[],
691
- keysPerRequest = 1000
692
- ) {
693
- const requests = { count: 0 };
694
- setMockRawResponse(
695
- "/accounts/:accountId/storage/kv/namespaces/:namespaceId/keys",
696
- ([_url, accountId, namespaceId], _init, query) => {
697
- requests.count++;
698
- expect(accountId).toEqual("some-account-id");
699
- expect(namespaceId).toEqual(expectedNamespaceId);
700
- if (expectedKeys.length <= keysPerRequest) {
701
- return createFetchResult(expectedKeys);
702
- } else {
703
- const start = parseInt(query.get("cursor") ?? "0") || 0;
704
- const end = start + keysPerRequest;
705
- const cursor = end < expectedKeys.length ? end : undefined;
706
- return createFetchResult(
707
- expectedKeys.slice(start, end),
708
- true,
709
- [],
710
- [],
711
- { cursor }
712
- );
720
+ expect(requests.count).toEqual(0);
721
+ });
722
+ });
723
+
724
+ describe("list", () => {
725
+ it("should list the keys of a namespace specified by namespace-id", async () => {
726
+ const keys = [
727
+ { name: "key-1" },
728
+ { name: "key-2", expiration: 123456789 },
729
+ { name: "key-3", expiration_ttl: 666 },
730
+ ];
731
+ mockKeyListRequest("some-namespace-id", keys);
732
+ await runWrangler("kv:key list --namespace-id some-namespace-id");
733
+ expect(std.err).toMatchInlineSnapshot(`""`);
734
+ expect(std.out).toMatchInlineSnapshot(`
735
+ "[
736
+ {
737
+ \\"name\\": \\"key-1\\"
738
+ },
739
+ {
740
+ \\"name\\": \\"key-2\\",
741
+ \\"expiration\\": 123456789
742
+ },
743
+ {
744
+ \\"name\\": \\"key-3\\",
745
+ \\"expiration_ttl\\": 666
713
746
  }
714
- }
715
- );
716
- return requests;
717
- }
718
-
719
- it("should list the keys of a namespace specified by namespace-id", async () => {
720
- const keys = ["key-1", "key-2", "key-3"];
721
- mockKeyListRequest("some-namespace-id", keys);
722
- const { error, stdout, stderr } = await runWrangler(
723
- "kv:key list --namespace-id some-namespace-id"
724
- );
725
- expect(error).toMatchInlineSnapshot(`undefined`);
726
- expect(stderr).toMatchInlineSnapshot(`""`);
727
- expect(stdout).toMatchInlineSnapshot(`
728
- "key-1
729
- key-2
730
- key-3"
747
+ ]"
748
+ `);
749
+ });
750
+
751
+ it("should list the keys of a namespace specified by binding", async () => {
752
+ writeWranglerConfig();
753
+ const keys = [{ name: "key-1" }, { name: "key-2" }, { name: "key-3" }];
754
+ mockKeyListRequest("bound-id", keys);
755
+
756
+ await runWrangler("kv:key list --binding someBinding");
757
+ expect(std.err).toMatchInlineSnapshot(`""`);
758
+ expect(std.out).toMatchInlineSnapshot(`
759
+ "[
760
+ {
761
+ \\"name\\": \\"key-1\\"
762
+ },
763
+ {
764
+ \\"name\\": \\"key-2\\"
765
+ },
766
+ {
767
+ \\"name\\": \\"key-3\\"
768
+ }
769
+ ]"
731
770
  `);
732
- });
733
-
734
- it("should list the keys of a namespace specified by binding", async () => {
735
- writeWranglerConfig();
736
- const keys = ["key-1", "key-2", "key-3"];
737
- mockKeyListRequest("bound-id", keys);
738
- const { error, stdout, stderr } = await runWrangler(
739
- "kv:key list --binding someBinding"
740
- );
741
- expect(error).toMatchInlineSnapshot(`undefined`);
742
- expect(stderr).toMatchInlineSnapshot(`""`);
743
- expect(stdout).toMatchInlineSnapshot(`
744
- "key-1
745
- key-2
746
- key-3"
771
+ });
772
+
773
+ it("should list the keys of a preview namespace specified by binding", async () => {
774
+ writeWranglerConfig();
775
+ const keys = [{ name: "key-1" }, { name: "key-2" }, { name: "key-3" }];
776
+ mockKeyListRequest("preview-bound-id", keys);
777
+ await runWrangler("kv:key list --binding someBinding --preview");
778
+ expect(std.err).toMatchInlineSnapshot(`""`);
779
+ expect(std.out).toMatchInlineSnapshot(`
780
+ "[
781
+ {
782
+ \\"name\\": \\"key-1\\"
783
+ },
784
+ {
785
+ \\"name\\": \\"key-2\\"
786
+ },
787
+ {
788
+ \\"name\\": \\"key-3\\"
789
+ }
790
+ ]"
747
791
  `);
748
- });
749
-
750
- it("should list the keys of a preview namespace specified by binding", async () => {
751
- writeWranglerConfig();
752
- const keys = ["key-1", "key-2", "key-3"];
753
- mockKeyListRequest("preview-bound-id", keys);
754
- const { error, stdout, stderr } = await runWrangler(
755
- "kv:key list --binding someBinding --preview"
756
- );
757
- expect(error).toMatchInlineSnapshot(`undefined`);
758
- expect(stderr).toMatchInlineSnapshot(`""`);
759
- expect(stdout).toMatchInlineSnapshot(`
760
- "key-1
761
- key-2
762
- key-3"
792
+ });
793
+
794
+ it("should list the keys of a namespace specified by binding, in a given environment", async () => {
795
+ writeWranglerConfig();
796
+ const keys = [{ name: "key-1" }, { name: "key-2" }, { name: "key-3" }];
797
+ mockKeyListRequest("env-bound-id", keys);
798
+ await runWrangler(
799
+ "kv:key list --binding someBinding --env some-environment"
800
+ );
801
+ expect(std.err).toMatchInlineSnapshot(`""`);
802
+ expect(std.out).toMatchInlineSnapshot(`
803
+ "[
804
+ {
805
+ \\"name\\": \\"key-1\\"
806
+ },
807
+ {
808
+ \\"name\\": \\"key-2\\"
809
+ },
810
+ {
811
+ \\"name\\": \\"key-3\\"
812
+ }
813
+ ]"
763
814
  `);
764
- });
765
-
766
- it("should list the keys of a namespace specified by binding, in a given environment", async () => {
767
- writeWranglerConfig();
768
- const keys = ["key-1", "key-2", "key-3"];
769
- mockKeyListRequest("env-bound-id", keys);
770
- const { error, stdout, stderr } = await runWrangler(
771
- "kv:key list --binding someBinding --env some-environment"
772
- );
773
- expect(error).toMatchInlineSnapshot(`undefined`);
774
- expect(stderr).toMatchInlineSnapshot(`""`);
775
- expect(stdout).toMatchInlineSnapshot(`
776
- "key-1
777
- key-2
778
- key-3"
815
+ });
816
+
817
+ it("should list the keys of a preview namespace specified by binding, in a given environment", async () => {
818
+ writeWranglerConfig();
819
+ const keys = [{ name: "key-1" }, { name: "key-2" }, { name: "key-3" }];
820
+ mockKeyListRequest("preview-env-bound-id", keys);
821
+ await runWrangler(
822
+ "kv:key list --binding someBinding --preview --env some-environment"
823
+ );
824
+ expect(std.err).toMatchInlineSnapshot(`""`);
825
+ expect(std.out).toMatchInlineSnapshot(`
826
+ "[
827
+ {
828
+ \\"name\\": \\"key-1\\"
829
+ },
830
+ {
831
+ \\"name\\": \\"key-2\\"
832
+ },
833
+ {
834
+ \\"name\\": \\"key-3\\"
835
+ }
836
+ ]"
779
837
  `);
780
- });
781
-
782
- it("should list the keys of a preview namespace specified by binding, in a given environment", async () => {
783
- writeWranglerConfig();
784
- const keys = ["key-1", "key-2", "key-3"];
785
- mockKeyListRequest("preview-env-bound-id", keys);
786
- const { error, stdout, stderr } = await runWrangler(
787
- "kv:key list --binding someBinding --preview --env some-environment"
788
- );
789
- expect(error).toMatchInlineSnapshot(`undefined`);
790
- expect(stderr).toMatchInlineSnapshot(`""`);
791
- expect(stdout).toMatchInlineSnapshot(`
792
- "key-1
793
- key-2
794
- key-3"
838
+ });
839
+
840
+ // We'll run the next test with variations on the cursor
841
+ // that's returned on cloudflare's API after all results
842
+ // have been drained.
843
+ for (const blankCursorValue of [undefined, null, ""] as [
844
+ undefined,
845
+ null,
846
+ ""
847
+ ]) {
848
+ describe(`cursor - ${blankCursorValue}`, () => {
849
+ it("should make multiple requests for paginated results", async () => {
850
+ // Create a lot of mock keys, so that the fetch requests will be paginated
851
+ const keys: NamespaceKeyInfo[] = [];
852
+ for (let i = 0; i < 550; i++) {
853
+ keys.push({ name: "key-" + i });
854
+ }
855
+ // Ask for the keys in pages of size 100.
856
+ const requests = mockKeyListRequest(
857
+ "some-namespace-id",
858
+ keys,
859
+ 100,
860
+ blankCursorValue
861
+ );
862
+ await runWrangler("kv:key list --namespace-id some-namespace-id");
863
+ expect(std.err).toMatchInlineSnapshot(`""`);
864
+ expect(JSON.parse(std.out)).toEqual(keys);
865
+ expect(requests.count).toEqual(6);
866
+ });
867
+ });
868
+ }
869
+
870
+ it("should error if a given binding name is not in the configured kv namespaces", async () => {
871
+ writeWranglerConfig();
872
+ await expect(
873
+ runWrangler("kv:key list --binding otherBinding")
874
+ ).rejects.toThrowErrorMatchingInlineSnapshot(
875
+ `"A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\"."`
876
+ );
877
+ expect(std.err).toMatchInlineSnapshot(`
878
+ "X [ERROR] A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\".
879
+
880
+ "
795
881
  `);
796
- });
797
-
798
- it("should make multiple requests for paginated results", async () => {
799
- // Create a lot of mock keys, so that the fetch requests will be paginated
800
- const keys: string[] = [];
801
- for (let i = 0; i < 550; i++) {
802
- keys.push("key-" + i);
803
- }
804
- // Ask for the keys in pages of size 100.
805
- const requests = mockKeyListRequest("some-namespace-id", keys, 100);
806
- const { stdout, stderr, error } = await runWrangler(
807
- "kv:key list --namespace-id some-namespace-id --limit 100"
808
- );
809
- expect(error).toMatchInlineSnapshot(`undefined`);
810
- expect(stderr).toMatchInlineSnapshot(`""`);
811
- expect(stdout).toEqual(keys.join("\n"));
812
- expect(requests.count).toEqual(6);
813
- });
814
-
815
- it("should error if a given binding name is not in the configured kv namespaces", async () => {
816
- writeWranglerConfig();
817
- const { error, stdout, stderr } = await runWrangler(
818
- "kv:key list --binding otherBinding"
819
- );
820
- expect(error).toMatchInlineSnapshot(
821
- `[Error: A namespace with binding name "otherBinding" was not found in the configured "kv_namespaces".]`
822
- );
823
- expect(stderr).toMatchInlineSnapshot(`
824
- "A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\".
825
-
826
- %s
827
- If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
882
+ expect(std.out).toMatchInlineSnapshot(`
883
+ "
884
+ If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new/choose"
828
885
  `);
829
- expect(stdout).toMatchInlineSnapshot(`""`);
830
- });
831
- });
832
-
833
- describe("get", () => {
834
- function mockKeyGetRequest(
835
- expectedNamespaceId: string,
836
- expectedKey: string,
837
- expectedValue: string
838
- ) {
839
- const requests = { count: 0 };
840
- setMockRawResponse(
841
- "/accounts/:accountId/storage/kv/namespaces/:namespaceId/values/:key",
842
- ([_url, accountId, namespaceId, key]) => {
843
- requests.count++;
844
- expect(accountId).toEqual("some-account-id");
845
- expect(namespaceId).toEqual(expectedNamespaceId);
846
- expect(key).toEqual(expectedKey);
847
- return expectedValue;
886
+ });
887
+ });
888
+
889
+ describe("get", () => {
890
+ afterEach(() => {
891
+ unsetMockFetchKVGetValues();
892
+ });
893
+
894
+ it("should get a key in a given namespace specified by namespace-id", async () => {
895
+ setMockFetchKVGetValue(
896
+ "some-account-id",
897
+ "some-namespace-id",
898
+ "my-key",
899
+ "my-value"
900
+ );
901
+ await runWrangler("kv:key get my-key --namespace-id some-namespace-id");
902
+ expect(proc.write).toEqual(Buffer.from("my-value"));
903
+ expect(std.err).toMatchInlineSnapshot(`""`);
904
+ });
905
+
906
+ it("should get a key and decode the value from the response as a utf8 string if the `--text` flag is passed", async () => {
907
+ setMockFetchKVGetValue(
908
+ "some-account-id",
909
+ "some-namespace-id",
910
+ "my-key",
911
+ "my-value"
912
+ );
913
+ await runWrangler(
914
+ "kv:key get my-key --text --namespace-id some-namespace-id"
915
+ );
916
+ expect(proc.write).not.toEqual(Buffer.from("my-value"));
917
+ expect(std).toMatchInlineSnapshot(`
918
+ Object {
919
+ "debug": "",
920
+ "err": "",
921
+ "out": "my-value",
922
+ "warn": "",
848
923
  }
849
- );
850
- return requests;
851
- }
852
-
853
- it("should get a key in a given namespace specified by namespace-id", async () => {
854
- const requests = mockKeyGetRequest(
855
- "some-namespace-id",
856
- "my-key",
857
- "my-value"
858
- );
859
- const { error, stderr, stdout } = await runWrangler(
860
- "kv:key get my-key --namespace-id some-namespace-id"
861
- );
862
- expect(stdout).toMatchInlineSnapshot(`"my-value"`);
863
- expect(stderr).toMatchInlineSnapshot(`""`);
864
- expect(error).toMatchInlineSnapshot(`undefined`);
865
- expect(requests.count).toEqual(1);
866
- });
867
-
868
- it("should get a key in a given namespace specified by binding", async () => {
869
- writeWranglerConfig();
870
- const requests = mockKeyGetRequest("bound-id", "my-key", "my-value");
871
- const { error, stderr, stdout } = await runWrangler(
872
- "kv:key get my-key --binding someBinding --preview false"
873
- );
874
- expect(stdout).toMatchInlineSnapshot(`"my-value"`);
875
- expect(stderr).toMatchInlineSnapshot(`""`);
876
- expect(error).toMatchInlineSnapshot(`undefined`);
877
- expect(requests.count).toEqual(1);
878
- });
879
-
880
- it("should get a key in a given preview namespace specified by binding", async () => {
881
- writeWranglerConfig();
882
- const requests = mockKeyGetRequest(
883
- "preview-bound-id",
884
- "my-key",
885
- "my-value"
886
- );
887
- const { error, stderr, stdout } = await runWrangler(
888
- "kv:key get my-key --binding someBinding --preview"
889
- );
890
- expect(stdout).toMatchInlineSnapshot(`"my-value"`);
891
- expect(stderr).toMatchInlineSnapshot(`""`);
892
- expect(error).toMatchInlineSnapshot(`undefined`);
893
- expect(requests.count).toEqual(1);
894
- });
895
-
896
- it("should get a key for the specified environment in a given namespace", async () => {
897
- writeWranglerConfig();
898
- const requests = mockKeyGetRequest(
899
- "env-bound-id",
900
- "my-key",
901
- "my-value"
902
- );
903
- const { error, stderr, stdout } = await runWrangler(
904
- "kv:key get my-key my-value --binding someBinding --env some-environment --preview false"
905
- );
906
- expect(stdout).toMatchInlineSnapshot(`"my-value"`);
907
- expect(stderr).toMatchInlineSnapshot(`""`);
908
- expect(error).toMatchInlineSnapshot(`undefined`);
909
- expect(requests.count).toEqual(1);
910
- });
911
-
912
- it("should error if no key is provided", async () => {
913
- const { error, stdout, stderr } = await runWrangler("kv:key get");
914
-
915
- expect(stdout).toMatchInlineSnapshot(`""`);
916
- expect(stderr).toMatchInlineSnapshot(`
917
- "wrangler kv:key get <key>
924
+ `);
925
+ });
926
+
927
+ it("should get a binary and decode as utf8 text, resulting in improper decoding", async () => {
928
+ const buf = Buffer.from(
929
+ "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAiSURBVHgB7coxEQAACMPAgH/PgAM6dGwu49fA/deIBXrgAj2cAhIFT4QxAAAAAElFTkSuQmCC",
930
+ "base64"
931
+ );
932
+ setMockFetchKVGetValue(
933
+ "some-account-id",
934
+ "some-namespace-id",
935
+ "my-key",
936
+ buf
937
+ );
938
+ await runWrangler(
939
+ "kv:key get my-key --text --namespace-id some-namespace-id"
940
+ );
941
+ expect(proc.write).not.toEqual(buf);
942
+ expect(JSON.stringify(std)).toMatchInlineSnapshot(
943
+ `"{\\"debug\\":\\"\\",\\"out\\":\\"�PNG\\\\n\\\\u001a\\\\n\\\\u0000\\\\u0000\\\\u0000\\\\rIHDR\\\\u0000\\\\u0000\\\\u0000\\\\n\\\\u0000\\\\u0000\\\\u0000\\\\n\\\\b\\\\u0006\\\\u0000\\\\u0000\\\\u0000�2Ͻ\\\\u0000\\\\u0000\\\\u0000\\\\tpHYs\\\\u0000\\\\u0000\\\\u000b\\\\u0013\\\\u0000\\\\u0000\\\\u000b\\\\u0013\\\\u0001\\\\u0000��\\\\u0018\\\\u0000\\\\u0000\\\\u0000\\\\u0001sRGB\\\\u0000��\\\\u001c�\\\\u0000\\\\u0000\\\\u0000\\\\u0004gAMA\\\\u0000\\\\u0000��\\\\u000b�a\\\\u0005\\\\u0000\\\\u0000\\\\u0000\\\\\\"IDATx\\\\u0001��1\\\\u0011\\\\u0000\\\\u0000\\\\b���π\\\\u0003:tl.����׈\\\\u0005z�\\\\u0002=�\\\\u0002\\\\u0012\\\\u0005O�1\\\\u0000\\\\u0000\\\\u0000\\\\u0000IEND�B\`�\\",\\"err\\":\\"\\",\\"warn\\":\\"\\"}"`
944
+ );
945
+ });
946
+
947
+ it("should get a binary file by key in a given namespace specified by namespace-id", async () => {
948
+ const buf = Buffer.from(
949
+ "iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAiSURBVHgB7coxEQAACMPAgH/PgAM6dGwu49fA/deIBXrgAj2cAhIFT4QxAAAAAElFTkSuQmCC",
950
+ "base64"
951
+ );
952
+ setMockFetchKVGetValue(
953
+ "some-account-id",
954
+ "some-namespace-id",
955
+ "my-key",
956
+ buf
957
+ );
958
+ await runWrangler("kv:key get my-key --namespace-id some-namespace-id");
959
+ expect(proc.write).toEqual(buf);
960
+ expect(std.err).toMatchInlineSnapshot(`""`);
961
+ });
962
+
963
+ it("should get a key in a given namespace specified by binding", async () => {
964
+ writeWranglerConfig();
965
+ setMockFetchKVGetValue(
966
+ "some-account-id",
967
+ "bound-id",
968
+ "my-key",
969
+ "my-value"
970
+ );
971
+ await runWrangler(
972
+ "kv:key get my-key --binding someBinding --preview false"
973
+ );
974
+ expect(proc.write).toEqual(Buffer.from("my-value"));
975
+ expect(std.err).toMatchInlineSnapshot(`""`);
976
+ });
977
+
978
+ it("should get a key in a given preview namespace specified by binding", async () => {
979
+ writeWranglerConfig();
980
+ setMockFetchKVGetValue(
981
+ "some-account-id",
982
+ "preview-bound-id",
983
+ "my-key",
984
+ "my-value"
985
+ );
986
+ await runWrangler("kv:key get my-key --binding someBinding --preview");
987
+ expect(proc.write).toEqual(Buffer.from("my-value"));
988
+ expect(std.err).toMatchInlineSnapshot(`""`);
989
+ });
990
+
991
+ it("should get a key for the specified environment in a given namespace", async () => {
992
+ writeWranglerConfig();
993
+ setMockFetchKVGetValue(
994
+ "some-account-id",
995
+ "env-bound-id",
996
+ "my-key",
997
+ "my-value"
998
+ );
999
+ await runWrangler(
1000
+ "kv:key get my-key --binding someBinding --env some-environment --preview false"
1001
+ );
1002
+ expect(proc.write).toEqual(Buffer.from("my-value"));
1003
+ expect(std.err).toMatchInlineSnapshot(`""`);
1004
+ });
1005
+
1006
+ it("should encode the key in the api request to get a value", async () => {
1007
+ setMockFetchKVGetValue(
1008
+ "some-account-id",
1009
+ "some-namespace-id",
1010
+ "%2Fmy%2Ckey",
1011
+ "my-value"
1012
+ );
1013
+ await runWrangler(
1014
+ "kv:key get /my,key --namespace-id some-namespace-id"
1015
+ );
1016
+ expect(proc.write).toEqual(Buffer.from("my-value"));
1017
+ expect(std.err).toMatchInlineSnapshot(`""`);
1018
+ });
1019
+
1020
+ it("should error if no key is provided", async () => {
1021
+ await expect(
1022
+ runWrangler("kv:key get")
1023
+ ).rejects.toThrowErrorMatchingInlineSnapshot(
1024
+ `"Not enough non-option arguments: got 0, need at least 1"`
1025
+ );
1026
+ expect(std.out).toMatchInlineSnapshot(`
1027
+ "
1028
+ wrangler kv:key get <key>
918
1029
 
919
1030
  Reads a single value by key from the given namespace.
920
1031
 
@@ -927,25 +1038,28 @@ describe("wrangler", () => {
927
1038
  -v, --version Show version number [boolean]
928
1039
 
929
1040
  Options:
930
- -l, --local Run on my machine [boolean] [default: false]
931
1041
  --binding The name of the namespace to get from [string]
932
1042
  --namespace-id The id of the namespace to get from [string]
933
- --env Perform on a specific environment [string]
1043
+ -e, --env Perform on a specific environment [string]
934
1044
  --preview Interact with a preview namespace [boolean] [default: false]
935
-
936
- Not enough non-option arguments: got 0, need at least 1"
1045
+ --text Decode the returned value as a utf8 string [boolean] [default: false]"
937
1046
  `);
938
- expect(error).toMatchInlineSnapshot(
939
- `[Error: Not enough non-option arguments: got 0, need at least 1]`
940
- );
941
- });
942
-
943
- it("should error if no binding nor namespace is provided", async () => {
944
- const { error, stdout, stderr } = await runWrangler("kv:key get foo");
1047
+ expect(std.err).toMatchInlineSnapshot(`
1048
+ "X [ERROR] Not enough non-option arguments: got 0, need at least 1
945
1049
 
946
- expect(stdout).toMatchInlineSnapshot(`""`);
947
- expect(stderr).toMatchInlineSnapshot(`
948
- "wrangler kv:key get <key>
1050
+ "
1051
+ `);
1052
+ });
1053
+
1054
+ it("should error if no binding nor namespace is provided", async () => {
1055
+ await expect(
1056
+ runWrangler("kv:key get foo")
1057
+ ).rejects.toThrowErrorMatchingInlineSnapshot(
1058
+ `"Exactly one of the arguments binding and namespace-id is required"`
1059
+ );
1060
+ expect(std.out).toMatchInlineSnapshot(`
1061
+ "
1062
+ wrangler kv:key get <key>
949
1063
 
950
1064
  Reads a single value by key from the given namespace.
951
1065
 
@@ -958,27 +1072,29 @@ describe("wrangler", () => {
958
1072
  -v, --version Show version number [boolean]
959
1073
 
960
1074
  Options:
961
- -l, --local Run on my machine [boolean] [default: false]
962
1075
  --binding The name of the namespace to get from [string]
963
1076
  --namespace-id The id of the namespace to get from [string]
964
- --env Perform on a specific environment [string]
1077
+ -e, --env Perform on a specific environment [string]
965
1078
  --preview Interact with a preview namespace [boolean] [default: false]
1079
+ --text Decode the returned value as a utf8 string [boolean] [default: false]"
1080
+ `);
1081
+ expect(std.err).toMatchInlineSnapshot(`
1082
+ "X [ERROR] Exactly one of the arguments binding and namespace-id is required
966
1083
 
967
- Exactly one of the arguments binding and namespace-id is required"
1084
+ "
968
1085
  `);
969
- expect(error).toMatchInlineSnapshot(
970
- `[Error: Exactly one of the arguments binding and namespace-id is required]`
971
- );
972
- });
1086
+ });
973
1087
 
974
- it("should error if both binding and namespace is provided", async () => {
975
- const { error, stdout, stderr } = await runWrangler(
976
- "kv:key get foo --binding x --namespace-id y"
977
- );
1088
+ it("should error if both binding and namespace is provided", async () => {
1089
+ await expect(
1090
+ runWrangler("kv:key get foo --binding x --namespace-id y")
1091
+ ).rejects.toThrowErrorMatchingInlineSnapshot(
1092
+ `"Arguments binding and namespace-id are mutually exclusive"`
1093
+ );
978
1094
 
979
- expect(stdout).toMatchInlineSnapshot(`""`);
980
- expect(stderr).toMatchInlineSnapshot(`
981
- "wrangler kv:key get <key>
1095
+ expect(std.out).toMatchInlineSnapshot(`
1096
+ "
1097
+ wrangler kv:key get <key>
982
1098
 
983
1099
  Reads a single value by key from the given namespace.
984
1100
 
@@ -991,136 +1107,513 @@ describe("wrangler", () => {
991
1107
  -v, --version Show version number [boolean]
992
1108
 
993
1109
  Options:
994
- -l, --local Run on my machine [boolean] [default: false]
995
1110
  --binding The name of the namespace to get from [string]
996
1111
  --namespace-id The id of the namespace to get from [string]
997
- --env Perform on a specific environment [string]
1112
+ -e, --env Perform on a specific environment [string]
998
1113
  --preview Interact with a preview namespace [boolean] [default: false]
1114
+ --text Decode the returned value as a utf8 string [boolean] [default: false]"
1115
+ `);
1116
+ expect(std.err).toMatchInlineSnapshot(`
1117
+ "X [ERROR] Arguments binding and namespace-id are mutually exclusive
999
1118
 
1000
- Arguments binding and namespace-id are mutually exclusive"
1119
+ "
1001
1120
  `);
1002
- expect(error).toMatchInlineSnapshot(
1003
- `[Error: Arguments binding and namespace-id are mutually exclusive]`
1004
- );
1005
- });
1006
-
1007
- it("should error if a given binding name is not in the configured kv namespaces", async () => {
1008
- writeWranglerConfig();
1009
- const { error, stdout, stderr } = await runWrangler(
1010
- `kv:key get key --binding otherBinding`
1011
- );
1012
- expect(stdout).toMatchInlineSnapshot(`""`);
1013
- expect(stderr).toMatchInlineSnapshot(`
1014
- "A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\".
1015
-
1016
- %s
1017
- If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
1121
+ });
1122
+
1123
+ it("should error if a given binding name is not in the configured kv namespaces", async () => {
1124
+ writeWranglerConfig();
1125
+ await expect(
1126
+ runWrangler("kv:key get key --binding otherBinding")
1127
+ ).rejects.toThrowErrorMatchingInlineSnapshot(
1128
+ `"A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\"."`
1129
+ );
1130
+ expect(std.out).toMatchInlineSnapshot(`
1131
+ "
1132
+ If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new/choose"
1018
1133
  `);
1019
- expect(error).toMatchInlineSnapshot(
1020
- `[Error: A namespace with binding name "otherBinding" was not found in the configured "kv_namespaces".]`
1021
- );
1022
- });
1023
- });
1024
-
1025
- describe("delete", () => {
1026
- function mockDeleteRequest(
1027
- expectedNamespaceId: string,
1028
- expectedKey: string
1029
- ) {
1030
- const requests = { count: 0 };
1031
- setMockResponse(
1032
- "/accounts/:accountId/storage/kv/namespaces/:namespaceId/values/:key",
1033
- "DELETE",
1034
- ([_url, accountId, namespaceId, key]) => {
1035
- requests.count++;
1036
- expect(accountId).toEqual("some-account-id");
1037
- expect(namespaceId).toEqual(expectedNamespaceId);
1038
- expect(key).toEqual(expectedKey);
1039
- return null;
1040
- }
1041
- );
1042
- return requests;
1043
- }
1044
-
1045
- it("should delete a key in a namespace specified by id", async () => {
1046
- const requests = mockDeleteRequest("some-namespace-id", "someKey");
1047
- await runWrangler(
1048
- `kv:key delete --namespace-id some-namespace-id someKey`
1049
- );
1050
- expect(requests.count).toEqual(1);
1051
- });
1052
-
1053
- it("should delete a key in a namespace specified by binding name", async () => {
1054
- writeWranglerConfig();
1055
- const requests = mockDeleteRequest("bound-id", "someKey");
1056
- await runWrangler(
1057
- `kv:key delete --binding someBinding --preview false someKey`
1058
- );
1059
- expect(requests.count).toEqual(1);
1060
- });
1061
-
1062
- it("should delete a key in a preview namespace specified by binding name", async () => {
1063
- writeWranglerConfig();
1064
- const requests = mockDeleteRequest("preview-bound-id", "someKey");
1065
- await runWrangler(
1066
- `kv:key delete --binding someBinding --preview someKey`
1067
- );
1068
- expect(requests.count).toEqual(1);
1069
- });
1070
-
1071
- it("should error if a given binding name is not in the configured kv namespaces", async () => {
1072
- writeWranglerConfig();
1073
- const { stderr } = await runWrangler(
1074
- `kv:key delete --binding otherBinding someKey`
1075
- );
1076
- expect(stderr).toMatchInlineSnapshot(`
1077
- "A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\".
1078
-
1079
- %s
1080
- If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
1134
+ expect(std.err).toMatchInlineSnapshot(`
1135
+ "X [ERROR] A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\".
1136
+
1137
+ "
1138
+ `);
1139
+ });
1140
+
1141
+ describe("non-interactive", () => {
1142
+ const { setIsTTY } = useMockIsTTY();
1143
+ mockAccountId({ accountId: null });
1144
+
1145
+ it("should error if there are multiple accounts available but not interactive on stdin", async () => {
1146
+ mockGetMemberships([
1147
+ { id: "xxx", account: { id: "1", name: "one" } },
1148
+ { id: "yyy", account: { id: "2", name: "two" } },
1149
+ ]);
1150
+ setIsTTY({ stdin: false, stdout: true });
1151
+ await expect(runWrangler("kv:key get key --namespace-id=xxxx"))
1152
+ .rejects.toThrowErrorMatchingInlineSnapshot(`
1153
+ "More than one account available but unable to select one in non-interactive mode.
1154
+ Please set the appropriate \`account_id\` in your \`wrangler.toml\` file.
1155
+ Available accounts are (\\"<name>\\" - \\"<id>\\"):
1156
+ \\"one\\" - \\"1\\")
1157
+ \\"two\\" - \\"2\\")"
1158
+ `);
1159
+ });
1160
+
1161
+ it("should error if there are multiple accounts available but not interactive on stdout", async () => {
1162
+ mockGetMemberships([
1163
+ { id: "xxx", account: { id: "1", name: "one" } },
1164
+ { id: "yyy", account: { id: "2", name: "two" } },
1165
+ ]);
1166
+ setIsTTY({ stdin: true, stdout: false });
1167
+ await expect(runWrangler("kv:key get key --namespace-id=xxxx"))
1168
+ .rejects.toThrowErrorMatchingInlineSnapshot(`
1169
+ "More than one account available but unable to select one in non-interactive mode.
1170
+ Please set the appropriate \`account_id\` in your \`wrangler.toml\` file.
1171
+ Available accounts are (\\"<name>\\" - \\"<id>\\"):
1172
+ \\"one\\" - \\"1\\")
1173
+ \\"two\\" - \\"2\\")"
1174
+ `);
1175
+ });
1176
+
1177
+ it("should error if there are multiple accounts available but not interactive at all", async () => {
1178
+ mockGetMemberships([
1179
+ { id: "xxx", account: { id: "1", name: "one" } },
1180
+ { id: "yyy", account: { id: "2", name: "two" } },
1181
+ ]);
1182
+ setIsTTY(false);
1183
+ await expect(runWrangler("kv:key get key --namespace-id=xxxx"))
1184
+ .rejects.toThrowErrorMatchingInlineSnapshot(`
1185
+ "More than one account available but unable to select one in non-interactive mode.
1186
+ Please set the appropriate \`account_id\` in your \`wrangler.toml\` file.
1187
+ Available accounts are (\\"<name>\\" - \\"<id>\\"):
1188
+ \\"one\\" - \\"1\\")
1189
+ \\"two\\" - \\"2\\")"
1190
+ `);
1191
+ });
1192
+ });
1193
+ });
1194
+
1195
+ describe("delete", () => {
1196
+ function mockDeleteRequest(
1197
+ expectedNamespaceId: string,
1198
+ expectedKey: string
1199
+ ) {
1200
+ const requests = { count: 0 };
1201
+ setMockResponse(
1202
+ "/accounts/:accountId/storage/kv/namespaces/:namespaceId/values/:key",
1203
+ "DELETE",
1204
+ ([_url, accountId, namespaceId, key]) => {
1205
+ requests.count++;
1206
+ expect(accountId).toEqual("some-account-id");
1207
+ expect(namespaceId).toEqual(expectedNamespaceId);
1208
+ expect(key).toEqual(expectedKey);
1209
+ return null;
1210
+ }
1211
+ );
1212
+ return requests;
1213
+ }
1214
+
1215
+ it("should delete a key in a namespace specified by id", async () => {
1216
+ const requests = mockDeleteRequest("some-namespace-id", "someKey");
1217
+ await runWrangler(
1218
+ `kv:key delete --namespace-id some-namespace-id someKey`
1219
+ );
1220
+ expect(requests.count).toEqual(1);
1221
+ });
1222
+
1223
+ it("should encode the key in the api request to delete a value", async () => {
1224
+ const requests = mockDeleteRequest("voyager", "%2FNCC-74656");
1225
+ await runWrangler(`kv:key delete --namespace-id voyager /NCC-74656`);
1226
+ expect(requests.count).toEqual(1);
1227
+ expect(std.out).toMatchInlineSnapshot(
1228
+ `"Deleting the key \\"/NCC-74656\\" on namespace voyager."`
1229
+ );
1230
+ expect(std.err).toMatchInlineSnapshot(`""`);
1231
+ });
1232
+
1233
+ it("should delete a key in a namespace specified by binding name", async () => {
1234
+ writeWranglerConfig();
1235
+ const requests = mockDeleteRequest("bound-id", "someKey");
1236
+ await runWrangler(
1237
+ `kv:key delete --binding someBinding --preview false someKey`
1238
+ );
1239
+ expect(requests.count).toEqual(1);
1240
+ });
1241
+
1242
+ it("should delete a key in a preview namespace specified by binding name", async () => {
1243
+ writeWranglerConfig();
1244
+ const requests = mockDeleteRequest("preview-bound-id", "someKey");
1245
+ await runWrangler(
1246
+ `kv:key delete --binding someBinding --preview someKey`
1247
+ );
1248
+ expect(requests.count).toEqual(1);
1249
+ });
1250
+
1251
+ it("should error if a given binding name is not in the configured kv namespaces", async () => {
1252
+ writeWranglerConfig();
1253
+ await expect(
1254
+ runWrangler(`kv:key delete --binding otherBinding someKey`)
1255
+ ).rejects.toThrowErrorMatchingInlineSnapshot(
1256
+ `"A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\"."`
1257
+ );
1258
+
1259
+ expect(std.err).toMatchInlineSnapshot(`
1260
+ "X [ERROR] A namespace with binding name \\"otherBinding\\" was not found in the configured \\"kv_namespaces\\".
1261
+
1262
+ "
1263
+ `);
1264
+ });
1265
+
1266
+ it("should delete a key in a namespace specified by binding name in a given environment", async () => {
1267
+ writeWranglerConfig();
1268
+ const requests = mockDeleteRequest("env-bound-id", "someKey");
1269
+ await runWrangler(
1270
+ `kv:key delete --binding someBinding --env some-environment --preview false someKey`
1271
+ );
1272
+ expect(std.out).toMatchInlineSnapshot(
1273
+ `"Deleting the key \\"someKey\\" on namespace env-bound-id."`
1274
+ );
1275
+ expect(std.err).toMatchInlineSnapshot(`""`);
1276
+ expect(requests.count).toEqual(1);
1277
+ });
1278
+
1279
+ it("should delete a key in a preview namespace specified by binding name in a given environment", async () => {
1280
+ writeWranglerConfig();
1281
+ const requests = mockDeleteRequest("preview-env-bound-id", "someKey");
1282
+ await runWrangler(
1283
+ `kv:key delete --binding someBinding --env some-environment --preview someKey`
1284
+ );
1285
+ expect(requests.count).toEqual(1);
1286
+ });
1287
+ });
1288
+ });
1289
+
1290
+ describe("kv:bulk", () => {
1291
+ describe("put", () => {
1292
+ function mockPutRequest(
1293
+ expectedNamespaceId: string,
1294
+ expectedKeyValues: KeyValue[]
1295
+ ) {
1296
+ const requests = { count: 0 };
1297
+ setMockResponse(
1298
+ "/accounts/:accountId/storage/kv/namespaces/:namespaceId/bulk",
1299
+ "PUT",
1300
+ ([_url, accountId, namespaceId], { body }) => {
1301
+ requests.count++;
1302
+ expect(accountId).toEqual("some-account-id");
1303
+ expect(namespaceId).toEqual(expectedNamespaceId);
1304
+ expect(JSON.parse(body as string)).toEqual(
1305
+ expectedKeyValues.slice(
1306
+ (requests.count - 1) * 5000,
1307
+ requests.count * 5000
1308
+ )
1309
+ );
1310
+ return null;
1311
+ }
1312
+ );
1313
+ return requests;
1314
+ }
1315
+
1316
+ it("should put the key-values parsed from a file", async () => {
1317
+ const keyValues: KeyValue[] = [
1318
+ { key: "someKey1", value: "someValue1" },
1319
+ { key: "ns:someKey2", value: "123", base64: true },
1320
+ { key: "someKey3", value: "someValue3", expiration: 100 },
1321
+ { key: "someKey4", value: "someValue4", expiration_ttl: 500 },
1322
+ ];
1323
+ writeFileSync("./keys.json", JSON.stringify(keyValues));
1324
+ const requests = mockPutRequest("some-namespace-id", keyValues);
1325
+ await runWrangler(
1326
+ `kv:bulk put --namespace-id some-namespace-id keys.json`
1327
+ );
1328
+ expect(requests.count).toEqual(1);
1329
+ expect(std.out).toMatchInlineSnapshot(`"Success!"`);
1330
+ expect(std.warn).toMatchInlineSnapshot(`""`);
1331
+ expect(std.err).toMatchInlineSnapshot(`""`);
1332
+ });
1333
+
1334
+ it("should put the key-values in batches of 5000 parsed from a file", async () => {
1335
+ const keyValues: KeyValue[] = new Array(12000).fill({
1336
+ key: "someKey1",
1337
+ value: "someValue1",
1338
+ });
1339
+ writeFileSync("./keys.json", JSON.stringify(keyValues));
1340
+ const requests = mockPutRequest("some-namespace-id", keyValues);
1341
+ await runWrangler(
1342
+ `kv:bulk put --namespace-id some-namespace-id keys.json`
1343
+ );
1344
+ expect(requests.count).toEqual(3);
1345
+ expect(std.out).toMatchInlineSnapshot(`
1346
+ "Uploaded 0% (0 out of 12,000)
1347
+ Uploaded 41% (5,000 out of 12,000)
1348
+ Uploaded 83% (10,000 out of 12,000)
1349
+ Uploaded 100% (12,000 out of 12,000)
1350
+ Success!"
1351
+ `);
1352
+ expect(std.warn).toMatchInlineSnapshot(`""`);
1353
+ expect(std.err).toMatchInlineSnapshot(`""`);
1354
+ });
1355
+
1356
+ it("should error if the file is not a JSON array", async () => {
1357
+ const keyValues = { key: "someKey1", value: "someValue1" };
1358
+ writeFileSync("./keys.json", JSON.stringify(keyValues));
1359
+ await expect(
1360
+ runWrangler(`kv:bulk put --namespace-id some-namespace-id keys.json`)
1361
+ ).rejects.toThrowErrorMatchingInlineSnapshot(`
1362
+ "Unexpected JSON input from \\"keys.json\\".
1363
+ Expected an array of key-value objects but got type \\"object\\"."
1364
+ `);
1365
+ expect(std.out).toMatchInlineSnapshot(`
1366
+ "
1367
+ If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new/choose"
1368
+ `);
1369
+ expect(std.warn).toMatchInlineSnapshot(`""`);
1370
+ });
1371
+
1372
+ it("should error if the array contains items that are not key-value objects", async () => {
1373
+ const keyValues = [
1374
+ 123,
1375
+ "a string",
1376
+ { key: "someKey" },
1377
+ { value: "someValue" },
1378
+ // add a valid object here to make sure it's not included
1379
+ { key: "someKey1", value: "someValue1" },
1380
+ // this one will only add a warning
1381
+ { key: "someKey1", value: "someValue1", invalid: true },
1382
+ // back to the invalid ones
1383
+ { key: 123, value: "somevalue" },
1384
+ { key: "somekey", value: 123 },
1385
+ { key: "someKey1", value: "someValue1", expiration: "string" },
1386
+ { key: "someKey1", value: "someValue1", expiration_ttl: "string" },
1387
+ {
1388
+ key: 123,
1389
+ value: {
1390
+ a: {
1391
+ nested: "object",
1392
+ },
1393
+ },
1394
+ },
1395
+ { key: "someKey1", value: "someValue1", metadata: 123 },
1396
+ { key: "someKey1", value: "someValue1", base64: "string" },
1397
+ ];
1398
+ writeFileSync("./keys.json", JSON.stringify(keyValues));
1399
+ await expect(
1400
+ runWrangler(`kv:bulk put --namespace-id some-namespace-id keys.json`)
1401
+ ).rejects.toThrowErrorMatchingInlineSnapshot(`
1402
+ "Unexpected JSON input from \\"keys.json\\".
1403
+ Each item in the array should be an object that matches:
1404
+
1405
+ interface KeyValue {
1406
+ key: string;
1407
+ value: string;
1408
+ expiration?: number;
1409
+ expiration_ttl?: number;
1410
+ metadata?: object;
1411
+ base64?: boolean;
1412
+ }
1413
+
1414
+ The item at index 0 is 123
1415
+ The item at index 1 is \\"a string\\"
1416
+ The item at index 2 is {\\"key\\":\\"someKey\\"}
1417
+ The item at index 3 is {\\"value\\":\\"someValue\\"}
1418
+ The item at index 6 is {\\"key\\":123,\\"value\\":\\"somevalue\\"}
1419
+ The item at index 7 is {\\"key\\":\\"somekey\\",\\"value\\":123}
1420
+ The item at index 8 is {\\"key\\":\\"someKey1\\",\\"value\\":\\"someValue1\\",\\"expiration\\":\\"string\\"}
1421
+ The item at index 9 is {\\"key\\":\\"someKey1\\",\\"value\\":\\"someValue1\\",\\"expiration_ttl\\":\\"string\\"}
1422
+ The item at index 10 is {\\"key\\":123,\\"value\\":{\\"a\\":{\\"nested\\":\\"object\\"}}}
1423
+ The item at index 11 is {\\"key\\":\\"someKey1\\",\\"value\\":\\"someValue1\\",\\"metadata\\":123}
1424
+ The item at index 12 is {\\"key\\":\\"someKey1\\",\\"value\\":\\"someValue1\\",\\"base64\\":\\"string\\"}"
1425
+ `);
1426
+
1427
+ expect(std.out).toMatchInlineSnapshot(`
1428
+ "
1429
+ If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new/choose"
1430
+ `);
1431
+ expect(std.warn).toMatchInlineSnapshot(`
1432
+ "▲ [WARNING] Unexpected key-value properties in \\"keys.json\\".
1433
+
1434
+ The item at index 5 contains unexpected properties: [\\"invalid\\"].
1435
+
1436
+ "
1437
+ `);
1438
+ });
1439
+ });
1440
+
1441
+ describe("delete", () => {
1442
+ function mockDeleteRequest(
1443
+ expectedNamespaceId: string,
1444
+ expectedKeys: string[]
1445
+ ) {
1446
+ const requests = { count: 0 };
1447
+ setMockResponse(
1448
+ "/accounts/:accountId/storage/kv/namespaces/:namespaceId/bulk",
1449
+ "DELETE",
1450
+ ([_url, accountId, namespaceId], { headers, body }) => {
1451
+ requests.count++;
1452
+ expect(accountId).toEqual("some-account-id");
1453
+ expect(namespaceId).toEqual(expectedNamespaceId);
1454
+ expect(new Headers(headers ?? []).get("Content-Type")).toEqual(
1455
+ "application/json"
1456
+ );
1457
+ expect(JSON.parse(body as string)).toEqual(
1458
+ expectedKeys.slice(
1459
+ (requests.count - 1) * 5000,
1460
+ requests.count * 5000
1461
+ )
1462
+ );
1463
+ return null;
1464
+ }
1465
+ );
1466
+ return requests;
1467
+ }
1468
+
1469
+ it("should delete the keys parsed from a file", async () => {
1470
+ const keys = ["someKey1", "ns:someKey2"];
1471
+ writeFileSync("./keys.json", JSON.stringify(keys));
1472
+ mockConfirm({
1473
+ text: `Are you sure you want to delete all the keys read from "keys.json" from kv-namespace with id "some-namespace-id"?`,
1474
+ result: true,
1475
+ });
1476
+ const requests = mockDeleteRequest("some-namespace-id", keys);
1477
+ await runWrangler(
1478
+ `kv:bulk delete --namespace-id some-namespace-id keys.json`
1479
+ );
1480
+ expect(requests.count).toEqual(1);
1481
+ expect(std.out).toMatchInlineSnapshot(`"Success!"`);
1482
+ expect(std.warn).toMatchInlineSnapshot(`""`);
1483
+ expect(std.err).toMatchInlineSnapshot(`""`);
1484
+ });
1485
+
1486
+ it("should delete the keys in batches of 5000 parsed from a file", async () => {
1487
+ const keys = new Array(12000).fill("some-key");
1488
+ writeFileSync("./keys.json", JSON.stringify(keys));
1489
+ mockConfirm({
1490
+ text: `Are you sure you want to delete all the keys read from "keys.json" from kv-namespace with id "some-namespace-id"?`,
1491
+ result: true,
1492
+ });
1493
+ const requests = mockDeleteRequest("some-namespace-id", keys);
1494
+ await runWrangler(
1495
+ `kv:bulk delete --namespace-id some-namespace-id keys.json`
1496
+ );
1497
+ expect(requests.count).toEqual(3);
1498
+ expect(std.out).toMatchInlineSnapshot(`
1499
+ "Deleted 0% (0 out of 12,000)
1500
+ Deleted 41% (5,000 out of 12,000)
1501
+ Deleted 83% (10,000 out of 12,000)
1502
+ Deleted 100% (12,000 out of 12,000)
1503
+ Success!"
1504
+ `);
1505
+ expect(std.warn).toMatchInlineSnapshot(`""`);
1506
+ expect(std.err).toMatchInlineSnapshot(`""`);
1507
+ });
1508
+
1509
+ it("should not delete the keys if the user confirms no", async () => {
1510
+ const keys = ["someKey1", "ns:someKey2"];
1511
+ writeFileSync("./keys.json", JSON.stringify(keys));
1512
+ mockConfirm({
1513
+ text: `Are you sure you want to delete all the keys read from "keys.json" from kv-namespace with id "some-namespace-id"?`,
1514
+ result: false,
1515
+ });
1516
+ await runWrangler(
1517
+ `kv:bulk delete --namespace-id some-namespace-id keys.json`
1518
+ );
1519
+ expect(std.out).toMatchInlineSnapshot(
1520
+ `"Not deleting keys read from \\"keys.json\\"."`
1521
+ );
1522
+ expect(std.warn).toMatchInlineSnapshot(`""`);
1523
+ expect(std.err).toMatchInlineSnapshot(`""`);
1524
+ });
1525
+
1526
+ it("should delete the keys without asking if --force is provided", async () => {
1527
+ const keys = ["someKey1", "ns:someKey2"];
1528
+ writeFileSync("./keys.json", JSON.stringify(keys));
1529
+ const requests = mockDeleteRequest("some-namespace-id", keys);
1530
+ await runWrangler(
1531
+ `kv:bulk delete --namespace-id some-namespace-id keys.json --force`
1532
+ );
1533
+ expect(requests.count).toEqual(1);
1534
+ expect(std.out).toMatchInlineSnapshot(`"Success!"`);
1535
+ expect(std.warn).toMatchInlineSnapshot(`""`);
1536
+ expect(std.err).toMatchInlineSnapshot(`""`);
1537
+ });
1538
+
1539
+ it("should delete the keys without asking if -f is provided", async () => {
1540
+ const keys = ["someKey1", "ns:someKey2"];
1541
+ writeFileSync("./keys.json", JSON.stringify(keys));
1542
+ const requests = mockDeleteRequest("some-namespace-id", keys);
1543
+ await runWrangler(
1544
+ `kv:bulk delete --namespace-id some-namespace-id keys.json -f`
1545
+ );
1546
+ expect(requests.count).toEqual(1);
1547
+ expect(std.out).toMatchInlineSnapshot(`"Success!"`);
1548
+ expect(std.warn).toMatchInlineSnapshot(`""`);
1549
+ expect(std.err).toMatchInlineSnapshot(`""`);
1550
+ });
1551
+
1552
+ it("should error if the file is not a JSON array", async () => {
1553
+ const keys = 12354;
1554
+ writeFileSync("./keys.json", JSON.stringify(keys));
1555
+ mockConfirm({
1556
+ text: `Are you sure you want to delete all the keys read from "keys.json" from kv-namespace with id "some-namespace-id"?`,
1557
+ result: true,
1558
+ });
1559
+ await expect(
1560
+ runWrangler(
1561
+ `kv:bulk delete --namespace-id some-namespace-id keys.json`
1562
+ )
1563
+ ).rejects.toThrowErrorMatchingInlineSnapshot(`
1564
+ "Unexpected JSON input from \\"keys.json\\".
1565
+ Expected an array of strings but got:
1566
+ 12354"
1567
+ `);
1568
+ expect(std.out).toMatchInlineSnapshot(`
1569
+ "
1570
+ If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new/choose"
1571
+ `);
1572
+ expect(std.warn).toMatchInlineSnapshot(`""`);
1573
+ });
1574
+
1575
+ it("should error if the file contains non-string items", async () => {
1576
+ const keys = ["good", 12354, { key: "someKey" }, null];
1577
+ writeFileSync("./keys.json", JSON.stringify(keys));
1578
+ mockConfirm({
1579
+ text: `Are you sure you want to delete all the keys read from "keys.json" from kv-namespace with id "some-namespace-id"?`,
1580
+ result: true,
1581
+ });
1582
+ await expect(
1583
+ runWrangler(
1584
+ `kv:bulk delete --namespace-id some-namespace-id keys.json`
1585
+ )
1586
+ ).rejects.toThrowErrorMatchingInlineSnapshot(`
1587
+ "Unexpected JSON input from \\"keys.json\\".
1588
+ Expected an array of strings.
1589
+ The item at index 1 is type: \\"number\\" - 12354
1590
+ The item at index 2 is type: \\"object\\" - {\\"key\\":\\"someKey\\"}
1591
+ The item at index 3 is type: \\"object\\" - null"
1592
+ `);
1593
+ expect(std.out).toMatchInlineSnapshot(`
1594
+ "
1595
+ If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new/choose"
1081
1596
  `);
1082
- });
1083
-
1084
- it("should delete a key in a namespace specified by binding name in a given environment", async () => {
1085
- writeWranglerConfig();
1086
- const requests = mockDeleteRequest("env-bound-id", "someKey");
1087
- const { stdout, stderr, error } = await runWrangler(
1088
- `kv:key delete --binding someBinding --env some-environment --preview false someKey`
1089
- );
1090
- expect(stdout).toMatchInlineSnapshot(
1091
- `"deleting the key \\"someKey\\" on namespace env-bound-id"`
1092
- );
1093
- expect(stderr).toMatchInlineSnapshot(`""`);
1094
- expect(error).toMatchInlineSnapshot(`undefined`);
1095
- expect(requests.count).toEqual(1);
1096
- });
1097
-
1098
- it("should delete a key in a preview namespace specified by binding name in a given environment", async () => {
1099
- writeWranglerConfig();
1100
- const requests = mockDeleteRequest("preview-env-bound-id", "someKey");
1101
- await runWrangler(
1102
- `kv:key delete --binding someBinding --env some-environment --preview someKey`
1103
- );
1104
- expect(requests.count).toEqual(1);
1105
- });
1106
- });
1107
- });
1597
+ expect(std.warn).toMatchInlineSnapshot(`""`);
1598
+ });
1599
+ });
1600
+ });
1108
1601
  });
1109
1602
 
1110
1603
  function writeWranglerConfig() {
1111
- writeFileSync(
1112
- "./wrangler.toml",
1113
- [
1114
- 'name = "otherWorker"',
1115
- "kv_namespaces = [",
1116
- ' { binding = "someBinding", id = "bound-id", preview_id = "preview-bound-id" }',
1117
- "]",
1118
- "",
1119
- "[env.some-environment]",
1120
- "kv_namespaces = [",
1121
- ' { binding = "someBinding", id = "env-bound-id", preview_id = "preview-env-bound-id" }',
1122
- "]",
1123
- ].join("\n"),
1124
- "utf-8"
1125
- );
1604
+ writeFileSync(
1605
+ "./wrangler.toml",
1606
+ [
1607
+ 'name = "other-worker"',
1608
+ "kv_namespaces = [",
1609
+ ' { binding = "someBinding", id = "bound-id", preview_id = "preview-bound-id" }',
1610
+ "]",
1611
+ "",
1612
+ "[env.some-environment]",
1613
+ "kv_namespaces = [",
1614
+ ' { binding = "someBinding", id = "env-bound-id", preview_id = "preview-env-bound-id" }',
1615
+ "]",
1616
+ ].join("\n"),
1617
+ "utf-8"
1618
+ );
1126
1619
  }