@shopify/cli-hydrogen 7.1.2 → 8.0.0

package/dist/generator-templates/starter/remix.config.js

@@ -1,24 +0,0 @@
-/** @type {import('@remix-run/dev').AppConfig} */
-module.exports = {
-  appDirectory: 'app',
-  ignoredRouteFiles: ['**/.*'],
-  watchPaths: ['./public', './.env'],
-  server: './server.ts',
-  /**
-   * The following settings are required to deploy Hydrogen apps to Oxygen:
-   */
-  publicPath: (process.env.HYDROGEN_ASSET_BASE_URL ?? '/') + 'build/',
-  assetsBuildDirectory: 'dist/client/build',
-  serverBuildPath: 'dist/worker/index.js',
-  serverMainFields: ['browser', 'module', 'main'],
-  serverConditions: ['worker', process.env.NODE_ENV],
-  serverDependenciesToBundle: 'all',
-  serverModuleFormat: 'esm',
-  serverPlatform: 'neutral',
-  serverMinify: process.env.NODE_ENV === 'production',
-  future: {
-    v3_fetcherPersist: true,
-    v3_relativeSplatpath: true,
-    v3_throwAbortReason: true,
-  },
-};

package/dist/lib/auth.test.js

@@ -1,157 +0,0 @@
-import { vi, describe, beforeEach, afterEach, it, expect } from 'vitest';
-import { ensureAuthenticatedAdmin, ensureAuthenticatedBusinessPlatform } from '@shopify/cli-kit/node/session';
-import { renderSelectPrompt } from '@shopify/cli-kit/node/ui';
-import { AbortError } from '@shopify/cli-kit/node/error';
-import { login } from './auth.js';
-import { getUserAccount } from './graphql/business-platform/user-account.js';
-import { setUserAccount, getConfig } from './shopify-config.js';
-
-vi.mock("@shopify/cli-kit/node/session");
-vi.mock("@shopify/cli-kit/node/ui");
-vi.mock("./graphql/business-platform/user-account.js");
-vi.mock("./shopify-config.js");
-describe("auth", () => {
-  const EMAIL = "email";
-  const SHOP = "my-shop";
-  const SHOP_DOMAIN = SHOP + ".myshopify.com";
-  const SHOP_NAME = "My Shop";
-  const TOKEN = "abc123";
-  const ROOT = "path/to/project";
-  const SHOPIFY_CONFIG = {
-    shop: SHOP_DOMAIN,
-    shopName: SHOP_NAME,
-    email: EMAIL
-  };
-  const EXPECTED_LOGIN_RESULT = {
-    config: { shop: SHOP_DOMAIN, shopName: SHOP_NAME, email: EMAIL },
-    session: {
-      token: TOKEN,
-      storeFqdn: SHOP_DOMAIN
-    }
-  };
-  beforeEach(() => {
-    vi.mocked(setUserAccount).mockImplementation(
-      (root, account) => Promise.resolve(account)
-    );
-    vi.mocked(ensureAuthenticatedAdmin).mockImplementation(
-      (shop) => Promise.resolve({ token: TOKEN, storeFqdn: shop })
-    );
-    vi.mocked(ensureAuthenticatedBusinessPlatform).mockResolvedValue("bp123");
-    vi.mocked(getUserAccount).mockResolvedValue({
-      email: "email",
-      activeShops: [{ name: SHOP_NAME, fqdn: SHOP_DOMAIN }]
-    });
-    vi.mocked(getConfig).mockResolvedValue({});
-    vi.mocked(renderSelectPrompt).mockResolvedValue({
-      fqdn: SHOP_DOMAIN,
-      name: SHOP_NAME
-    });
-  });
-  afterEach(() => {
-    vi.resetAllMocks();
-  });
-  describe("login", () => {
-    it("throws an error when it fails to authenticate", async () => {
-      vi.mocked(ensureAuthenticatedBusinessPlatform).mockRejectedValueOnce({});
-      await expect(login(ROOT)).rejects.toThrow(AbortError);
-      vi.mocked(ensureAuthenticatedAdmin).mockRejectedValueOnce({});
-      await expect(login(ROOT, SHOP)).rejects.toThrow(AbortError);
-    });
-    it("reads shop from local config", async () => {
-      vi.mocked(getConfig).mockResolvedValue(SHOPIFY_CONFIG);
-      const result = await login(ROOT);
-      expect(ensureAuthenticatedBusinessPlatform).not.toHaveBeenCalled();
-      expect(ensureAuthenticatedAdmin).toHaveBeenCalledWith(SHOP_DOMAIN);
-      expect(setUserAccount).toHaveBeenCalledWith(
-        ROOT,
-        expect.objectContaining({ shop: SHOP_DOMAIN })
-      );
-      expect(result).toStrictEqual(EXPECTED_LOGIN_RESULT);
-    });
-    it("uses the shop flag argument when passed", async () => {
-      const ANOTHER_SHOP = "another-shop";
-      const ANOTHER_SHOP_DOMAIN = "another-shop.myshopify.com";
-      const ANOTHER_SHOP_NAME = "ANOTHER SHOP";
-      vi.mocked(getConfig).mockResolvedValue(SHOPIFY_CONFIG);
-      vi.mocked(renderSelectPrompt).mockResolvedValue({
-        fqdn: ANOTHER_SHOP_DOMAIN,
-        name: ANOTHER_SHOP_NAME
-      });
-      const result = await login(ROOT, ANOTHER_SHOP);
-      expect(ensureAuthenticatedAdmin).toHaveBeenCalledWith(
-        ANOTHER_SHOP_DOMAIN
-      );
-      expect(setUserAccount).toHaveBeenCalledWith(
-        ROOT,
-        expect.objectContaining({ shop: ANOTHER_SHOP_DOMAIN })
-      );
-      expect(result).toStrictEqual({
-        config: {
-          shop: ANOTHER_SHOP_DOMAIN,
-          shopName: ANOTHER_SHOP_NAME,
-          email: EMAIL
-        },
-        session: {
-          storeFqdn: ANOTHER_SHOP_DOMAIN,
-          token: TOKEN
-        }
-      });
-    });
-    it("writes shop to local config and returns it with the admin session", async () => {
-      const result = await login(ROOT, SHOP);
-      expect(ensureAuthenticatedAdmin).toHaveBeenCalledWith(SHOP_DOMAIN);
-      expect(setUserAccount).toHaveBeenCalledWith(
-        ROOT,
-        expect.objectContaining({ shop: SHOP_DOMAIN })
-      );
-      expect(result).toStrictEqual(EXPECTED_LOGIN_RESULT);
-    });
-    it("prompts for shop is not found in arguments and local config", async () => {
-      const result = await login(ROOT);
-      expect(ensureAuthenticatedBusinessPlatform).toHaveBeenCalled();
-      expect(ensureAuthenticatedAdmin).toHaveBeenCalledWith(SHOP_DOMAIN);
-      expect(setUserAccount).toHaveBeenCalledWith(
-        ROOT,
-        expect.objectContaining({ shop: SHOP_DOMAIN })
-      );
-      expect(renderSelectPrompt).toHaveBeenCalledWith({
-        message: expect.any(String),
-        choices: [
-          {
-            label: expect.stringContaining(SHOP_DOMAIN),
-            value: { fqdn: SHOP_DOMAIN, name: SHOP_NAME }
-          }
-        ]
-      });
-      expect(result).toStrictEqual(EXPECTED_LOGIN_RESULT);
-    });
-    it("ignores local config and forces prompt when indicated", async () => {
-      vi.mocked(getConfig).mockResolvedValue(SHOPIFY_CONFIG);
-      const result = await login(ROOT, true);
-      expect(ensureAuthenticatedBusinessPlatform).toHaveBeenCalled();
-      expect(ensureAuthenticatedAdmin).toHaveBeenCalledWith(SHOP_DOMAIN);
-      expect(setUserAccount).toHaveBeenCalledWith(
-        ROOT,
-        expect.objectContaining({ shop: SHOP_DOMAIN })
-      );
-      expect(renderSelectPrompt).toHaveBeenCalledWith({
-        message: expect.any(String),
-        choices: [
-          {
-            label: expect.stringContaining(SHOP_DOMAIN),
-            value: { fqdn: SHOP_DOMAIN, name: SHOP_NAME }
-          }
-        ]
-      });
-      expect(result).toStrictEqual(EXPECTED_LOGIN_RESULT);
-    });
-    it("skips config steps when root argument is not passed", async () => {
-      const result = await login();
-      expect(ensureAuthenticatedBusinessPlatform).toHaveBeenCalled();
-      expect(ensureAuthenticatedAdmin).toHaveBeenCalledWith(SHOP_DOMAIN);
-      expect(getConfig).not.toHaveBeenCalled();
-      expect(setUserAccount).not.toHaveBeenCalled();
-      expect(result).toStrictEqual(EXPECTED_LOGIN_RESULT);
-    });
-  });
-});

