wrangler 0.0.0-e2f9bb2 → 0.0.0-e322475

package/src/__tests__/init.test.ts

@@ -1,17 +1,30 @@
 import * as fs from "node:fs";
-import * as fsp from "node:fs/promises";
 import path from "node:path";
 import * as TOML from "@iarna/toml";
-import { execa } from "execa";
+import { execa, execaSync } from "execa";
 import { parseConfigFileTextToJson } from "typescript";
 import { version as wranglerVersion } from "../../package.json";
 import { getPackageManager } from "../package-manager";
 import { mockConsoleMethods } from "./helpers/mock-console";
-import { mockConfirm, clearConfirmMocks } from "./helpers/mock-dialogs";
+import {
+  mockConfirm,
+  clearConfirmMocks,
+  mockSelect,
+  clearSelectMocks,
+} from "./helpers/mock-dialogs";
 import { runInTempDir } from "./helpers/run-in-tmp";
 import { runWrangler } from "./helpers/run-wrangler";
 import type { PackageManager } from "../package-manager";
 
+/**
+ * An expectation matcher for the minimal generated wrangler.toml.
+ */
+const MINIMAL_WRANGLER_TOML = {
+  compatibility_date: expect.any(String),
+  name: expect.stringContaining("wrangler-tests"),
+  main: "src/index.ts",
+};
+
 describe("init", () => {
   let mockPackageManager: PackageManager;
   runInTempDir();
@@ -29,6 +42,7 @@ describe("init", () => {
 
   afterEach(() => {
     clearConfirmMocks();
+    clearSelectMocks();
   });
 
   const std = mockConsoleMethods();
@@ -37,20 +51,26 @@ describe("init", () => {
     it("should initialize with no interactive prompts if `--yes` is used", async () => {
       await runWrangler("init --yes");
 
-      expect(fs.existsSync("./src/index.js")).toBe(false);
-      expect(fs.existsSync("./src/index.ts")).toBe(true);
-      expect(fs.existsSync("./tsconfig.json")).toBe(true);
-      expect(fs.existsSync("./package.json")).toBe(true);
-      expect(fs.existsSync("./wrangler.toml")).toBe(true);
+      checkFiles({
+        items: {
+          "./src/index.js": false,
+          "./src/index.ts": true,
+          "./tsconfig.json": true,
+          "./package.json": true,
+          "./wrangler.toml": true,
+        },
+      });
+
       expect(std.out).toMatchInlineSnapshot(`
-        "✨ Successfully created wrangler.toml
+        "✨ Created wrangler.toml
         ✨ Initialized git repository
         ✨ Created package.json
-        ✨ Created tsconfig.json, installed @cloudflare/workers-types into devDependencies
+        ✨ Created tsconfig.json
         ✨ Created src/index.ts
+        ✨ Installed @cloudflare/workers-types and typescript into devDependencies
 
         To start developing your Worker, run \`npm start\`
-        To publish your Worker to the Internet, run \`npm run publish\`"
+        To publish your Worker to the Internet, run \`npm run deploy\`"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
       expect(std.warn).toMatchInlineSnapshot(`""`);
@@ -59,24 +79,29 @@ describe("init", () => {
     it("should initialize with no interactive prompts if `--yes` is used (named worker)", async () => {
       await runWrangler("init my-worker --yes");
 
-      expect(fs.existsSync("./my-worker/src/index.js")).toBe(false);
-      expect(fs.existsSync("./my-worker/src/index.ts")).toBe(true);
-      expect(fs.existsSync("./my-worker/tsconfig.json")).toBe(true);
-      expect(fs.existsSync("./my-worker/package.json")).toBe(true);
-      expect(fs.existsSync("./my-worker/wrangler.toml")).toBe(true);
-      const parsedWranglerToml = TOML.parse(
-        fs.readFileSync("./my-worker/wrangler.toml", "utf-8")
-      );
-      expect(parsedWranglerToml.main).toEqual("src/index.ts");
+      checkFiles({
+        items: {
+          "./my-worker/src/index.js": false,
+          "./my-worker/src/index.ts": true,
+          "./my-worker/tsconfig.json": true,
+          "./my-worker/package.json": true,
+          "./my-worker/wrangler.toml": wranglerToml({
+            ...MINIMAL_WRANGLER_TOML,
+            name: "my-worker",
+          }),
+        },
+      });
+
       expect(std.out).toMatchInlineSnapshot(`
-        "✨ Successfully created wrangler.toml
-        ✨ Initialized git repository
-        ✨ Created package.json
-        ✨ Created tsconfig.json, installed @cloudflare/workers-types into devDependencies
-        ✨ Created src/index.ts
+        "✨ Created my-worker/wrangler.toml
+        ✨ Initialized git repository at my-worker
+        ✨ Created my-worker/package.json
+        ✨ Created my-worker/tsconfig.json
+        ✨ Created my-worker/src/index.ts
+        ✨ Installed @cloudflare/workers-types and typescript into devDependencies
 
         To start developing your Worker, run \`cd my-worker && npm start\`
-        To publish your Worker to the Internet, run \`npm run publish\`"
+        To publish your Worker to the Internet, run \`npm run deploy\`"
       `);
       expect(std.err).toMatchInlineSnapshot(`""`);
       expect(std.warn).toMatchInlineSnapshot(`""`);
@@ -85,23 +110,29 @@ describe("init", () => {
     it("should initialize with no interactive prompts if `-y` is used", async () => {
       await runWrangler("init -y");
 
-      expect(fs.existsSync("./src/index.js")).toBe(false);
-      expect(fs.existsSync("./src/index.ts")).toBe(true);
-      expect(fs.existsSync("./tsconfig.json")).toBe(true);
-      expect(fs.existsSync("./package.json")).toBe(true);
-      expect(fs.existsSync("./wrangler.toml")).toBe(true);
+      checkFiles({
+        items: {
+          "./src/index.js": false,
+          "./src/index.ts": true,
+          "./tsconfig.json": true,
+          "./package.json": true,
+          "./wrangler.toml": true,
+        },
+      });
+
       expect(std).toMatchInlineSnapshot(`
         Object {
           "debug": "",
           "err": "",
-          "out": "✨ Successfully created wrangler.toml
+          "out": "✨ Created wrangler.toml
         ✨ Initialized git repository
         ✨ Created package.json
-        ✨ Created tsconfig.json, installed @cloudflare/workers-types into devDependencies
+        ✨ Created tsconfig.json
         ✨ Created src/index.ts
+        ✨ Installed @cloudflare/workers-types and typescript into devDependencies
 
         To start developing your Worker, run \`npm start\`
-        To publish your Worker to the Internet, run \`npm run publish\`",
+        To publish your Worker to the Internet, run \`npm run deploy\`",
           "warn": "",
         }
       `);
@@ -161,11 +192,25 @@ describe("init", () => {
         }
       );
       await runWrangler("init");
-      const parsed = TOML.parse(await fsp.readFile("./wrangler.toml", "utf-8"));
-      expect(typeof parsed.compatibility_date).toBe("string");
-      expect(parsed.name).toContain("wrangler-tests");
-      expect(fs.existsSync("./package.json")).toBe(false);
-      expect(fs.existsSync("./tsconfig.json")).toBe(false);
+      checkFiles({
+        items: {
+          "wrangler.toml": wranglerToml({
+            compatibility_date: expect.any(String),
+            name: expect.stringContaining("wrangler-tests"),
+          }),
+          "package.json": false,
+          "tsconfig.json": false,
+        },
+      });
+
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created wrangler.toml",
+          "warn": "",
+        }
+      `);
     });
 
     it("should create a wrangler.toml and a directory for a named Worker ", async () => {
@@ -180,37 +225,113 @@ describe("init", () => {
         }
       );
       await runWrangler("init my-worker");
-      const parsed = TOML.parse(
-        await fsp.readFile("./my-worker/wrangler.toml", "utf-8")
-      );
-      expect(typeof parsed.compatibility_date).toBe("string");
-      expect(parsed.name).toBe("my-worker");
-      expect(fs.existsSync("./my-worker/package.json")).toBe(false);
-      expect(fs.existsSync("./my-worker/tsconfig.json")).toBe(false);
+
+      checkFiles({
+        items: {
+          "my-worker/wrangler.toml": wranglerToml({
+            compatibility_date: expect.any(String),
+            name: "my-worker",
+          }),
+          "my-worker/package.json": false,
+          "my-worker/tsconfig.json": false,
+        },
+      });
+
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created my-worker/wrangler.toml",
+          "warn": "",
+        }
+      `);
     });
 
     it("should display warning when wrangler.toml already exists, and exit if user does not want to carry on", async () => {
-      fs.writeFileSync(
-        "./wrangler.toml",
-        'compatibility_date="something-else"', // use a fake value to make sure the file is not overwritten
-        "utf-8"
-      );
+      writeFiles({
+        items: {
+          "wrangler.toml": wranglerToml({
+            // use a fake value to make sure the file is not overwritten
+            compatibility_date: "something-else",
+          }),
+        },
+      });
+
       mockConfirm({
         text: "Do you want to continue initializing this project?",
         result: false,
       });
+
       await runWrangler("init");
-      expect(std.warn).toContain("wrangler.toml file already exists!");
-      const parsed = TOML.parse(await fsp.readFile("./wrangler.toml", "utf-8"));
-      expect(parsed.compatibility_date).toBe("something-else");
+      expect(std.warn).toContain("wrangler.toml already exists!");
+
+      checkFiles({
+        items: {
+          "wrangler.toml": wranglerToml({
+            compatibility_date: "something-else",
+          }),
+          "package.json": false,
+          "tsconfig.json": false,
+        },
+      });
+
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "",
+          "warn": "▲ [WARNING] wrangler.toml already exists!
+
+        ",
+        }
+      `);
+    });
+
+    it("should display warning when wrangler.toml already exists in the target directory, and exit if user does not want to carry on", async () => {
+      writeFiles({
+        items: {
+          "path/to/worker/wrangler.toml": wranglerToml({
+            compatibility_date: "something-else",
+          }),
+        },
+      });
+      mockConfirm({
+        text: "Do you want to continue initializing this project?",
+        result: false,
+      });
+
+      await runWrangler("init path/to/worker");
+
+      expect(std.warn).toContain("wrangler.toml already exists!");
+      checkFiles({
+        items: {
+          "path/to/worker/wrangler.toml": wranglerToml({
+            compatibility_date: "something-else",
+          }),
+          "package.json": false,
+          "tsconfig.json": false,
+        },
+      });
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "",
+          "warn": "▲ [WARNING] path/to/worker/wrangler.toml already exists!
+
+        ",
+        }
+      `);
     });
 
     it("should not overwrite an existing wrangler.toml, after agreeing to other prompts", async () => {
-      fs.writeFileSync(
-        "./wrangler.toml",
-        'compatibility_date="something-else"', // use a fake value to make sure the file is not overwritten
-        "utf-8"
-      );
+      writeFiles({
+        items: {
+          "wrangler.toml": wranglerToml({
+            compatibility_date: "something-else",
+          }),
+        },
+      });
       mockConfirm(
         {
           text: "Would you like to use git to manage this Worker?",
@@ -227,25 +348,33 @@ describe("init", () => {
         {
           text: "Would you like to use TypeScript?",
           result: true,
-        },
-        {
-          text: "Would you like to create a Worker at src/index.ts?",
-          result: true,
         }
       );
 
+      mockSelect({
+        text: "Would you like to create a Worker at src/index.ts?",
+        result: "fetch",
+      });
+
       await runWrangler("init");
-      expect(fs.readFileSync("./wrangler.toml", "utf-8")).toMatchInlineSnapshot(
-        `"compatibility_date=\\"something-else\\""`
-      );
+
+      checkFiles({
+        items: {
+          "wrangler.toml": wranglerToml({
+            compatibility_date: "something-else",
+          }),
+        },
+      });
     });
 
     it("should display warning when wrangler.toml already exists, but continue if user does want to carry on", async () => {
-      fs.writeFileSync(
-        "./wrangler.toml",
-        `compatibility_date="something-else"`,
-        "utf-8"
-      );
+      writeFiles({
+        items: {
+          "wrangler.toml": wranglerToml({
+            compatibility_date: "something-else",
+          }),
+        },
+      });
       mockConfirm(
         {
           text: "Do you want to continue initializing this project?",
@@ -260,10 +389,101 @@ describe("init", () => {
           result: false,
         }
       );
+
+      await runWrangler("init");
+
+      expect(std.warn).toContain("wrangler.toml already exists!");
+      checkFiles({
+        items: {
+          "wrangler.toml": wranglerToml({
+            compatibility_date: "something-else",
+          }),
+        },
+      });
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "",
+          "warn": "▲ [WARNING] wrangler.toml already exists!
+
+        ",
+        }
+      `);
+    });
+
+    it("should not add a Cron Trigger to wrangler.toml when creating a Scheduled Worker if wrangler.toml already exists", async () => {
+      writeFiles({
+        items: {
+          "wrangler.toml": wranglerToml({
+            compatibility_date: "something-else",
+          }),
+        },
+      });
+      mockConfirm(
+        {
+          text: "Would you like to use git to manage this Worker?",
+          result: true,
+        },
+        {
+          text: "Do you want to continue initializing this project?",
+          result: true,
+        },
+        {
+          text: "No package.json found. Would you like to create one?",
+          result: true,
+        },
+        {
+          text: "Would you like to use TypeScript?",
+          result: true,
+        }
+      );
+      mockSelect({
+        text: "Would you like to create a Worker at src/index.ts?",
+        result: "scheduled",
+      });
+
+      await runWrangler("init");
+
+      checkFiles({
+        items: {
+          "wrangler.toml": wranglerToml({
+            compatibility_date: "something-else",
+          }),
+        },
+      });
+    });
+
+    it("should add a Cron Trigger to wrangler.toml when creating a Scheduled Worker, but only if wrangler.toml is being created during init", async () => {
+      mockConfirm(
+        {
+          text: "Would you like to use git to manage this Worker?",
+          result: true,
+        },
+        {
+          text: "No package.json found. Would you like to create one?",
+          result: true,
+        },
+        {
+          text: "Would you like to use TypeScript?",
+          result: true,
+        }
+      );
+      mockSelect({
+        text: "Would you like to create a Worker at src/index.ts?",
+        result: "scheduled",
+      });
+
       await runWrangler("init");
-      expect(std.warn).toContain("wrangler.toml file already exists!");
-      const parsed = TOML.parse(await fsp.readFile("./wrangler.toml", "utf-8"));
-      expect(parsed.compatibility_date).toBe("something-else");
+
+      checkFiles({
+        items: {
+          "wrangler.toml": wranglerToml({
+            ...MINIMAL_WRANGLER_TOML,
+            triggers: { crons: ["1 * * * *"] },
+          }),
+        },
+      });
     });
   });
 
@@ -279,48 +499,124 @@ describe("init", () => {
           result: false,
         }
       );
+
       await runWrangler("init");
+
+      checkFiles({
+        items: {
+          "wrangler.toml": wranglerToml({
+            compatibility_date: expect.any(String),
+            name: expect.stringContaining("wrangler-tests"),
+          }),
+          ".git": { items: {} },
+          ".gitignore": true,
+        },
+      });
       expect(std).toMatchInlineSnapshot(`
         Object {
           "debug": "",
           "err": "",
-          "out": "✨ Successfully created wrangler.toml
+          "out": "✨ Created wrangler.toml
         ✨ Initialized git repository",
           "warn": "",
         }
       `);
-      expect(fs.lstatSync(".git").isDirectory()).toBe(true);
-      expect(fs.lstatSync(".gitignore").isFile()).toBe(true);
+      expect((await execa("git", ["branch", "--show-current"])).stdout).toEqual(
+        "main"
+      );
     });
 
     it("should not offer to initialize a git repo if it's already inside one", async () => {
       await execa("git", ["init"]);
-      fs.mkdirSync("some-folder");
-      process.chdir("some-folder");
+      setWorkingDirectory("some-folder");
+
       await runWrangler("init -y");
 
+      checkFiles({
+        items: {
+          "wrangler.toml": wranglerToml({
+            ...MINIMAL_WRANGLER_TOML,
+            name: "some-folder",
+          }),
+          ".git": { items: {} },
+          ".gitignore": false,
+        },
+      });
+
       // Note the lack of "✨ Initialized git repository" in the log
       expect(std).toMatchInlineSnapshot(`
         Object {
           "debug": "",
           "err": "",
-          "out": "✨ Successfully created wrangler.toml
-        ✨ Initialized git repository
+          "out": "✨ Created wrangler.toml
         ✨ Created package.json
-        ✨ Created tsconfig.json, installed @cloudflare/workers-types into devDependencies
+        ✨ Created tsconfig.json
         ✨ Created src/index.ts
+        ✨ Installed @cloudflare/workers-types and typescript into devDependencies
 
         To start developing your Worker, run \`npm start\`
-        To publish your Worker to the Internet, run \`npm run publish\`",
+        To publish your Worker to the Internet, run \`npm run deploy\`",
+          "warn": "",
+        }
+      `);
+    });
+
+    it("should not offer to initialize a git repo if it's already inside one (when using a path as name)", async () => {
+      fs.mkdirSync("path/to/worker", { recursive: true });
+      await execa("git", ["init"], { cwd: "path/to/worker" });
+      expect(fs.lstatSync("path/to/worker/.git").isDirectory()).toBe(true);
+
+      await runWrangler("init path/to/worker/my-worker -y");
+
+      // Note the lack of "✨ Initialized git repository" in the log
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created path/to/worker/my-worker/wrangler.toml
+        ✨ Created path/to/worker/my-worker/package.json
+        ✨ Created path/to/worker/my-worker/tsconfig.json
+        ✨ Created path/to/worker/my-worker/src/index.ts
+        ✨ Installed @cloudflare/workers-types and typescript into devDependencies
+
+        To start developing your Worker, run \`cd path/to/worker/my-worker && npm start\`
+        To publish your Worker to the Internet, run \`npm run deploy\`",
           "warn": "",
         }
       `);
     });
 
+    // I... don't know how to test this lol
     it.todo(
       "should not offer to initialize a git repo if git is not installed"
     );
-    // I... don't know how to test this lol
+
+    it("should initialize git repo with `main` default branch", async () => {
+      mockConfirm(
+        {
+          text: "Would you like to use git to manage this Worker?",
+          result: true,
+        },
+        {
+          text: "No package.json found. Would you like to create one?",
+          result: false,
+        }
+      );
+      await runWrangler("init");
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created wrangler.toml
+        ✨ Initialized git repository",
+          "warn": "",
+        }
+      `);
+
+      expect(execaSync("git", ["symbolic-ref", "HEAD"]).stdout).toEqual(
+        "refs/heads/main"
+      );
+    });
   });
 
   describe("package.json", () => {
@@ -337,24 +633,39 @@ describe("init", () => {
         {
           text: "Would you like to use TypeScript?",
           result: false,
-        },
-        {
-          text: "Would you like to create a Worker at src/index.js?",
-          result: false,
         }
       );
+      mockSelect({
+        text: "Would you like to create a Worker at src/index.js?",
+        result: "none",
+      });
+
       await runWrangler("init");
-      expect(fs.existsSync("./package.json")).toBe(true);
-      const packageJson = JSON.parse(
-        fs.readFileSync("./package.json", "utf-8")
-      );
-      expect(packageJson.name).toContain("wrangler-tests");
-      expect(packageJson.version).toEqual("0.0.0");
-      expect(packageJson.devDependencies).toEqual({
-        wrangler: expect.any(String),
+
+      checkFiles({
+        items: {
+          "package.json": {
+            contents: expect.objectContaining({
+              name: expect.stringContaining("wrangler-tests"),
+              version: "0.0.0",
+              devDependencies: {
+                wrangler: expect.any(String),
+              },
+            }),
+          },
+          "tsconfig.json": false,
+        },
       });
-      expect(fs.existsSync("./tsconfig.json")).toBe(false);
       expect(mockPackageManager.install).toHaveBeenCalled();
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created wrangler.toml
+        ✨ Created package.json",
+          "warn": "",
+        }
+      `);
     });
 
     it("should create a package.json, with the specified name, if none is found and user confirms", async () => {
@@ -370,17 +681,38 @@ describe("init", () => {
         {
           text: "Would you like to use TypeScript?",
           result: false,
-        },
-        {
-          text: "Would you like to create a Worker at src/index.js?",
-          result: false,
         }
       );
+      mockSelect({
+        text: "Would you like to create a Worker at my-worker/src/index.js?",
+        result: "none",
+      });
+
       await runWrangler("init my-worker");
-      const packageJson = JSON.parse(
-        fs.readFileSync("./my-worker/package.json", "utf-8")
-      );
-      expect(packageJson.name).toBe("my-worker");
+
+      checkFiles({
+        items: {
+          "my-worker/package.json": {
+            contents: expect.objectContaining({
+              name: "my-worker",
+              version: "0.0.0",
+              devDependencies: {
+                wrangler: expect.any(String),
+              },
+            }),
+          },
+          "my-worker/tsconfig.json": false,
+        },
+      });
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created my-worker/wrangler.toml
+        ✨ Created my-worker/package.json",
+          "warn": "",
+        }
+      `);
     });
 
     it("should not touch an existing package.json in the same directory", async () => {
@@ -390,110 +722,240 @@ describe("init", () => {
           result: false,
         },
         {
-          text: "Would you like to install wrangler into your package.json?",
+          text: "Would you like to install wrangler into package.json?",
           result: false,
         },
         {
           text: "Would you like to use TypeScript?",
           result: false,
-        },
-        {
-          text: "Would you like to create a Worker at src/index.js?",
-          result: false,
         }
       );
-
-      fs.writeFileSync(
-        "./package.json",
-        JSON.stringify({ name: "test", version: "1.0.0" }),
-        "utf-8"
-      );
+      mockSelect({
+        text: "Would you like to create a Worker at src/index.js?",
+        result: "none",
+      });
+      writeFiles({
+        items: {
+          "package.json": { contents: { name: "test", version: "1.0.0" } },
+        },
+      });
 
       await runWrangler("init");
-      const packageJson = JSON.parse(
-        fs.readFileSync("./package.json", "utf-8")
-      );
-      expect(packageJson.name).toEqual("test");
-      expect(packageJson.version).toEqual("1.0.0");
+
+      checkFiles({
+        items: {
+          "package.json": { contents: { name: "test", version: "1.0.0" } },
+        },
+      });
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created wrangler.toml",
+          "warn": "",
+        }
+      `);
     });
 
-    it("should offer to install wrangler into an existing package.json", async () => {
+    it("should not touch an existing package.json in an ancestor directory, when a name is passed", async () => {
       mockConfirm(
         {
           text: "Would you like to use git to manage this Worker?",
           result: false,
         },
         {
-          text: "Would you like to install wrangler into your package.json?",
+          text: "No package.json found. Would you like to create one?",
           result: true,
         },
         {
-          text: "Would you like to use TypeScript?",
+          text: "Would you like to install wrangler into path/to/worker/my-worker/package.json?",
           result: false,
         },
         {
-          text: "Would you like to create a Worker at src/index.js?",
+          text: "Would you like to use TypeScript?",
           result: false,
         }
       );
+      mockSelect({
+        text: "Would you like to create a Worker at path/to/worker/my-worker/src/index.js?",
+        result: "none",
+      });
+      writeFiles({
+        items: {
+          "path/to/worker/package.json": {
+            contents: { name: "test", version: "1.0.0" },
+          },
+        },
+      });
 
-      fs.writeFileSync(
-        "./package.json",
-        JSON.stringify({ name: "test", version: "1.0.0" }),
-        "utf-8"
-      );
+      await runWrangler("init path/to/worker/my-worker");
 
-      await runWrangler("init");
-      const packageJson = JSON.parse(
-        fs.readFileSync("./package.json", "utf-8")
-      );
-      expect(packageJson.name).toEqual("test");
-      expect(packageJson.version).toEqual("1.0.0");
-      expect(mockPackageManager.addDevDeps).toHaveBeenCalledWith(
-        `wrangler@${wranglerVersion}`
-      );
+      checkFiles({
+        items: {
+          "path/to/worker/package.json": {
+            contents: { name: "test", version: "1.0.0" },
+          },
+        },
+      });
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created path/to/worker/my-worker/wrangler.toml
+        ✨ Created path/to/worker/my-worker/package.json",
+          "warn": "",
+        }
+      `);
     });
 
-    it("should not touch an existing package.json in an ancestor directory", async () => {
+    it("should offer to install wrangler into an existing package.json", async () => {
       mockConfirm(
         {
           text: "Would you like to use git to manage this Worker?",
           result: false,
         },
         {
-          text: "Would you like to install wrangler into your package.json?",
-          result: false,
+          text: "Would you like to install wrangler into package.json?",
+          result: true,
         },
         {
           text: "Would you like to use TypeScript?",
           result: false,
+        }
+      );
+      mockSelect({
+        text: "Would you like to create a Worker at src/index.js?",
+        result: "none",
+      });
+      writeFiles({
+        items: {
+          "package.json": {
+            contents: { name: "test", version: "1.0.0" },
+          },
+        },
+      });
+
+      await runWrangler("init");
+
+      checkFiles({
+        items: {
+          "package.json": {
+            contents: { name: "test", version: "1.0.0" },
+          },
+        },
+      });
+      expect(mockPackageManager.addDevDeps).toHaveBeenCalledWith(
+        `wrangler@${wranglerVersion}`
+      );
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created wrangler.toml
+        ✨ Installed wrangler into devDependencies",
+          "warn": "",
+        }
+      `);
+    });
+
+    it("should offer to install wrangler into a package.json relative to the target directory, if no name is provided", async () => {
+      mockConfirm(
+        {
+          text: "Would you like to use git to manage this Worker?",
+          result: false,
         },
         {
-          text: "Would you like to create a Worker at src/index.js?",
+          text: "Would you like to install wrangler into ../package.json?",
+          result: true,
+        },
+        {
+          text: "Would you like to use TypeScript?",
           result: false,
         }
       );
+      mockSelect({
+        text: "Would you like to create a Worker at src/index.js?",
+        result: "none",
+      });
+      writeFiles({
+        items: {
+          "path/to/worker/package.json": {
+            contents: { name: "test", version: "1.0.0" },
+          },
+        },
+      });
+      setWorkingDirectory("path/to/worker/my-worker");
 
-      fs.writeFileSync(
-        "./package.json",
-        JSON.stringify({ name: "test", version: "1.0.0" }),
-        "utf-8"
+      await runWrangler("init");
+
+      setWorkingDirectory("../../../..");
+      checkFiles({
+        items: {
+          "path/to/worker/package.json": {
+            contents: { name: "test", version: "1.0.0" },
+          },
+          "path/to/worker/my-worker/package.json": false,
+        },
+      });
+      expect(mockPackageManager.addDevDeps).toHaveBeenCalledWith(
+        `wrangler@${wranglerVersion}`
       );
+      expect(mockPackageManager.cwd).toBe(process.cwd());
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created wrangler.toml
+        ✨ Installed wrangler into devDependencies",
+          "warn": "",
+        }
+      `);
+    });
 
-      fs.mkdirSync("./sub-1/sub-2", { recursive: true });
-      process.chdir("./sub-1/sub-2");
+    it("should not touch an existing package.json in an ancestor directory", async () => {
+      mockConfirm(
+        {
+          text: "Would you like to use git to manage this Worker?",
+          result: false,
+        },
+        {
+          text: "Would you like to install wrangler into ../../package.json?",
+          result: false,
+        },
+        {
+          text: "Would you like to use TypeScript?",
+          result: false,
+        }
+      );
+      mockSelect({
+        text: "Would you like to create a Worker at src/index.js?",
+        result: "none",
+      });
+      writeFiles({
+        items: {
+          "package.json": {
+            contents: { name: "test", version: "1.0.0" },
+          },
+        },
+      });
+      setWorkingDirectory("./sub-1/sub-2");
 
       await runWrangler("init");
-      expect(fs.existsSync("./package.json")).toBe(false);
-      expect(fs.existsSync("../../package.json")).toBe(true);
 
-      const packageJson = JSON.parse(
-        fs.readFileSync("../../package.json", "utf-8")
-      );
-      expect(packageJson).toMatchInlineSnapshot(`
+      checkFiles({
+        items: {
+          "package.json": false,
+          "../../package.json": {
+            contents: { name: "test", version: "1.0.0" },
+          },
+        },
+      });
+      expect(std).toMatchInlineSnapshot(`
         Object {
-          "name": "test",
-          "version": "1.0.0",
+          "debug": "",
+          "err": "",
+          "out": "✨ Created wrangler.toml",
+          "warn": "",
         }
       `);
     });
@@ -507,28 +969,50 @@ describe("init", () => {
           result: false,
         },
         {
-          text: "Would you like to install wrangler into your package.json?",
+          text: "Would you like to install wrangler into package.json?",
           result: false,
         },
         {
           text: "Would you like to use TypeScript?",
           result: false,
-        },
-        {
-          text: "Would you like to create a Worker at src/index.js?",
-          result: true,
         }
       );
-
-      fs.writeFileSync(
-        "./package.json",
-        JSON.stringify({ name: "test", version: "1.0.0" }),
-        "utf-8"
-      );
+      mockSelect({
+        text: "Would you like to create a Worker at src/index.js?",
+        result: "fetch",
+      });
+      writeFiles({
+        items: {
+          "package.json": {
+            contents: { name: "test", version: "1.0.0" },
+          },
+        },
+      });
 
       await runWrangler("init");
-      expect(fs.existsSync("./src/index.js")).toBe(true);
-      expect(fs.existsSync("./src/index.ts")).toBe(false);
+
+      checkFiles({
+        items: {
+          "wrangler.toml": wranglerToml({
+            ...MINIMAL_WRANGLER_TOML,
+            main: "src/index.js",
+          }),
+          "src/index.js": true,
+          "src/index.ts": false,
+        },
+      });
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created wrangler.toml
+        ✨ Created src/index.js
+
+        To start developing your Worker, run \`npx wrangler dev\`
+        To publish your Worker to the Internet, run \`npx wrangler publish\`",
+          "warn": "",
+        }
+      `);
     });
 
     it("should offer to create a worker in a typescript project", async () => {
@@ -538,28 +1022,48 @@ describe("init", () => {
           result: false,
         },
         {
-          text: "Would you like to install wrangler into your package.json?",
+          text: "Would you like to install wrangler into package.json?",
           result: false,
         },
         {
           text: "Would you like to use TypeScript?",
           result: true,
-        },
-        {
-          text: "Would you like to create a Worker at src/index.ts?",
-          result: true,
         }
       );
-
-      fs.writeFileSync(
-        "./package.json",
-        JSON.stringify({ name: "test", version: "1.0.0" }),
-        "utf-8"
-      );
+      mockSelect({
+        text: "Would you like to create a Worker at src/index.ts?",
+        result: "fetch",
+      });
+      writeFiles({
+        items: {
+          "package.json": {
+            contents: { name: "test", version: "1.0.0" },
+          },
+        },
+      });
 
       await runWrangler("init");
-      expect(fs.existsSync("./src/index.js")).toBe(false);
-      expect(fs.existsSync("./src/index.ts")).toBe(true);
+
+      checkFiles({
+        items: {
+          "src/index.js": false,
+          "src/index.ts": true,
+        },
+      });
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created wrangler.toml
+        ✨ Created tsconfig.json
+        ✨ Created src/index.ts
+        ✨ Installed @cloudflare/workers-types and typescript into devDependencies
+
+        To start developing your Worker, run \`npx wrangler dev\`
+        To publish your Worker to the Internet, run \`npx wrangler publish\`",
+          "warn": "",
+        }
+      `);
     });
 
     it("should add scripts for a typescript project with .ts extension", async () => {
@@ -573,40 +1077,46 @@ describe("init", () => {
           result: true,
         },
         {
-          text: "Would you like to install wrangler into your package.json?",
+          text: "Would you like to install wrangler into package.json?",
           result: false,
         },
         {
           text: "Would you like to use TypeScript?",
           result: true,
-        },
-        {
-          text: "Would you like to create a Worker at src/index.ts?",
-          result: true,
         }
       );
-      await runWrangler("init");
-
-      expect(fs.existsSync("./package.json")).toBe(true);
-      const packageJson = JSON.parse(
-        fs.readFileSync("./package.json", "utf-8")
-      );
+      mockSelect({
+        text: "Would you like to create a Worker at src/index.ts?",
+        result: "fetch",
+      });
 
-      expect(fs.existsSync("./src/index.js")).toBe(false);
-      expect(fs.existsSync("./src/index.ts")).toBe(true);
+      await runWrangler("init");
 
-      expect(packageJson.scripts.start).toBe("wrangler dev");
-      expect(packageJson.scripts.publish).toBe("wrangler publish");
-      expect(packageJson.name).toContain("wrangler-tests");
-      expect(packageJson.version).toEqual("0.0.0");
+      checkFiles({
+        items: {
+          "package.json": {
+            contents: expect.objectContaining({
+              name: expect.stringContaining("wrangler-tests"),
+              version: "0.0.0",
+              scripts: {
+                start: "wrangler dev",
+                deploy: "wrangler publish",
+              },
+            }),
+          },
+          "src/index.js": false,
+          "src/index.ts": true,
+        },
+      });
       expect(std.out).toMatchInlineSnapshot(`
-        "✨ Successfully created wrangler.toml
+        "✨ Created wrangler.toml
         ✨ Created package.json
-        ✨ Created tsconfig.json, installed @cloudflare/workers-types into devDependencies
+        ✨ Created tsconfig.json
         ✨ Created src/index.ts
+        ✨ Installed @cloudflare/workers-types and typescript into devDependencies
 
         To start developing your Worker, run \`npm start\`
-        To publish your Worker to the Internet, run \`npm run publish\`"
+        To publish your Worker to the Internet, run \`npm run deploy\`"
       `);
     });
 
@@ -617,41 +1127,52 @@ describe("init", () => {
           result: false,
         },
         {
-          text: "Would you like to install wrangler into your package.json?",
+          text: "Would you like to install wrangler into package.json?",
           result: false,
         },
         {
           text: "Would you like to use TypeScript?",
           result: true,
-        },
-        {
-          text: "Would you like to create a Worker at src/index.ts?",
-          result: true,
         }
       );
-      await fsp.writeFile(
-        "./package.json",
-        JSON.stringify({
-          scripts: {
-            start: "test-start",
-            publish: "test-publish",
+      mockSelect({
+        text: "Would you like to create a Worker at src/index.ts?",
+        result: "fetch",
+      });
+      writeFiles({
+        items: {
+          "package.json": {
+            contents: {
+              scripts: {
+                start: "test-start",
+                deploy: "test-publish",
+              },
+            },
           },
-        })
-      );
-      const packageJson = JSON.parse(
-        fs.readFileSync("./package.json", "utf-8")
-      );
-      await runWrangler("init");
+        },
+      });
 
-      expect(fs.existsSync("./src/index.js")).toBe(false);
-      expect(fs.existsSync("./src/index.ts")).toBe(true);
+      await runWrangler("init");
 
-      expect(packageJson.scripts.start).toBe("test-start");
-      expect(packageJson.scripts.publish).toBe("test-publish");
+      checkFiles({
+        items: {
+          "package.json": {
+            contents: {
+              scripts: {
+                start: "test-start",
+                deploy: "test-publish",
+              },
+            },
+          },
+          "src/index.js": false,
+          "src/index.ts": true,
+        },
+      });
       expect(std.out).toMatchInlineSnapshot(`
-        "✨ Successfully created wrangler.toml
-        ✨ Created tsconfig.json, installed @cloudflare/workers-types into devDependencies
+        "✨ Created wrangler.toml
+        ✨ Created tsconfig.json
         ✨ Created src/index.ts
+        ✨ Installed @cloudflare/workers-types and typescript into devDependencies
 
         To start developing your Worker, run \`npx wrangler dev\`
         To publish your Worker to the Internet, run \`npx wrangler publish\`"
@@ -665,7 +1186,7 @@ describe("init", () => {
           result: false,
         },
         {
-          text: "Would you like to install wrangler into your package.json?",
+          text: "Would you like to install wrangler into package.json?",
           result: false,
         },
         {
@@ -673,22 +1194,35 @@ describe("init", () => {
           result: true,
         }
       );
-
-      fs.writeFileSync(
-        "./package.json",
-        JSON.stringify({ name: "test", version: "1.0.0" }),
-        "utf-8"
-      );
-      fs.mkdirSync("./src", { recursive: true });
       const PLACEHOLDER = "/* placeholder text */";
-      fs.writeFileSync("./src/index.ts", PLACEHOLDER, "utf-8");
+      writeFiles({
+        items: {
+          "package.json": { contents: { name: "test", version: "1.0.0" } },
+          "src/index.ts": { contents: PLACEHOLDER },
+        },
+      });
 
       await runWrangler("init");
-      expect(fs.existsSync("./src/index.js")).toBe(false);
-      expect(fs.readFileSync("./src/index.ts", "utf-8")).toBe(PLACEHOLDER);
+
+      checkFiles({
+        items: {
+          "src/index.js": false,
+          "src/index.ts": { contents: PLACEHOLDER },
+        },
+      });
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created wrangler.toml
+        ✨ Created tsconfig.json
+        ✨ Installed @cloudflare/workers-types and typescript into devDependencies",
+          "warn": "",
+        }
+      `);
     });
 
-    it("should create a tsconfig.json and install `workers-types` if none is found and user confirms", async () => {
+    it("should not offer to create a worker in a ts project for a named worker if a file already exists at the location", async () => {
       mockConfirm(
         {
           text: "Would you like to use git to manage this Worker?",
@@ -698,67 +1232,204 @@ describe("init", () => {
           text: "No package.json found. Would you like to create one?",
           result: true,
         },
+        {
+          text: "Would you like to install wrangler into package.json?",
+          result: false,
+        },
         {
           text: "Would you like to use TypeScript?",
           result: true,
+        }
+      );
+      const PLACEHOLDER = "/* placeholder text */";
+      writeFiles({
+        items: {
+          "package.json": { contents: { name: "test", version: "1.0.0" } },
+          "my-worker/src/index.ts": { contents: PLACEHOLDER },
         },
+      });
+
+      await runWrangler("init my-worker");
+
+      checkFiles({
+        items: {
+          "my-worker/src/index.js": false,
+          "my-worker/src/index.ts": { contents: PLACEHOLDER },
+        },
+      });
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created my-worker/wrangler.toml
+        ✨ Created my-worker/package.json
+        ✨ Created my-worker/tsconfig.json
+        ✨ Installed @cloudflare/workers-types and typescript into devDependencies",
+          "warn": "",
+        }
+      `);
+    });
+
+    it("should create a tsconfig.json and install `workers-types` if none is found and user confirms", async () => {
+      mockConfirm(
         {
-          text: "Would you like to create a Worker at src/index.ts?",
+          text: "Would you like to use git to manage this Worker?",
           result: false,
+        },
+        {
+          text: "No package.json found. Would you like to create one?",
+          result: true,
+        },
+        {
+          text: "Would you like to use TypeScript?",
+          result: true,
         }
       );
+      mockSelect({
+        text: "Would you like to create a Worker at src/index.ts?",
+        result: "none",
+      });
+
       await runWrangler("init");
-      expect(fs.existsSync("./tsconfig.json")).toBe(true);
-      const { config: tsconfigJson, error: tsConfigParseError } =
-        parseConfigFileTextToJson(
-          "./tsconfig.json",
-          fs.readFileSync("./tsconfig.json", "utf-8")
-        );
-      expect(tsConfigParseError).toBeUndefined();
-      expect(tsconfigJson.compilerOptions.types).toEqual([
-        "@cloudflare/workers-types",
-      ]);
+
+      checkFiles({
+        items: {
+          "tsconfig.json": {
+            contents: {
+              config: {
+                compilerOptions: expect.objectContaining({
+                  types: ["@cloudflare/workers-types"],
+                }),
+              },
+              error: undefined,
+            },
+          },
+        },
+      });
       expect(mockPackageManager.addDevDeps).toHaveBeenCalledWith(
         "@cloudflare/workers-types",
         "typescript"
       );
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created wrangler.toml
+        ✨ Created package.json
+        ✨ Created tsconfig.json
+        ✨ Installed @cloudflare/workers-types and typescript into devDependencies",
+          "warn": "",
+        }
+      `);
     });
 
     it("should not touch an existing tsconfig.json in the same directory", async () => {
-      fs.writeFileSync(
-        "./package.json",
-        JSON.stringify({
-          name: "test",
-          version: "1.0.0",
-          devDependencies: {
-            wrangler: "0.0.0",
-            "@cloudflare/workers-types": "0.0.0",
+      mockConfirm({
+        text: "Would you like to use git to manage this Worker?",
+        result: false,
+      });
+      mockSelect({
+        text: "Would you like to create a Worker at src/index.ts?",
+        result: "fetch",
+      });
+      writeFiles({
+        items: {
+          "package.json": {
+            contents: {
+              name: "test",
+              version: "1.0.0",
+              devDependencies: {
+                wrangler: "0.0.0",
+                "@cloudflare/workers-types": "0.0.0",
+              },
+            },
           },
-        }),
-        "utf-8"
-      );
-      fs.writeFileSync(
-        "./tsconfig.json",
-        JSON.stringify({ compilerOptions: {} }),
-        "utf-8"
-      );
+          "tsconfig.json": { contents: { compilerOptions: {} } },
+        },
+      });
 
+      await runWrangler("init");
+
+      checkFiles({
+        items: {
+          "tsconfig.json": {
+            contents: { config: { compilerOptions: {} }, error: undefined },
+          },
+        },
+      });
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created wrangler.toml
+        ✨ Created src/index.ts
+
+        To start developing your Worker, run \`npx wrangler dev\`
+        To publish your Worker to the Internet, run \`npx wrangler publish\`",
+          "warn": "",
+        }
+      `);
+    });
+
+    it("should not touch an existing tsconfig.json in the ancestor of a target directory, if a name is passed", async () => {
       mockConfirm(
         {
           text: "Would you like to use git to manage this Worker?",
           result: false,
         },
         {
-          text: "Would you like to create a Worker at src/index.ts?",
+          text: "No package.json found. Would you like to create one?",
+          result: true,
+        },
+        {
+          text: "Would you like to use TypeScript?",
           result: true,
         }
       );
+      mockSelect({
+        text: "Would you like to create a Worker at path/to/worker/my-worker/src/index.ts?",
+        result: "fetch",
+      });
+      writeFiles({
+        items: {
+          "path/to/worker/package.json": {
+            contents: {
+              name: "test",
+              version: "1.0.0",
+              devDependencies: {
+                wrangler: "0.0.0",
+                "@cloudflare/workers-types": "0.0.0",
+              },
+            },
+          },
+          "path/to/worker/tsconfig.json": { contents: { compilerOptions: {} } },
+        },
+      });
 
-      await runWrangler("init");
-      const tsconfigJson = JSON.parse(
-        fs.readFileSync("./tsconfig.json", "utf-8")
-      );
-      expect(tsconfigJson.compilerOptions).toEqual({});
+      await runWrangler("init path/to/worker/my-worker");
+
+      checkFiles({
+        items: {
+          "path/to/worker/tsconfig.json": {
+            contents: { config: { compilerOptions: {}, error: undefined } },
+          },
+        },
+      });
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created path/to/worker/my-worker/wrangler.toml
+        ✨ Created path/to/worker/my-worker/package.json
+        ✨ Created path/to/worker/my-worker/tsconfig.json
+        ✨ Created path/to/worker/my-worker/src/index.ts
+        ✨ Installed @cloudflare/workers-types and typescript into devDependencies
+
+        To start developing your Worker, run \`cd path/to/worker/my-worker && npm start\`
+        To publish your Worker to the Internet, run \`npm run deploy\`",
+          "warn": "",
+        }
+      `);
     });
 
     it("should offer to install type definitions in an existing typescript project", async () => {
@@ -768,90 +1439,94 @@ describe("init", () => {
           result: false,
         },
         {
-          text: "Would you like to install wrangler into your package.json?",
+          text: "Would you like to install wrangler into package.json?",
           result: false,
         },
         {
           text: "Would you like to install the type definitions for Workers into your package.json?",
           result: true,
-        },
-        {
-          text: "Would you like to create a Worker at src/index.ts?",
-          result: false,
         }
       );
-      fs.writeFileSync(
-        "./package.json",
-        JSON.stringify({
-          name: "test",
-          version: "1.0.0",
-        }),
-        "utf-8"
-      );
-      fs.writeFileSync(
-        "./tsconfig.json",
-        JSON.stringify({ compilerOptions: {} }),
-        "utf-8"
-      );
+      mockSelect({
+        text: "Would you like to create a Worker at src/index.ts?",
+        result: "none",
+      });
+      writeFiles({
+        items: {
+          "./package.json": {
+            contents: {
+              name: "test",
+              version: "1.0.0",
+            },
+          },
+          "./tsconfig.json": { contents: { compilerOptions: {} } },
+        },
+      });
 
       await runWrangler("init");
-      const tsconfigJson = JSON.parse(
-        fs.readFileSync("./tsconfig.json", "utf-8")
-      );
-      // unchanged tsconfig
-      expect(tsconfigJson.compilerOptions).toEqual({});
+
+      checkFiles({
+        items: {
+          // unchanged tsconfig
+          "tsconfig.json": { contents: { config: { compilerOptions: {} } } },
+        },
+      });
       expect(mockPackageManager.addDevDeps).toHaveBeenCalledWith(
         "@cloudflare/workers-types"
       );
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created wrangler.toml
+        ✨ Installed @cloudflare/workers-types into devDependencies
+        🚨 Please add \\"@cloudflare/workers-types\\" to compilerOptions.types in tsconfig.json",
+          "warn": "",
+        }
+      `);
     });
 
     it("should not touch an existing tsconfig.json in an ancestor directory", async () => {
-      fs.writeFileSync(
-        "./package.json",
-        JSON.stringify({
-          name: "test",
-          version: "1.0.0",
-          devDependencies: {
-            wrangler: "0.0.0",
-            "@cloudflare/workers-types": "0.0.0",
+      mockConfirm({
+        text: "Would you like to use git to manage this Worker?",
+        result: false,
+      });
+      mockSelect({
+        text: "Would you like to create a Worker at src/index.ts?",
+        result: "fetch",
+      });
+      writeFiles({
+        items: {
+          "package.json": {
+            contents: {
+              name: "test",
+              version: "1.0.0",
+              devDependencies: {
+                wrangler: "0.0.0",
+                "@cloudflare/workers-types": "0.0.0",
+              },
+            },
           },
-        }),
-        "utf-8"
-      );
-      fs.writeFileSync(
-        "./tsconfig.json",
-        JSON.stringify({ compilerOptions: {} }),
-        "utf-8"
-      );
-
-      mockConfirm(
-        {
-          text: "Would you like to use git to manage this Worker?",
-          result: false,
+          "tsconfig.json": { contents: { compilerOptions: {} } },
         },
-        {
-          text: "Would you like to create a Worker at src/index.ts?",
-          result: true,
-        }
-      );
-
-      fs.mkdirSync("./sub-1/sub-2", { recursive: true });
-      process.chdir("./sub-1/sub-2");
+      });
+      setWorkingDirectory("./sub-1/sub-2");
 
       await runWrangler("init");
-      expect(fs.existsSync("./tsconfig.json")).toBe(false);
-      expect(fs.existsSync("../../tsconfig.json")).toBe(true);
-
-      const tsconfigJson = JSON.parse(
-        fs.readFileSync("../../tsconfig.json", "utf-8")
-      );
-      expect(tsconfigJson.compilerOptions).toEqual({});
 
+      checkFiles({
+        items: {
+          "tsconfig.json": false,
+          "../../tsconfig.json": {
+            contents: { config: { compilerOptions: {} } },
+          },
+        },
+      });
       expect(std).toMatchInlineSnapshot(`
         Object {
           "debug": "",
           "err": "",
-          "out": "✨ Successfully created wrangler.toml
+          "out": "✨ Created wrangler.toml
         ✨ Created src/index.ts
 
         To start developing your Worker, run \`npx wrangler dev\`
@@ -874,39 +1549,44 @@ describe("init", () => {
           result: true,
         },
         {
-          text: "Would you like to install wrangler into your package.json?",
+          text: "Would you like to install wrangler into package.json?",
           result: false,
         },
         {
           text: "Would you like to use TypeScript?",
           result: false,
-        },
-        {
-          text: "Would you like to create a Worker at src/index.js?",
-          result: true,
         }
       );
-      await runWrangler("init");
-
-      expect(fs.existsSync("./package.json")).toBe(true);
-      const packageJson = JSON.parse(
-        fs.readFileSync("./package.json", "utf-8")
-      );
+      mockSelect({
+        text: "Would you like to create a Worker at src/index.js?",
+        result: "fetch",
+      });
 
-      expect(fs.existsSync("./src/index.js")).toBe(true);
-      expect(fs.existsSync("./src/index.ts")).toBe(false);
+      await runWrangler("init");
 
-      expect(packageJson.scripts.start).toBe("wrangler dev");
-      expect(packageJson.scripts.publish).toBe("wrangler publish");
-      expect(packageJson.name).toContain("wrangler-tests");
-      expect(packageJson.version).toEqual("0.0.0");
+      checkFiles({
+        items: {
+          "src/index.js": true,
+          "src/index.ts": false,
+          "package.json": {
+            contents: expect.objectContaining({
+              name: expect.stringContaining("wrangler-tests"),
+              version: "0.0.0",
+              scripts: {
+                start: "wrangler dev",
+                deploy: "wrangler publish",
+              },
+            }),
+          },
+        },
+      });
       expect(std.out).toMatchInlineSnapshot(`
-        "✨ Successfully created wrangler.toml
+        "✨ Created wrangler.toml
         ✨ Created package.json
         ✨ Created src/index.js
 
         To start developing your Worker, run \`npm start\`
-        To publish your Worker to the Internet, run \`npm run publish\`"
+        To publish your Worker to the Internet, run \`npm run deploy\`"
       `);
     });
 
@@ -917,39 +1597,49 @@ describe("init", () => {
           result: false,
         },
         {
-          text: "Would you like to install wrangler into your package.json?",
+          text: "Would you like to install wrangler into package.json?",
           result: false,
         },
         {
           text: "Would you like to use TypeScript?",
           result: false,
-        },
-        {
-          text: "Would you like to create a Worker at src/index.js?",
-          result: true,
         }
       );
-      await fsp.writeFile(
-        "./package.json",
-        JSON.stringify({
-          scripts: {
-            start: "test-start",
-            publish: "test-publish",
+      mockSelect({
+        text: "Would you like to create a Worker at src/index.js?",
+        result: "fetch",
+      });
+      writeFiles({
+        items: {
+          "package.json": {
+            contents: {
+              scripts: {
+                start: "test-start",
+                deploy: "test-publish",
+              },
+            },
           },
-        })
-      );
-      const packageJson = JSON.parse(
-        fs.readFileSync("./package.json", "utf-8")
-      );
-      await runWrangler("init");
+        },
+      });
 
-      expect(fs.existsSync("./src/index.js")).toBe(true);
-      expect(fs.existsSync("./src/index.ts")).toBe(false);
+      await runWrangler("init");
 
-      expect(packageJson.scripts.start).toBe("test-start");
-      expect(packageJson.scripts.publish).toBe("test-publish");
+      checkFiles({
+        items: {
+          "src/index.js": true,
+          "src/index.ts": false,
+          "package.json": {
+            contents: expect.objectContaining({
+              scripts: {
+                start: "test-start",
+                deploy: "test-publish",
+              },
+            }),
+          },
+        },
+      });
       expect(std.out).toMatchInlineSnapshot(`
-        "✨ Successfully created wrangler.toml
+        "✨ Created wrangler.toml
         ✨ Created src/index.js
 
         To start developing your Worker, run \`npx wrangler dev\`
@@ -964,7 +1654,7 @@ describe("init", () => {
           result: false,
         },
         {
-          text: "Would you like to install wrangler into your package.json?",
+          text: "Would you like to install wrangler into package.json?",
           result: false,
         },
         {
@@ -972,19 +1662,73 @@ describe("init", () => {
           result: false,
         }
       );
+      const PLACEHOLDER = "/* placeholder text */";
+      writeFiles({
+        items: {
+          "package.json": { contents: { name: "test", version: "1.0.0" } },
+          "src/index.js": { contents: PLACEHOLDER },
+        },
+      });
+
+      await runWrangler("init");
+
+      checkFiles({
+        items: {
+          "src/index.js": { contents: PLACEHOLDER },
+          "src/index.ts": false,
+        },
+      });
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created wrangler.toml",
+          "warn": "",
+        }
+      `);
+    });
 
