wrangler 0.0.0-e043479 → 0.0.0-e0b9366

package/src/__tests__/publish.test.ts

@@ -2,14 +2,20 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as TOML from "@iarna/toml";
 import { mockAccountId, mockApiToken } from "./helpers/mock-account-id";
-import { setMockResponse, unsetAllMocks } from "./helpers/mock-cfetch";
+import {
+  createFetchResult,
+  setMockFetchKVGetValue,
+  setMockRawResponse,
+  setMockResponse,
+  unsetAllMocks,
+  unsetMockFetchKVGetValues,
+} from "./helpers/mock-cfetch";
 import { mockConsoleMethods } from "./helpers/mock-console";
 import { mockKeyListRequest } from "./helpers/mock-kv";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 import writeWranglerToml from "./helpers/write-wrangler-toml";
-import type { WorkerMetadata } from "../api/form_data";
-import type { Config } from "../config";
+import type { WorkerMetadata } from "../create-worker-upload-form";
 import type { KVNamespaceInfo } from "../kv";
 import type { FormData, File } from "undici";
 
@@ -27,6 +33,7 @@ describe("publish", () => {
 
   afterEach(() => {
     unsetAllMocks();
+    unsetMockFetchKVGetValues();
   });
 
   describe("environments", () => {
@@ -143,6 +150,7 @@ describe("publish", () => {
           type: "json",
         },
       ],
+      expectedCompatibilityDate: "2022-01-12",
     });
     mockSubDomainRequest();
     await runWrangler("publish ./some-path/worker/index.js");
@@ -460,9 +468,8 @@ export default{
 
     it('should error if a site definition doesn\'t have a "bucket" field', async () => {
       writeWranglerToml({
-        site: {
-          "entry-point": "./index.js",
-        } as Config["site"],
+        // @ts-expect-error we're intentionally setting an invalid config
+        site: {},
       });
       writeWorkerSource();
       mockUploadWorkerRequest();
@@ -471,20 +478,20 @@ export default{
       await expect(runWrangler("publish ./index.js")).rejects
         .toThrowErrorMatchingInlineSnapshot(`
               "Processing wrangler.toml configuration:
-                - ERROR: \\"site.bucket\\" is a required field."
+                - \\"site.bucket\\" is a required field."
             `);
 
       expect(std.out).toMatchInlineSnapshot(`""`);
       expect(std.err).toMatchInlineSnapshot(`
         "Processing wrangler.toml configuration:
-          - ERROR: \\"site.bucket\\" is a required field.
+          - \\"site.bucket\\" is a required field.
 
         %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
       `);
       expect(std.warn).toMatchInlineSnapshot(`""`);
     });
 
-    it("should warn if there is a `site.entry-point` configuration", async () => {
+    it("should error if there is a `site.entry-point` configuration", async () => {
       const assets = [
         { filePath: "assets/file-1.txt", content: "Content of file-1" },
         { filePath: "assets/file-2.txt", content: "Content of file-2" },
@@ -508,22 +515,26 @@ export default{
       mockKeyListRequest(kvNamespace.id, []);
       mockUploadAssetsToKVRequest(kvNamespace.id, assets);
 
-      await runWrangler("publish ./index.js");
+      await expect(runWrangler("publish ./index.js")).rejects
+        .toThrowErrorMatchingInlineSnapshot(`
+              "Processing wrangler.toml configuration:
+                - DEPRECATION: \\"site.entry-point\\":
+                  The \`site.entry-point\` config field is no longer used.
+                  The entry-point should be specified via the command line or the \`main\` config field."
+            `);
 
-      expect(std.out).toMatchInlineSnapshot(`
-        "reading assets/file-1.txt...
-        uploading as assets/file-1.2ca234f380.txt...
-        reading assets/file-2.txt...
-        uploading as assets/file-2.5938485188.txt...
-        Uploaded test-name (TIMINGS)
-        Published test-name (TIMINGS)
-          test-name.test-sub-domain.workers.dev"
+      expect(std.out).toMatchInlineSnapshot(`""`);
+      expect(std.err).toMatchInlineSnapshot(`
+        "Processing wrangler.toml configuration:
+          - DEPRECATION: \\"site.entry-point\\":
+            The \`site.entry-point\` config field is no longer used.
+            The entry-point should be specified via the command line or the \`main\` config field.
+
+        %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
       `);
-      expect(std.err).toMatchInlineSnapshot(`""`);
       expect(std.warn).toMatchInlineSnapshot(`
-        "Deprecation notice: The \`site.entry-point\` config field is no longer used.
-        The entry-point should be specified via the command line (e.g. \`wrangler publish path/to/script\`) or the \`main\` config field.
-        Please remove the \`site.entry-point\` field from the \`wrangler.toml\` file."
+        "Processing wrangler.toml configuration:
+          - Unexpected fields found in site field: \\"entry-point\\""
       `);
     });
 
@@ -802,7 +813,9 @@ export default{
       mockSubDomainRequest();
       mockListKVNamespacesRequest(kvNamespace);
       // Put file-1 in the KV namespace
-      mockKeyListRequest(kvNamespace.id, ["assets/file-1.2ca234f380.txt"]);
+      mockKeyListRequest(kvNamespace.id, [
+        { name: "assets/file-1.2ca234f380.txt" },
+      ]);
       // Check we do not upload file-1
       mockUploadAssetsToKVRequest(
         kvNamespace.id,
@@ -1224,6 +1237,152 @@ export default{
         %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
       `);
     });
+
+    describe("expire unused assets", () => {
+      it("should expire uploaded assets that aren't included anymore", async () => {
+        const assets = [
+          { filePath: "assets/file-1.txt", content: "Content of file-1" },
+          { filePath: "assets/file-2.txt", content: "Content of file-2" },
+        ];
+        const kvNamespace = {
+          title: "__test-name-workers_sites_assets",
+          id: "__test-name-workers_sites_assets-id",
+        };
+        writeWranglerToml({
+          main: "./index.js",
+          site: {
+            bucket: "assets",
+          },
+        });
+        writeWorkerSource();
+        writeAssets(assets);
+        mockUploadWorkerRequest();
+        mockSubDomainRequest();
+        mockListKVNamespacesRequest(kvNamespace);
+        mockKeyListRequest(kvNamespace.id, [
+          // Put file-1 in the KV namespace
+          { name: "assets/file-1.2ca234f380.txt" },
+          // As well as a couple from a previous upload
+          { name: "assets/file-3.somehash.txt" },
+          { name: "assets/file-4.anotherhash.txt" },
+        ]);
+
+        // Check that we pull down the values of file-3.txt and file-4.txt
+        setMockFetchKVGetValue(
+          "some-account-id",
+          "__test-name-workers_sites_assets-id",
+          "assets/file-3.somehash.txt",
+          Buffer.from("Content of file-3", "utf8").toString("base64")
+        );
+        setMockFetchKVGetValue(
+          "some-account-id",
+          "__test-name-workers_sites_assets-id",
+          "assets/file-4.anotherhash.txt",
+          Buffer.from("Content of file-4", "utf8").toString("base64")
+        );
+
+        // and send them back up
+        mockUploadAssetsToKVRequest(kvNamespace.id, [
+          ...assets.filter((a) => a.filePath !== "assets/file-1.txt"),
+          {
+            filePath: "assets/file-3.txt",
+            content: "Content of file-3",
+            // expect to expire this asset 300 seconds from now
+            expiration_ttl: 300,
+          },
+          {
+            filePath: "assets/file-4.txt",
+            content: "Content of file-4",
+            // expect to expire this asset 300 seconds from now
+            expiration_ttl: 300,
+          },
+        ]);
+
+        await runWrangler("publish");
+
+        expect(std.out).toMatchInlineSnapshot(`
+          "reading assets/file-1.txt...
+          skipping - already uploaded
+          reading assets/file-2.txt...
+          uploading as assets/file-2.5938485188.txt...
+          expiring unused assets/file-3.somehash.txt...
+          expiring unused assets/file-4.anotherhash.txt...
+          Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
+        `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+      });
+
+      it("should not try to expire uploaded assets that are already set to expire", async () => {
+        const assets = [
+          {
+            filePath: "assets/file-1.txt",
+            content: "Content of file-1",
+          },
+          { filePath: "assets/file-2.txt", content: "Content of file-2" },
+        ];
+        const kvNamespace = {
+          title: "__test-name-workers_sites_assets",
+          id: "__test-name-workers_sites_assets-id",
+        };
+        writeWranglerToml({
+          main: "./index.js",
+          site: {
+            bucket: "assets",
+          },
+        });
+        writeWorkerSource();
+        writeAssets(assets);
+        mockUploadWorkerRequest();
+        mockSubDomainRequest();
+        mockListKVNamespacesRequest(kvNamespace);
+        // These return with an expiration added on each of them
+        mockKeyListRequest(kvNamespace.id, [
+          // Put file-1 in the KV namespace, with an expiration
+          { name: "assets/file-1.2ca234f380.txt", expiration: 10000 },
+          // As well as a couple from a previous upload
+          // This one's set to expire so it won't be uploaded back
+          { name: "assets/file-3.somehash.txt", expiration: 10000 },
+          // This one will be sent back with an expiration value
+          { name: "assets/file-4.anotherhash.txt" },
+        ]);
+
+        setMockFetchKVGetValue(
+          "some-account-id",
+          "__test-name-workers_sites_assets-id",
+          "assets/file-4.anotherhash.txt",
+          Buffer.from("Content of file-4", "utf8").toString("base64")
+        );
+
+        mockUploadAssetsToKVRequest(kvNamespace.id, [
+          // so it'll re-upload file-1 because it's set to expire
+          // and file-2 because it hasn't been uploaded yet
+          ...assets,
+          // and it'll expire file-4 since it's just not included anymore
+          {
+            filePath: "assets/file-4.txt",
+            content: "Content of file-4",
+            // expect to expire this asset 300 seconds from now
+            expiration_ttl: 300,
+          },
+        ]);
+
+        await runWrangler("publish");
+
+        expect(std.out).toMatchInlineSnapshot(`
+          "reading assets/file-1.txt...
+          uploading as assets/file-1.2ca234f380.txt...
+          reading assets/file-2.txt...
+          uploading as assets/file-2.5938485188.txt...
+          expiring unused assets/file-4.anotherhash.txt...
+          Uploaded test-name (TIMINGS)
+          Published test-name (TIMINGS)
+            test-name.test-sub-domain.workers.dev"
+        `);
+        expect(std.err).toMatchInlineSnapshot(`""`);
+      });
+    });
   });
 
   describe("workers_dev setting", () => {
@@ -1267,7 +1426,6 @@ export default{
       });
       writeWorkerSource();
       mockUploadWorkerRequest();
-      mockSubDomainRequest();
       mockUpdateWorkerRequest({ enabled: false });
 
       await runWrangler("publish ./index");
@@ -1279,6 +1437,193 @@ export default{
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
 
+    it("should disable the workers.dev domain if workers_dev is undefined but overwritten to `false` in environment", async () => {
+      writeWranglerToml({
+        env: {
+          dev: {
+            workers_dev: false,
+          },
+        },
+      });
+      writeWorkerSource();
+      mockUploadWorkerRequest({
+        env: "dev",
+      });
+      mockUpdateWorkerRequest({ enabled: false, env: "dev" });
+
+      await runWrangler("publish ./index --env dev --legacy-env false");
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name (dev) (TIMINGS)
+        No publish targets for test-name (dev) (TIMINGS)"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should disable the workers.dev domain if workers_dev is `true` but overwritten to `false` in environment", async () => {
+      writeWranglerToml({
+        workers_dev: true,
+        env: {
+          dev: {
+            workers_dev: false,
+          },
+        },
+      });
+      writeWorkerSource();
+      mockUploadWorkerRequest({
+        env: "dev",
+      });
+      mockUpdateWorkerRequest({ enabled: false, env: "dev" });
+
+      await runWrangler("publish ./index --env dev --legacy-env false");
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name (dev) (TIMINGS)
+        No publish targets for test-name (dev) (TIMINGS)"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should publish to a workers.dev domain if workers_dev is undefined but overwritten to `true` in environment", async () => {
+      writeWranglerToml({
+        env: {
+          dev: {
+            workers_dev: true,
+          },
+        },
+      });
+      writeWorkerSource();
+      mockUploadWorkerRequest({
+        env: "dev",
+      });
+      mockSubDomainRequest();
+      mockUpdateWorkerRequest({ enabled: true, env: "dev" });
+
+      await runWrangler("publish ./index --env dev --legacy-env false");
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name (dev) (TIMINGS)
+        Published test-name (dev) (TIMINGS)
+          dev.test-name.test-sub-domain.workers.dev"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should publish to a workers.dev domain if workers_dev is `false` but overwritten to `true` in environment", async () => {
+      writeWranglerToml({
+        workers_dev: false,
+        env: {
+          dev: {
+            workers_dev: true,
+          },
+        },
+      });
+      writeWorkerSource();
+      mockUploadWorkerRequest({
+        env: "dev",
+      });
+      mockSubDomainRequest();
+      mockUpdateWorkerRequest({ enabled: true, env: "dev" });
+
+      await runWrangler("publish ./index --env dev --legacy-env false");
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name (dev) (TIMINGS)
+        Published test-name (dev) (TIMINGS)
+          dev.test-name.test-sub-domain.workers.dev"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should use the global compatibility_date and compatibility_flags if they are not overwritten by the environment", async () => {
+      writeWranglerToml({
+        compatibility_date: "2022-01-12",
+        compatibility_flags: ["no_global_navigator"],
+        env: {
+          dev: {},
+        },
+      });
+      writeWorkerSource();
+      mockUploadWorkerRequest({
+        env: "dev",
+        expectedCompatibilityDate: "2022-01-12",
+        expectedCompatibilityFlags: ["no_global_navigator"],
+      });
+      mockSubDomainRequest();
+      mockUpdateWorkerRequest({ enabled: true, env: "dev" });
+
+      await runWrangler("publish ./index --env dev --legacy-env false");
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name (dev) (TIMINGS)
+        Published test-name (dev) (TIMINGS)
+          dev.test-name.test-sub-domain.workers.dev"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should use the environment specific compatibility_date and compatibility_flags", async () => {
+      writeWranglerToml({
+        compatibility_date: "2022-01-12",
+        compatibility_flags: ["no_global_navigator"],
+        env: {
+          dev: {
+            compatibility_date: "2022-01-13",
+            compatibility_flags: ["global_navigator"],
+          },
+        },
+      });
+      writeWorkerSource();
+      mockUploadWorkerRequest({
+        env: "dev",
+        expectedCompatibilityDate: "2022-01-13",
+        expectedCompatibilityFlags: ["global_navigator"],
+      });
+      mockSubDomainRequest();
+      mockUpdateWorkerRequest({ enabled: true, env: "dev" });
+
+      await runWrangler("publish ./index --env dev --legacy-env false");
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name (dev) (TIMINGS)
+        Published test-name (dev) (TIMINGS)
+          dev.test-name.test-sub-domain.workers.dev"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
+    it("should use the command line --compatibility-date and --compatibility-flags if they are specified", async () => {
+      writeWranglerToml({
+        compatibility_date: "2022-01-12",
+        compatibility_flags: ["no_global_navigator"],
+        env: {
+          dev: {
+            compatibility_date: "2022-01-13",
+            compatibility_flags: ["global_navigator"],
+          },
+        },
+      });
+      writeWorkerSource();
+      mockUploadWorkerRequest({
+        env: "dev",
+        expectedCompatibilityDate: "2022-01-14",
+        expectedCompatibilityFlags: ["url_standard"],
+      });
+      mockSubDomainRequest();
+      mockUpdateWorkerRequest({ enabled: true, env: "dev" });
+
+      await runWrangler(
+        "publish ./index --env dev --legacy-env false --compatibility-date 2022-01-14 --compatibility-flags url_standard"
+      );
+
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name (dev) (TIMINGS)
+        Published test-name (dev) (TIMINGS)
+          dev.test-name.test-sub-domain.workers.dev"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+    });
+
     it("should enable the workers.dev domain if workers_dev is undefined and subdomain is not already available", async () => {
       writeWranglerToml();
       writeWorkerSource();
@@ -1312,6 +1657,22 @@ export default{
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
     });
+
+    it("should error politely when publishing to workers_dev when there is no workers.dev subdomain", async () => {
+      writeWranglerToml({
+        workers_dev: true,
+      });
+      writeWorkerSource();
+      mockUploadWorkerRequest();
+      mockSubDomainRequest("does-not-exist", false);
+
+      await expect(runWrangler("publish ./index")).rejects
+        .toThrowErrorMatchingInlineSnapshot(`
+              "Error: You need to register a workers.dev subdomain before publishing to workers.dev
+              You can either publish your worker to one or more routes by specifying them in wrangler.toml, or register a workers.dev subdomain here:
+              https://dash.cloudflare.com/some-account-id/workers/onboarding"
+            `);
+    });
   });
 
   describe("custom builds", () => {
@@ -1367,6 +1728,30 @@ export default{
         expect(std.warn).toMatchInlineSnapshot(`""`);
       });
     }
+
+    it("should throw an error if the entry doesn't exist after the build finishes", async () => {
+      writeWranglerToml({
+        main: "index.js",
+        build: {
+          command: `node -e "console.log('custom build');"`,
+        },
+      });
+
+      await expect(
+        runWrangler("publish index.js")
+      ).rejects.toThrowErrorMatchingInlineSnapshot(
+        `"Could not resolve \\"index.js\\" after running custom build: node -e \\"console.log('custom build');\\""`
+      );
+      expect(std.out).toMatchInlineSnapshot(
+        `"running: node -e \\"console.log('custom build');\\""`
+      );
+      expect(std.err).toMatchInlineSnapshot(`
+        "Could not resolve \\"index.js\\" after running custom build: node -e \\"console.log('custom build');\\"
+
+        %s If you think this is a bug then please create an issue at https://github.com/cloudflare/wrangler2/issues/new."
+      `);
+      expect(std.warn).toMatchInlineSnapshot(`""`);
+    });
   });
 
   describe("[wasm_modules]", () => {
@@ -1447,6 +1832,7 @@ export default{
         expectedBindings: [
           { name: "TESTWASMNAME", part: "TESTWASMNAME", type: "wasm_module" },
         ],
+        expectedCompatibilityDate: "2022-01-12",
       });
       mockSubDomainRequest();
       await runWrangler("publish index.js --config ./path/to/wrangler.toml");
@@ -1575,6 +1961,7 @@ export default{
             type: "text_blob",
           },
         ],
+        expectedCompatibilityDate: "2022-01-12",
       });
       mockSubDomainRequest();
       await runWrangler("publish index.js --config ./path/to/wrangler.toml");
@@ -1919,6 +2306,62 @@ export default{
       `);
     });
   });
+
+  describe("legacy module specifiers", () => {
+    it("should work with legacy module specifiers, with a deprecation warning (1)", async () => {
+      writeWranglerToml({
+        rules: [{ type: "Text", globs: ["**/*.file"], fallthrough: false }],
+      });
+      fs.writeFileSync(
+        "./index.js",
+        `import TEXT from 'text.file'; export default {};`
+      );
+      fs.writeFileSync("./text.file", "SOME TEXT CONTENT");
+      mockSubDomainRequest();
+      mockUploadWorkerRequest({
+        expectedModules: {
+          "./2d91d1c4dd6e57d4f5432187ab7c25f45a8973f0-text.file":
+            "SOME TEXT CONTENT",
+        },
+      });
+      await runWrangler("publish index.js");
+      expect(std.out).toMatchInlineSnapshot(`
+        "Uploaded test-name (TIMINGS)
+        Published test-name (TIMINGS)
+          test-name.test-sub-domain.workers.dev"
+      `);
+      expect(std.err).toMatchInlineSnapshot(`""`);
+      expect(std.warn).toMatchInlineSnapshot(
+        `"Deprecation warning: detected a legacy module import in \\"./index.js\\". This will stop working in the future. Replace references to \\"text.file\\" with \\"./text.file\\";"`
+      );
+    });
+  });
+
+  it("should work with legacy module specifiers, with a deprecation warning (2)", async () => {
+    writeWranglerToml();
+    fs.writeFileSync(
+      "./index.js",
+      `import WASM from 'index.wasm'; export default {};`
+    );
+    fs.writeFileSync("./index.wasm", "SOME WASM CONTENT");
+    mockSubDomainRequest();
+    mockUploadWorkerRequest({
+      expectedModules: {
+        "./94b240d0d692281e6467aa42043986e5c7eea034-index.wasm":
+          "SOME WASM CONTENT",
+      },
+    });
+    await runWrangler("publish index.js");
+    expect(std.out).toMatchInlineSnapshot(`
+      "Uploaded test-name (TIMINGS)
+      Published test-name (TIMINGS)
+        test-name.test-sub-domain.workers.dev"
+    `);
+    expect(std.err).toMatchInlineSnapshot(`""`);
+    expect(std.warn).toMatchInlineSnapshot(
+      `"Deprecation warning: detected a legacy module import in \\"./index.js\\". This will stop working in the future. Replace references to \\"index.wasm\\" with \\"./index.wasm\\";"`
+    );
+  });
 });
 
 /** Write a mock Worker script to disk. */
@@ -1966,6 +2409,8 @@ function mockUploadWorkerRequest({
   expectedType = "esm",
   expectedBindings,
   expectedModules = {},
+  expectedCompatibilityDate,
+  expectedCompatibilityFlags,
   env = undefined,
   legacyEnv = false,
 }: {
@@ -1974,8 +2419,10 @@ function mockUploadWorkerRequest({
   expectedType?: "esm" | "sw";
   expectedBindings?: unknown;
   expectedModules?: Record<string, string>;
-  env?: string | undefined;
-  legacyEnv?: boolean | undefined;
+  expectedCompatibilityDate?: string;
+  expectedCompatibilityFlags?: string[];
+  env?: string;
+  legacyEnv?: boolean;
 } = {}) {
   setMockResponse(
     env && !legacyEnv
@@ -1997,7 +2444,6 @@ function mockUploadWorkerRequest({
           expectedEntry
         );
       }
-
       const metadata = JSON.parse(
         formBody.get("metadata") as string
       ) as WorkerMetadata;
@@ -2009,6 +2455,14 @@ function mockUploadWorkerRequest({
       if (expectedBindings !== undefined) {
         expect(metadata.bindings).toEqual(expectedBindings);
       }
+      if (expectedCompatibilityDate !== undefined) {
+        expect(metadata.compatibility_date).toEqual(expectedCompatibilityDate);
+      }
+      if (expectedCompatibilityFlags !== undefined) {
+        expect(metadata.compatibility_flags).toEqual(
+          expectedCompatibilityFlags
+        );
+      }
       for (const [name, content] of Object.entries(expectedModules)) {
         expect(await (formBody.get(name) as File).text()).toEqual(content);
       }
@@ -2019,10 +2473,21 @@ function mockUploadWorkerRequest({
 }
 
 /** Create a mock handler for the request to get the account's subdomain. */
-function mockSubDomainRequest(subdomain = "test-sub-domain") {
-  setMockResponse("/accounts/:accountId/workers/subdomain", "GET", () => {
-    return { subdomain };
-  });
+function mockSubDomainRequest(
+  subdomain = "test-sub-domain",
+  registeredWorkersDev = true
+) {
+  if (registeredWorkersDev) {
+    setMockResponse("/accounts/:accountId/workers/subdomain", "GET", () => {
+      return { subdomain };
+    });
+  } else {
+    setMockRawResponse("/accounts/:accountId/workers/subdomain", "GET", () => {
+      return createFetchResult(null, false, [
+        { code: 10007, message: "haven't registered workers.dev" },
+      ]);
+    });
+  }
 }
 
 /** Create a mock handler to toggle a <script>.<user>.workers.dev subdomain */
@@ -2103,7 +2568,12 @@ function mockListKVNamespacesRequest(...namespaces: KVNamespaceInfo[]) {
 /** Create a mock handler for the request that tries to do a bulk upload of assets to a KV namespace. */
 function mockUploadAssetsToKVRequest(
   expectedNamespaceId: string,
-  assets: { filePath: string; content: string }[]
+  assets: {
+    filePath: string;
+    content: string;
+    expiration?: number;
+    expiration_ttl?: number;
+  }[]
 ) {
   setMockResponse(
     "/accounts/:accountId/storage/kv/namespaces/:namespaceId/bulk",
@@ -2132,6 +2602,8 @@ function mockUploadAssetsToKVRequest(
         expect(Buffer.from(upload.value, "base64").toString()).toEqual(
           asset.content
         );
+        expect(upload.expiration).toEqual(asset.expiration);
+        expect(upload.expiration_ttl).toEqual(asset.expiration_ttl);
       }
       return null;
     }