package/dist/lib/check-lockfile.test.js

@@ -1,81 +0,0 @@
-import { checkLockfileStatus } from './check-lockfile.js';
-import { describe, vi, beforeEach, afterEach, it, expect } from 'vitest';
-import { inTemporaryDirectory, writeFile } from '@shopify/cli-kit/node/fs';
-import { joinPath } from '@shopify/cli-kit/node/path';
-import { checkIfIgnoredInGitRepository } from '@shopify/cli-kit/node/git';
-import { mockAndCaptureOutput } from '@shopify/cli-kit/node/testing/output';
-
-describe("checkLockfileStatus()", () => {
-  const checkIgnoreMock = vi.fn();
-  const outputMock = mockAndCaptureOutput();
-  beforeEach(() => {
-    vi.mock("@shopify/cli-kit/node/git");
-    vi.mocked(checkIfIgnoredInGitRepository).mockImplementation(
-      checkIgnoreMock
-    );
-    vi.mocked(checkIgnoreMock).mockResolvedValue([]);
-  });
-  afterEach(() => {
-    vi.restoreAllMocks();
-    outputMock.clear();
-  });
-  describe("when a lockfile is present", () => {
-    it("does not call displayLockfileWarning", async () => {
-      await inTemporaryDirectory(async (tmpDir) => {
-        await writeFile(joinPath(tmpDir, "package-lock.json"), "");
-        await checkLockfileStatus(tmpDir);
-        expect(outputMock.warn()).toBe("");
-      });
-    });
-    describe("and it is being ignored by Git", () => {
-      beforeEach(() => {
-        vi.mocked(checkIgnoreMock).mockResolvedValue(["package-lock.json"]);
-      });
-      it("renders a warning", async () => {
-        await inTemporaryDirectory(async (tmpDir) => {
-          await writeFile(joinPath(tmpDir, "package-lock.json"), "");
-          await checkLockfileStatus(tmpDir);
-          expect(outputMock.warn()).toMatch(
-            / warning .+ Lockfile ignored by Git .+/is
-          );
-        });
-      });
-    });
-  });
-  describe("when there are multiple lockfiles", () => {
-    it("renders a warning", async () => {
-      await inTemporaryDirectory(async (tmpDir) => {
-        await writeFile(joinPath(tmpDir, "package-lock.json"), "");
-        await writeFile(joinPath(tmpDir, "pnpm-lock.yaml"), "");
-        await checkLockfileStatus(tmpDir);
-        expect(outputMock.warn()).toMatch(
-          / warning .+ Multiple lockfiles found .+/is
-        );
-      });
-    });
-    it("throws when shouldExit is true", async () => {
-      await inTemporaryDirectory(async (tmpDir) => {
-        await writeFile(joinPath(tmpDir, "package-lock.json"), "");
-        await writeFile(joinPath(tmpDir, "pnpm-lock.yaml"), "");
-        await expect(checkLockfileStatus(tmpDir, true)).rejects.toThrow(
-          /Multiple lockfiles found/is
-        );
-      });
-    });
-  });
-  describe("when a lockfile is missing", () => {
-    it("renders a warning", async () => {
-      await inTemporaryDirectory(async (tmpDir) => {
-        await checkLockfileStatus(tmpDir);
-        expect(outputMock.warn()).toMatch(/ warning .+ No lockfile found .+/is);
-      });
-    });
-    it("throws when shouldExit is true", async () => {
-      await inTemporaryDirectory(async (tmpDir) => {
-        await expect(checkLockfileStatus(tmpDir, true)).rejects.toThrow(
-          /No lockfile found/is
-        );
-      });
-    });
-  });
-});