-      fs.writeFileSync(
-        "./package.json",
-        JSON.stringify({ name: "test", version: "1.0.0" }),
-        "utf-8"
+    it("should not offer to create a worker in a non-ts named worker project if a file already exists at the location", async () => {
+      mockConfirm(
+        {
+          text: "Would you like to use git to manage this Worker?",
+          result: false,
+        },
+        {
+          text: "Would you like to install wrangler into my-worker/package.json?",
+          result: false,
+        },
+        {
+          text: "Would you like to use TypeScript?",
+          result: false,
+        }
       );
-      fs.mkdirSync("./src", { recursive: true });
       const PLACEHOLDER = "/* placeholder text */";
-      fs.writeFileSync("./src/index.js", PLACEHOLDER, "utf-8");
+      writeFiles({
+        items: {
+          "my-worker/package.json": {
+            contents: { name: "test", version: "1.0.0" },
+          },
+          "my-worker/src/index.js": { contents: PLACEHOLDER },
+        },
+      });
 
-      await runWrangler("init");
-      expect(fs.readFileSync("./src/index.js", "utf-8")).toBe(PLACEHOLDER);
-      expect(fs.existsSync("./src/index.ts")).toBe(false);
+      await runWrangler("init my-worker");
+
+      checkFiles({
+        items: {
+          "my-worker/src/index.js": { contents: PLACEHOLDER },
+          "my-worker/src/index.ts": false,
+        },
+      });
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created my-worker/wrangler.toml",
+          "warn": "",
+        }
+      `);
     });
   });
 
@@ -992,51 +1736,257 @@ describe("init", () => {
     it("should create a worker with a given name", async () => {
       await runWrangler("init my-worker -y");
 
-      const parsed = TOML.parse(
-        await fsp.readFile("./my-worker/wrangler.toml", "utf-8")
-      );
-
-      expect(typeof parsed.compatibility_date).toBe("string");
-      expect(parsed.name).toBe("my-worker");
+      checkFiles({
+        items: {
+          "my-worker/wrangler.toml": wranglerToml({
+            ...MINIMAL_WRANGLER_TOML,
+            name: "my-worker",
+          }),
+        },
+      });
     });
 
     it('should create a worker with the name of the current directory if "name" is .', async () => {
       await runWrangler("init . -y");
 
-      const parsed = TOML.parse(await fsp.readFile("wrangler.toml", "utf-8"));
+      const workerName = path.basename(process.cwd()).toLowerCase();
+      checkFiles({
+        items: {
+          "wrangler.toml": wranglerToml({
+            ...MINIMAL_WRANGLER_TOML,
+            name: workerName,
+          }),
+        },
+      });
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created wrangler.toml
+        ✨ Initialized git repository
+        ✨ Created package.json
+        ✨ Created tsconfig.json
+        ✨ Created src/index.ts
+        ✨ Installed @cloudflare/workers-types and typescript into devDependencies
 
-      expect(typeof parsed.compatibility_date).toBe("string");
-      expect(parsed.name).toBe(path.basename(process.cwd()).toLowerCase());
-      expect(fs.existsSync("./my-worker/package.json")).toBe(false);
-      expect(fs.existsSync("./my-worker/tsconfig.json")).toBe(false);
+        To start developing your Worker, run \`npm start\`
+        To publish your Worker to the Internet, run \`npm run deploy\`",
+          "warn": "",
+        }
+      `);
     });
 
     it('should create a worker in a nested directory if "name" is path/to/worker', async () => {
       await runWrangler("init path/to/worker -y");
 
-      const parsed = TOML.parse(
-        await fsp.readFile("path/to/worker/wrangler.toml", "utf-8")
-      );
-
-      expect(typeof parsed.compatibility_date).toBe("string");
-      expect(parsed.name).toBe("worker");
-      expect(fs.existsSync("./my-worker/package.json")).toBe(false);
-      expect(fs.existsSync("./my-worker/tsconfig.json")).toBe(false);
+      checkFiles({
+        items: {
+          "path/to/worker/wrangler.toml": wranglerToml({
+            ...MINIMAL_WRANGLER_TOML,
+            name: "worker",
+          }),
+        },
+      });
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created path/to/worker/wrangler.toml
+        ✨ Initialized git repository at path/to/worker
+        ✨ Created path/to/worker/package.json
+        ✨ Created path/to/worker/tsconfig.json
+        ✨ Created path/to/worker/src/index.ts
+        ✨ Installed @cloudflare/workers-types and typescript into devDependencies
+
+        To start developing your Worker, run \`cd path/to/worker && npm start\`
+        To publish your Worker to the Internet, run \`npm run deploy\`",
+          "warn": "",
+        }
+      `);
     });
 
     it("should normalize characters that aren't lowercase alphanumeric, underscores, or dashes", async () => {
       await runWrangler("init WEIRD_w0rkr_N4m3.js.tsx.tar.gz -y");
-      const parsed = TOML.parse(
-        await fsp.readFile(
-          "WEIRD_w0rkr_N4m3.js.tsx.tar.gz/wrangler.toml",
-          "utf-8"
-        )
+
+      checkFiles({
+        items: {
+          "WEIRD_w0rkr_N4m3.js.tsx.tar.gz/wrangler.toml": wranglerToml({
+            ...MINIMAL_WRANGLER_TOML,
+            name: "weird_w0rkr_n4m3-js-tsx-tar-gz",
+          }),
+        },
+      });
+      expect(std).toMatchInlineSnapshot(`
+        Object {
+          "debug": "",
+          "err": "",
+          "out": "✨ Created WEIRD_w0rkr_N4m3.js.tsx.tar.gz/wrangler.toml
+        ✨ Initialized git repository at WEIRD_w0rkr_N4m3.js.tsx.tar.gz
+        ✨ Created WEIRD_w0rkr_N4m3.js.tsx.tar.gz/package.json
+        ✨ Created WEIRD_w0rkr_N4m3.js.tsx.tar.gz/tsconfig.json
+        ✨ Created WEIRD_w0rkr_N4m3.js.tsx.tar.gz/src/index.ts
+        ✨ Installed @cloudflare/workers-types and typescript into devDependencies
+
+        To start developing your Worker, run \`cd WEIRD_w0rkr_N4m3.js.tsx.tar.gz && npm start\`
+        To publish your Worker to the Internet, run \`npm run deploy\`",
+          "warn": "",
+        }
+      `);
+    });
+
+    it("should ignore ancestor files (such as wrangler.toml, package.json and tsconfig.json) if a name/path is given", async () => {
+      mockConfirm(
+        {
+          text: "Would you like to use git to manage this Worker?",
+          result: false,
+        },
+        {
+          text: "Would you like to use TypeScript?",
+          result: true,
+        },
+        {
+          text: "No package.json found. Would you like to create one?",
+          result: true,
+        },
+        {
+          text: "Would you like to install the type definitions for Workers into your package.json?",
+          result: true,
+        }
       );
+      mockSelect({
+        text: "Would you like to create a Worker at sub/folder/worker/src/index.ts?",
+        result: "fetch",
+      });
+      writeFiles({
+        items: {
+          "package.json": { contents: { name: "top-level" } },
+          "tsconfig.json": { contents: { compilerOptions: {} } },
+          "wrangler.toml": wranglerToml({
+            name: "top-level",
+            compatibility_date: "some-date",
+          }),
+        },
+      });
+
+      await runWrangler("init sub/folder/worker");
 
-      expect(typeof parsed.compatibility_date).toBe("string");
-      expect(parsed.name).toBe("weird_w0rkr_n4m3-js-tsx-tar-gz");
-      expect(fs.existsSync("./my-worker/package.json")).toBe(false);
-      expect(fs.existsSync("./my-worker/tsconfig.json")).toBe(false);
+      // Ancestor files are untouched.
+      checkFiles({
+        items: {
+          "package.json": { contents: { name: "top-level" } },
+          "tsconfig.json": {
+            contents: { config: { compilerOptions: {} }, error: undefined },
+          },
+          "wrangler.toml": wranglerToml({
+            name: "top-level",
+            compatibility_date: "some-date",
+          }),
+        },
+      });
+      // New initialized Worker has its own files.
+      checkFiles({
+        items: {
+          "sub/folder/worker/package.json": {
+            contents: expect.objectContaining({
+              name: "worker",
+            }),
+          },
+          "sub/folder/worker/tsconfig.json": true,
+          "sub/folder/worker/wrangler.toml": wranglerToml({
+            ...MINIMAL_WRANGLER_TOML,
+            name: "worker",
+          }),
+        },
+      });
     });
   });
 });
