test: finish unit testing migrate and migrateWithOptions (#1632)

## PR Checklist

- [x] Addresses an existing open issue: fixes #872
- [x] That issue was marked as [`status: accepting
prs`](https://github.com/JoshuaKGoldberg/create-typescript-app/issues?q=is%3Aopen+is%3Aissue+label%3A%22status%3A+accepting+prs%22)
- [x] Steps in
[CONTRIBUTING.md](https://github.com/JoshuaKGoldberg/create-typescript-app/blob/main/.github/CONTRIBUTING.md)
were taken

## Overview

As the issue suggested, this was a fair bit of setup. But I feel better
now.

💖

Author: JoshuaKGoldberg

src/migrate/index.test.ts

@@ -1,15 +1,23 @@
 import { describe, expect, it, vi } from "vitest";
 
 import { StatusCodes } from "../shared/codes.js";
+import { RunOrRestoreOptions } from "../shared/runOrRestore.js";
 import { migrate } from "./index.js";
 
 const mockOutro = vi.fn();
 
-vi.mock("@clack/prompts", () => ({
+vi.mock("../shared/cli/outro.js", () => ({
 	get outro() {
 		return mockOutro;
 	},
-	spinner: vi.fn(),
+}));
+
+const mockEnsureGitRepository = vi.fn();
+
+vi.mock("../shared/ensureGitRepository.js", () => ({
+	get ensureGitRepository() {
+		return mockEnsureGitRepository;
+	},
 }));
 
 const mockReadOptions = vi.fn();
@@ -20,11 +28,18 @@ vi.mock("../shared/options/readOptions.js", () => ({
 	},
 }));
 
-const mockMigrateAndEnterRepository = vi.fn();
+vi.mock("../shared/runOrRestore.js", () => ({
+	async runOrRestore({ run }: RunOrRestoreOptions) {
+		await run();
+		return StatusCodes.Success;
+	},
+}));
+
+const mockMigrateWithOptions = vi.fn();
 
-vi.mock("./migrateAndEnterRepository.js", () => ({
-	get migrateAndEnterRepository() {
-		return mockMigrateAndEnterRepository;
+vi.mock("./migrateWithOptions.js", () => ({
+	get migrateWithOptions() {
+		return mockMigrateWithOptions;
 	},
 }));
 
@@ -46,4 +61,47 @@ describe("migrate", () => {
 			options: optionsBase,
 		});
 	});
+
+	it("runs migrateWithOptions when readOptions returns inputs", async () => {
+		mockReadOptions.mockResolvedValue({
+			cancelled: false,
+			options: optionsBase,
+		});
+
+		const result = await migrate([]);
+
+		expect(result).toEqual({
+			code: StatusCodes.Success,
+			options: optionsBase,
+		});
+		expect(mockEnsureGitRepository).toHaveBeenCalled();
+		expect(mockOutro.mock.calls).toMatchInlineSnapshot(`
+      [
+        [
+          [
+            {
+              "label": "You may consider committing these changes:",
+              "lines": [
+                "git add -A",
+                "git commit -m "migrated repo to create-typescript-app ✨",
+                "git push",
+              ],
+              "variant": "code",
+            },
+            {
+              "label": "Be sure to:",
+              "lines": [
+                "- enable the GitHub apps: 
+         - Codecov (https://github.com/apps/codecov)
+         - Renovate (https://github.com/apps/renovate)",
+                "- populate the secrets: 
+         - ACCESS_TOKEN (a GitHub PAT with repo and workflow permissions)
+         - NPM_TOKEN (an npm access token with automation permissions)",
+              ],
+            },
+          ],
+        ],
+      ]
+    `);
+	});
 });

src/migrate/migrateWithOptions.test.ts

@@ -0,0 +1,201 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { GitHub } from "../shared/options/getGitHub.js";
+import { Options } from "../shared/types.js";
+import { migrateWithOptions } from "./migrateWithOptions.js";
+
+vi.mock("../shared/cli/spinners.js", () => ({
+	async withSpinner(_label: string, task: () => Promise<void>) {
+		await task();
+	},
+	withSpinners: vi.fn(),
+}));
+
+const mockDetectExistingContributors = vi.fn();
+
+vi.mock("../steps/detectExistingContributors.js", () => ({
+	get detectExistingContributors() {
+		return mockDetectExistingContributors;
+	},
+}));
+
+const mockFinalizeDependencies = vi.fn();
+
+vi.mock("../steps/finalizeDependencies.js", () => ({
+	get finalizeDependencies() {
+		return mockFinalizeDependencies;
+	},
+}));
+
+const mockInitializeGitHubRepository = vi.fn();
+
+vi.mock("../steps/initializeGitHubRepository/index.js", () => ({
+	get initializeGitHubRepository() {
+		return mockInitializeGitHubRepository;
+	},
+}));
+
+const mockPopulateCSpellDictionary = vi.fn();
+
+vi.mock("../steps/populateCSpellDictionary.js", () => ({
+	get populateCSpellDictionary() {
+		return mockPopulateCSpellDictionary;
+	},
+}));
+
+vi.mock("../steps/runCleanup.js", () => ({
+	runCleanup: vi.fn(),
+}));
+
+vi.mock("../shared/cli/spinners.js", () => ({
+	async withSpinner(_label: string, task: () => Promise<void>) {
+		await task();
+	},
+	withSpinners: vi.fn(),
+}));
+
+const mockGitHubAndOptions = vi.fn();
+
+vi.mock("../shared/options/readOptions.js", () => ({
+	get GitHubAndOptions() {
+		return mockGitHubAndOptions;
+	},
+}));
+
+const optionsBase = {} as Options;
+
+describe("migrateWithOptions", () => {
+	it("runs initializeGitHubRepository when github is truthy", async () => {
+		const github = {
+			octokit: {},
+		} as GitHub;
+
+		await migrateWithOptions({
+			github,
+			options: optionsBase,
+		});
+
+		expect(mockInitializeGitHubRepository).toHaveBeenCalledWith(
+			github.octokit,
+			optionsBase,
+		);
+	});
+
+	it("does not run initializeGitHubRepository when github is falsy", async () => {
+		const options = {
+			...optionsBase,
+			excludeAllContributors: true,
+		};
+
+		await migrateWithOptions({
+			github: undefined,
+			options,
+		});
+
+		expect(mockInitializeGitHubRepository).not.toHaveBeenCalled();
+	});
+
+	it("does not run detectExistingContributors when excludeAllContributors is true", async () => {
+		const options = {
+			...optionsBase,
+			excludeAllContributors: true,
+			skipAllContributorsApi: false,
+		};
+
+		await migrateWithOptions({
+			github: undefined,
+			options,
+		});
+
+		expect(mockDetectExistingContributors).not.toHaveBeenCalled();
+	});
+
+	it("does not run detectExistingContributors when skipAllContributorsApi is true", async () => {
+		const options = {
+			...optionsBase,
+			excludeAllContributors: false,
+			skipAllContributorsApi: true,
+		};
+
+		await migrateWithOptions({
+			github: undefined,
+			options,
+		});
+
+		expect(mockDetectExistingContributors).not.toHaveBeenCalled();
+	});
+
+	it("runs detectExistingContributors when excludeAllContributors and skipAllContributorsApi are false", async () => {
+		const options = {
+			...optionsBase,
+			excludeAllContributors: false,
+			skipAllContributorsApi: false,
+		};
+
+		await migrateWithOptions({
+			github: undefined,
+			options,
+		});
+
+		expect(mockDetectExistingContributors).toHaveBeenCalledWith(
+			undefined,
+			options,
+		);
+	});
+
+	it("runs finalizeDependencies when skipInstall is false", async () => {
+		const options = {
+			...optionsBase,
+			skipInstall: false,
+		};
+
+		await migrateWithOptions({
+			github: undefined,
+			options,
+		});
+
+		expect(mockFinalizeDependencies).toHaveBeenCalledWith(options);
+	});
+
+	it("does not run finalizeDependencies when skipInstall is true", async () => {
+		const options = {
+			...optionsBase,
+			skipInstall: true,
+		};
+
+		await migrateWithOptions({
+			github: undefined,
+			options,
+		});
+
+		expect(mockFinalizeDependencies).not.toHaveBeenCalled();
+	});
+
+	it("runs populateCSpellDictionary when excludeLintSpelling is false", async () => {
+		const options = {
+			...optionsBase,
+			excludeLintSpelling: false,
+		};
+
+		await migrateWithOptions({
+			github: undefined,
+			options,
+		});
+
+		expect(mockPopulateCSpellDictionary).toHaveBeenCalled();
+	});
+
+	it("does not run populateCSpellDictionary when excludeLintSpelling is true", async () => {
+		const options = {
+			...optionsBase,
+			excludeLintSpelling: true,
+		};
+
+		await migrateWithOptions({
+			github: undefined,
+			options,
+		});
+
+		expect(mockPopulateCSpellDictionary).not.toHaveBeenCalled();
+	});
+});