package/dist/lib/check-version.test.js

@@ -1,86 +0,0 @@
-import { checkHydrogenVersion } from './check-version.js';
-import { vi, describe, afterEach, it, expect, beforeEach } from 'vitest';
-import { mockAndCaptureOutput } from '@shopify/cli-kit/node/testing/output';
-import { checkForNewVersion } from '@shopify/cli-kit/node/node-package-manager';
-
-vi.mock("@shopify/cli-kit/node/node-package-manager", () => {
-  return {
-    checkForNewVersion: vi.fn()
-  };
-});
-const requireMock = vi.fn();
-vi.mock("node:module", async () => {
-  const { createRequire } = await vi.importActual(
-    "node:module"
-  );
-  return {
-    createRequire: (url) => {
-      const actualRequire = createRequire(url);
-      requireMock.mockImplementation((mod) => actualRequire(mod));
-      const require2 = requireMock;
-      require2.resolve = actualRequire.resolve.bind(actualRequire);
-      return require2;
-    }
-  };
-});
-describe("checkHydrogenVersion()", () => {
-  const outputMock = mockAndCaptureOutput();
-  afterEach(() => {
-    vi.restoreAllMocks();
-    outputMock.clear();
-  });
-  describe("when a current version is available", () => {
-    it("calls checkForNewVersion", async () => {
-      await checkHydrogenVersion("dir");
-      expect(checkForNewVersion).toHaveBeenCalledWith(
-        "@shopify/hydrogen",
-        // Calver
-        expect.stringMatching(/20\d{2}\.\d{1,2}\.\d{1,3}/)
-      );
-    });
-    describe("and it is up to date", () => {
-      beforeEach(() => {
-        vi.mocked(checkForNewVersion).mockResolvedValue(void 0);
-      });
-      it("returns undefined", async () => {
-        expect(await checkHydrogenVersion("dir")).toBe(void 0);
-      });
-    });
-    describe("and it is using @next", () => {
-      it("returns undefined", async () => {
-        vi.mocked(checkForNewVersion).mockResolvedValue("2023.1.5");
-        vi.mocked(requireMock).mockReturnValueOnce({
-          version: "0.0.0-next-a188915-20230713115118"
-        });
-        expect(await checkHydrogenVersion("dir")).toBe(void 0);
-      });
-    });
-    describe("and a new version is available", () => {
-      beforeEach(() => {
-        vi.mocked(checkForNewVersion).mockResolvedValue("2023.1.5");
-      });
-      it("returns a function", async () => {
-        expect(await checkHydrogenVersion("dir")).toBeInstanceOf(Function);
-      });
-      it("outputs a message to the user with the new version", async () => {
-        const showUpgrade = await checkHydrogenVersion("dir");
-        const { currentVersion, newVersion } = showUpgrade();
-        expect(outputMock.info()).toMatch(
-          new RegExp(
-            ` info .+ Upgrade available .+ Version ${newVersion.replaceAll(
-              ".",
-              "\\."
-            )}.+ running v${currentVersion.replaceAll(".", "\\.")}`,
-            "is"
-          )
-        );
-      });
-    });
-  });
-  describe("when no current version can be found", () => {
-    it("returns undefined and does not call checkForNewVersion", async () => {
-      expect(await checkHydrogenVersion("/fake-absolute-dir")).toBe(void 0);
-      expect(checkForNewVersion).not.toHaveBeenCalled();
-    });
-  });
-});