+
+/**
+ * Change the current working directory, ensuring that this exists.
+ */
+function setWorkingDirectory(directory: string) {
+  fs.mkdirSync(directory, { recursive: true });
+  process.chdir(directory);
+}
+
+/**
+ * Write the given folder/files to disk at the given `cwd`.
+ */
+function writeFiles(folder: TestFolder, cwd = process.cwd()) {
+  for (const name in folder.items) {
+    const item = folder.items[name];
+    const itemPath = path.resolve(cwd, name);
+    if (typeof item !== "boolean") {
+      if ("contents" in item) {
+        fs.mkdirSync(path.dirname(itemPath), { recursive: true });
+        fs.writeFileSync(itemPath, stringify(name, item.contents));
+      } else {
+        fs.mkdirSync(itemPath, { recursive: true });
+        writeFiles(item, itemPath);
+      }
+    } else {
+      throw new Error("Cannot write boolean flags to disk: " + itemPath);
+    }
+  }
+}
+
+/**
+ * Check that the given test folders/files match what is in on disk.
+ */
+function checkFiles(folder: TestFolder, cwd = process.cwd()) {
+  for (const name in folder.items) {
+    const item = folder.items[name];
+    const itemPath = path.resolve(cwd, name);
+    if (typeof item === "boolean") {
+      if (fs.existsSync(itemPath) !== item) {
+        throw new Error(`Expected ${itemPath} ${item ? "" : "not "}to exist.`);
+      }
+    } else if ("contents" in item) {
+      const actualContents = parse(name, fs.readFileSync(itemPath, "utf-8"));
+      expect(actualContents).toEqual(item.contents);
+    } else if ("items" in item) {
+      checkFiles(item, itemPath);
+    } else {
+      throw new Error("Unexpected TestFile object.");
+    }
+  }
+}
+
+function stringify(name: string, value: unknown) {
+  if (name.endsWith(".toml")) {
+    return TOML.stringify(value as TOML.JsonMap);
+  }
+  if (name.endsWith(".json")) {
+    return JSON.stringify(value);
+  }
+  return `${value}`;
+}
+
+function parse(name: string, value: string): unknown {
+  if (name.endsWith(".toml")) {
+    return TOML.parse(value);
+  }
+  if (name.endsWith("tsconfig.json")) {
+    return parseConfigFileTextToJson(name, value);
+  }
+  if (name.endsWith(".json")) {
+    return JSON.parse(value);
+  }
+  return value;
+}
+
+function wranglerToml(options: TOML.JsonMap = {}): TestFile {
+  return {
+    contents: options,
+  };
+}
+
+interface TestFile {
+  contents: unknown;
+}
+interface TestFolder {
+  items: {
+    [id: string]: TestFile | TestFolder | boolean;
+  };
+}