package/dist/lib/environment-variables.test.js

@@ -1,149 +0,0 @@
-import { vi, describe, beforeEach, afterEach, it, expect } from 'vitest';
-import { inTemporaryDirectory, writeFile } from '@shopify/cli-kit/node/fs';
-import { joinPath } from '@shopify/cli-kit/node/path';
-import { mockAndCaptureOutput } from '@shopify/cli-kit/node/testing/output';
-import { getAllEnvironmentVariables } from './environment-variables.js';
-import { getStorefrontEnvVariables } from './graphql/admin/pull-variables.js';
-import { login } from './auth.js';
-
-vi.mock("./auth.js");
-vi.mock("./graphql/admin/pull-variables.js");
-describe("getAllEnvironmentVariables()", () => {
-  const ADMIN_SESSION = {
-    token: "abc123",
-    storeFqdn: "my-shop"
-  };
-  const SHOPIFY_CONFIG = {
-    shop: "my-shop",
-    shopName: "My Shop",
-    email: "email",
-    storefront: {
-      id: "gid://shopify/HydrogenStorefront/1",
-      title: "Hydrogen"
-    }
-  };
-  beforeEach(() => {
-    vi.mocked(login).mockResolvedValue({
-      session: ADMIN_SESSION,
-      config: SHOPIFY_CONFIG
-    });
-    vi.mocked(getStorefrontEnvVariables).mockResolvedValue({
-      id: SHOPIFY_CONFIG.storefront.id,
-      environmentVariables: [
-        {
-          id: "gid://shopify/HydrogenStorefrontEnvironmentVariable/1",
-          key: "PUBLIC_API_TOKEN",
-          value: "abc123",
-          isSecret: false,
-          readOnly: false
-        }
-      ]
-    });
-  });
-  afterEach(() => {
-    vi.resetAllMocks();
-    mockAndCaptureOutput().clear();
-  });
-  it("calls pullRemoteEnvironmentVariables", async () => {
-    await inTemporaryDirectory(async (tmpDir) => {
-      await getAllEnvironmentVariables({
-        envBranch: "main",
-        root: tmpDir
-      });
-      expect(getStorefrontEnvVariables).toHaveBeenCalledWith(
-        ADMIN_SESSION,
-        SHOPIFY_CONFIG.storefront.id,
-        "main"
-      );
-    });
-  });
-  it("does not call pullRemoteEnvironmentVariables when indicated", async () => {
-    await inTemporaryDirectory(async (tmpDir) => {
-      await getAllEnvironmentVariables({
-        envBranch: "main",
-        root: tmpDir,
-        fetchRemote: false
-      });
-      expect(getStorefrontEnvVariables).not.toHaveBeenCalled();
-    });
-  });
-  it("renders a message about injection", async () => {
-    await inTemporaryDirectory(async (tmpDir) => {
-      const outputMock = mockAndCaptureOutput();
-      await getAllEnvironmentVariables({ root: tmpDir });
-      expect(outputMock.info()).toMatch(
-        /Environment variables injected into MiniOxygen:/
-      );
-    });
-  });
-  it("lists all of the variables being used", async () => {
-    await inTemporaryDirectory(async (tmpDir) => {
-      const outputMock = mockAndCaptureOutput();
-      await getAllEnvironmentVariables({ root: tmpDir });
-      expect(outputMock.info()).toMatch(/PUBLIC_API_TOKEN\s+from Oxygen/);
-    });
-  });
-  it("doest not fail on network errors", async () => {
-    await inTemporaryDirectory(async (tmpDir) => {
-      vi.mocked(getStorefrontEnvVariables).mockRejectedValue(
-        new Error("Network error")
-      );
-      const outputMock = mockAndCaptureOutput();
-      await getAllEnvironmentVariables({ root: tmpDir });
-      expect(outputMock.info()).not.toMatch(/PUBLIC_API_TOKEN\s+from Oxygen/);
-      expect(outputMock.warn()).toMatch(/failed to load/i);
-    });
-  });
-  describe("when one of the variables is a secret", () => {
-    beforeEach(() => {
-      vi.mocked(getStorefrontEnvVariables).mockResolvedValue({
-        id: SHOPIFY_CONFIG.storefront.id,
-        environmentVariables: [
-          {
-            id: "gid://shopify/HydrogenStorefrontEnvironmentVariable/1",
-            key: "PUBLIC_API_TOKEN",
-            value: "",
-            isSecret: true,
-            readOnly: false
-          }
-        ]
-      });
-    });
-    it("uses special messaging to alert the user", async () => {
-      await inTemporaryDirectory(async (tmpDir) => {
-        const outputMock = mockAndCaptureOutput();
-        await getAllEnvironmentVariables({ root: tmpDir });
-        expect(outputMock.info()).toMatch(
-          /PUBLIC_API_TOKEN\s+from Oxygen \(Marked as secret\)/
-        );
-      });
-    });
-  });
-  describe("when there are local variables", () => {
-    it("includes local variables in the list", async () => {
-      await inTemporaryDirectory(async (tmpDir) => {
-        const filePath = joinPath(tmpDir, ".env");
-        await writeFile(filePath, "LOCAL_TOKEN=1");
-        const outputMock = mockAndCaptureOutput();
-        await getAllEnvironmentVariables({ root: tmpDir });
-        expect(outputMock.info()).toMatch(/LOCAL_TOKEN\s+from local \.env/);
-      });
-    });
-    describe("and they overwrite remote variables", () => {
-      it("uses special messaging to alert the user", async () => {
-        await inTemporaryDirectory(async (tmpDir) => {
-          const filePath = joinPath(tmpDir, ".env");
-          await writeFile(filePath, "PUBLIC_API_TOKEN=abc");
-          const outputMock = mockAndCaptureOutput();
-          await getAllEnvironmentVariables({ root: tmpDir });
-          expect(outputMock.info()).not.toMatch(
-            /PUBLIC_API_TOKEN\s+from Oxygen/
-          );
-          expect(outputMock.info()).toMatch(
-            /PUBLIC_API_TOKEN\s+from local \.env/
-          );
-        });
-      });
-    });
-  });
-});

package/dist/lib/file.test.js

@@ -1,68 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { replaceFileContent, findFileWithExtension } from './file.js';
-import { resolvePath } from '@shopify/cli-kit/node/path';
-import { inTemporaryDirectory, writeFile, readFile, mkdir } from '@shopify/cli-kit/node/fs';
-
-describe("File utils", () => {
-  describe("replaceFileContent", () => {
-    it("replaces the content of a file and formats it", async () => {
-      await inTemporaryDirectory(async (tmpDir) => {
-        const filepath = resolvePath(tmpDir, "index.js");
-        await writeFile(
-          filepath,
-          'function foo() { console.log("foo"); return null}'
-        );
-        await replaceFileContent(filepath, {}, async (content) => {
-          return content.replaceAll("foo", "bar");
-        });
-        expect(await readFile(filepath)).toBe(
-          'function bar() {\n  console.log("bar");\n  return null;\n}\n'
-        );
-      });
-    });
-  });
-  describe("findFileWithExtension", () => {
-    it("ignores missing files", async () => {
-      await inTemporaryDirectory(async (tmpDir) => {
-        expect(findFileWithExtension(tmpDir, "nope")).resolves.toEqual({
-          filepath: void 0,
-          extension: void 0,
-          astType: void 0
-        });
-      });
-    });
-    it("finds the file with its corresponding extension and astType", async () => {
-      await inTemporaryDirectory(async (tmpDir) => {
-        await writeFile(resolvePath(tmpDir, "first.js"), "content");
-        await writeFile(resolvePath(tmpDir, "second.tsx"), "content");
-        await writeFile(resolvePath(tmpDir, "third.mjs"), "content");
-        await writeFile(resolvePath(tmpDir, "fourth"), "content");
-        await mkdir(resolvePath(tmpDir, "fifth"));
-        await writeFile(resolvePath(tmpDir, "fifth", "index.ts"), "content");
-        expect(findFileWithExtension(tmpDir, "first")).resolves.toEqual({
-          filepath: expect.stringMatching(/first\.js$/),
-          extension: "js",
-          astType: "js"
-        });
-        expect(findFileWithExtension(tmpDir, "second")).resolves.toEqual({
-          filepath: expect.stringMatching(/second\.tsx$/),
-          extension: "tsx",
-          astType: "tsx"
-        });
-        expect(findFileWithExtension(tmpDir, "third")).resolves.toEqual({
-          filepath: expect.stringMatching(/third\.mjs$/),
-          extension: "mjs",
-          astType: "js"
-        });
-        expect(findFileWithExtension(tmpDir, "fourth")).resolves.toEqual({
-          filepath: expect.stringMatching(/fourth$/)
-        });
-        expect(findFileWithExtension(tmpDir, "fifth")).resolves.toEqual({
-          filepath: expect.stringMatching(/fifth\/index\.ts$/),
-          extension: "ts",
-          astType: "ts"
-        });
-      });
-    });
-  });
-});

package/dist/lib/flags.test.js

@@ -1,43 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { flagsToCamelObject, parseProcessFlags } from './flags.js';
-
-describe("CLI flag utils", () => {
-  it("turns kebab-case flags to camelCase", async () => {
-    expect(
-      flagsToCamelObject({
-        "kebab-case": "value",
-        "another-kebab-case": "value",
-        flag: "value"
-      })
-    ).toMatchObject({
-      kebabCase: "value",
-      anotherKebabCase: "value",
-      flag: "value"
-    });
-  });
-  it("parses flags from process.argv", async () => {
-    expect(
-      parseProcessFlags(
-        "node ./bin --force --install-deps --template hello-world --path test --language ts".split(
-          " "
-        )
-      )
-    ).toMatchObject({
-      force: true,
-      installDeps: true,
-      template: "hello-world",
-      path: "test",
-      language: "ts"
-    });
-    expect(
-      parseProcessFlags(
-        "node ./bin -f --no-install-deps --language js".split(" "),
-        { f: "force" }
-      )
-    ).toMatchObject({
-      force: true,
-      installDeps: false,
-      language: "js"
-    });
-  });
-});