Emdash source with visual editor image upload fix
Fixes: 1. media.ts: wrap placeholder generation in try-catch 2. toolbar.ts: check r.ok, display error message in popover
This commit is contained in:
368
packages/create-emdash/tests/flags.test.ts
Normal file
368
packages/create-emdash/tests/flags.test.ts
Normal file
@@ -0,0 +1,368 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
|
||||
import { FlagError, HELP_TEXT, parseFlags, validateProjectName, wantsHelp } from "../src/flags.js";
|
||||
|
||||
/**
|
||||
* `parseArgs` consumes argv from index 2 onward, mirroring `process.argv`.
|
||||
* Helper keeps tests readable.
|
||||
*/
|
||||
function argv(...args: string[]): string[] {
|
||||
return ["node", "create-emdash", ...args];
|
||||
}
|
||||
|
||||
describe("parseFlags — defaults", () => {
|
||||
it("returns no values when called with no args", () => {
|
||||
const flags = parseFlags(argv());
|
||||
expect(flags).toEqual({ yes: false, force: false, help: false });
|
||||
});
|
||||
|
||||
it("treats yes/force/help as false when omitted (not undefined)", () => {
|
||||
// Important: index.ts checks these directly, so they must be
|
||||
// boolean — never undefined.
|
||||
const flags = parseFlags(argv());
|
||||
expect(flags.yes).toBe(false);
|
||||
expect(flags.force).toBe(false);
|
||||
expect(flags.help).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe("parseFlags — positional name", () => {
|
||||
it("captures the project name from the first positional", () => {
|
||||
const flags = parseFlags(argv("my-blog"));
|
||||
expect(flags.name).toBe("my-blog");
|
||||
});
|
||||
|
||||
it('accepts "." for current directory', () => {
|
||||
const flags = parseFlags(argv("."));
|
||||
expect(flags.name).toBe(".");
|
||||
});
|
||||
|
||||
it("does NOT validate the name itself — that's the resolver's job", () => {
|
||||
// Validation moved to validateProjectName so the prompt path and the
|
||||
// flag path use the same rule with the same error message. parseFlags
|
||||
// is purely structural; it stores whatever the user typed. The
|
||||
// resolver enforces PROJECT_NAME_PATTERN before scaffolding.
|
||||
const flags = parseFlags(argv("My-Site"));
|
||||
expect(flags.name).toBe("My-Site");
|
||||
});
|
||||
|
||||
it("accepts a positional after flags", () => {
|
||||
const flags = parseFlags(argv("--yes", "my-blog"));
|
||||
expect(flags.name).toBe("my-blog");
|
||||
expect(flags.yes).toBe(true);
|
||||
});
|
||||
|
||||
it("rejects extra positionals as a likely typo", () => {
|
||||
// `npm create emdash my blog` (space instead of hyphen) is the
|
||||
// killer case: without this check it parses as name="my", drops
|
||||
// "blog" silently, and creates a project literally named "my".
|
||||
expect(() => parseFlags(argv("my", "blog"))).toThrow(FlagError);
|
||||
expect(() => parseFlags(argv("my", "blog"))).toThrow(/Unexpected extra/);
|
||||
});
|
||||
|
||||
it("does not reject extra-position errors when the second token is a flag", () => {
|
||||
// argv ordering shouldn't trip the extra-positional check — flags
|
||||
// are removed by parseArgs before we count positionals.
|
||||
const flags = parseFlags(argv("my-blog", "--yes"));
|
||||
expect(flags.name).toBe("my-blog");
|
||||
expect(flags.yes).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe("validateProjectName", () => {
|
||||
it("returns undefined for a valid name", () => {
|
||||
expect(validateProjectName("my-site")).toBeUndefined();
|
||||
expect(validateProjectName("blog")).toBeUndefined();
|
||||
expect(validateProjectName("a")).toBeUndefined();
|
||||
expect(validateProjectName("123")).toBeUndefined();
|
||||
});
|
||||
|
||||
it('returns undefined for "." (current-dir sentinel)', () => {
|
||||
expect(validateProjectName(".")).toBeUndefined();
|
||||
});
|
||||
|
||||
it("returns an error message for invalid names", () => {
|
||||
expect(validateProjectName("My-Site")).toMatch(/lowercase letters/);
|
||||
expect(validateProjectName("my site")).toMatch(/lowercase letters/);
|
||||
expect(validateProjectName("my.site")).toMatch(/lowercase letters/);
|
||||
});
|
||||
});
|
||||
|
||||
describe("parseFlags — --template", () => {
|
||||
it("accepts a bare template key", () => {
|
||||
expect(parseFlags(argv("--template", "blog")).template).toBe("blog");
|
||||
expect(parseFlags(argv("--template", "starter")).template).toBe("starter");
|
||||
expect(parseFlags(argv("--template", "marketing")).template).toBe("marketing");
|
||||
expect(parseFlags(argv("--template", "portfolio")).template).toBe("portfolio");
|
||||
});
|
||||
|
||||
it("rejects unknown template keys", () => {
|
||||
expect(() => parseFlags(argv("--template", "nope"))).toThrow(FlagError);
|
||||
expect(() => parseFlags(argv("--template", "nope"))).toThrow(/--template/);
|
||||
});
|
||||
|
||||
it("accepts the combined <platform>:<template> form", () => {
|
||||
const flags = parseFlags(argv("--template", "cloudflare:blog"));
|
||||
expect(flags.platform).toBe("cloudflare");
|
||||
expect(flags.template).toBe("blog");
|
||||
});
|
||||
|
||||
it("accepts node:starter via the combined form", () => {
|
||||
const flags = parseFlags(argv("--template", "node:starter"));
|
||||
expect(flags.platform).toBe("node");
|
||||
expect(flags.template).toBe("starter");
|
||||
});
|
||||
|
||||
it("rejects an unknown platform prefix in the combined form", () => {
|
||||
expect(() => parseFlags(argv("--template", "vercel:blog"))).toThrow(FlagError);
|
||||
expect(() => parseFlags(argv("--template", "vercel:blog"))).toThrow(/platform prefix/);
|
||||
});
|
||||
|
||||
it("rejects an unknown template name in the combined form", () => {
|
||||
expect(() => parseFlags(argv("--template", "cloudflare:nope"))).toThrow(FlagError);
|
||||
});
|
||||
|
||||
it("errors when --platform and --template platform-prefix disagree (platform first)", () => {
|
||||
// Easy to trip over if a user copies a flag set; surfacing an error
|
||||
// is friendlier than silently letting one win.
|
||||
expect(() => parseFlags(argv("--platform", "node", "--template", "cloudflare:blog"))).toThrow(
|
||||
FlagError,
|
||||
);
|
||||
expect(() => parseFlags(argv("--platform", "node", "--template", "cloudflare:blog"))).toThrow(
|
||||
/conflicts/,
|
||||
);
|
||||
});
|
||||
|
||||
it("errors when --platform and --template platform-prefix disagree (template first)", () => {
|
||||
// Same as above but argv order reversed — conflict detection must
|
||||
// be order-independent. Without the reconcile-at-end pattern this
|
||||
// test passes by accident.
|
||||
expect(() => parseFlags(argv("--template", "cloudflare:blog", "--platform", "node"))).toThrow(
|
||||
FlagError,
|
||||
);
|
||||
});
|
||||
|
||||
it("accepts --platform and --template platform-prefix when they agree", () => {
|
||||
const flags = parseFlags(argv("--platform", "cloudflare", "--template", "cloudflare:blog"));
|
||||
expect(flags.platform).toBe("cloudflare");
|
||||
expect(flags.template).toBe("blog");
|
||||
});
|
||||
|
||||
it("rejects empty halves of the combined form", () => {
|
||||
expect(() => parseFlags(argv("--template", ":"))).toThrow(FlagError);
|
||||
expect(() => parseFlags(argv("--template", ":blog"))).toThrow(FlagError);
|
||||
expect(() => parseFlags(argv("--template", "cloudflare:"))).toThrow(FlagError);
|
||||
});
|
||||
|
||||
it("treats subsequent colons as part of the template name (which then fails)", () => {
|
||||
// `cloudflare:blog:extra` -> platformPart="cloudflare", templatePart="blog:extra".
|
||||
// templatePart isn't a valid template, so we get the template error.
|
||||
expect(() => parseFlags(argv("--template", "cloudflare:blog:extra"))).toThrow(
|
||||
/--template name must be one of/,
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe("parseFlags — --platform", () => {
|
||||
it("accepts valid platforms", () => {
|
||||
expect(parseFlags(argv("--platform", "node")).platform).toBe("node");
|
||||
expect(parseFlags(argv("--platform", "cloudflare")).platform).toBe("cloudflare");
|
||||
});
|
||||
|
||||
it("rejects unknown platforms", () => {
|
||||
expect(() => parseFlags(argv("--platform", "vercel"))).toThrow(FlagError);
|
||||
});
|
||||
});
|
||||
|
||||
describe("parseFlags — package manager", () => {
|
||||
it("accepts --pm with valid managers", () => {
|
||||
expect(parseFlags(argv("--pm", "pnpm")).packageManager).toBe("pnpm");
|
||||
expect(parseFlags(argv("--pm", "npm")).packageManager).toBe("npm");
|
||||
expect(parseFlags(argv("--pm", "yarn")).packageManager).toBe("yarn");
|
||||
expect(parseFlags(argv("--pm", "bun")).packageManager).toBe("bun");
|
||||
});
|
||||
|
||||
it("accepts --package-manager as an alias", () => {
|
||||
expect(parseFlags(argv("--package-manager", "pnpm")).packageManager).toBe("pnpm");
|
||||
});
|
||||
|
||||
it("rejects unknown package managers", () => {
|
||||
expect(() => parseFlags(argv("--pm", "deno"))).toThrow(FlagError);
|
||||
});
|
||||
|
||||
it("accepts --pm and --package-manager together when they agree", () => {
|
||||
const flags = parseFlags(argv("--pm", "pnpm", "--package-manager", "pnpm"));
|
||||
expect(flags.packageManager).toBe("pnpm");
|
||||
});
|
||||
|
||||
it("errors when --pm and --package-manager disagree", () => {
|
||||
expect(() => parseFlags(argv("--pm", "pnpm", "--package-manager", "npm"))).toThrow(FlagError);
|
||||
});
|
||||
});
|
||||
|
||||
describe("parseFlags — install toggle", () => {
|
||||
it("--install sets install: true", () => {
|
||||
expect(parseFlags(argv("--install")).install).toBe(true);
|
||||
});
|
||||
|
||||
it("--no-install sets install: false", () => {
|
||||
expect(parseFlags(argv("--no-install")).install).toBe(false);
|
||||
});
|
||||
|
||||
it("install is undefined when neither flag is passed", () => {
|
||||
expect(parseFlags(argv()).install).toBeUndefined();
|
||||
});
|
||||
|
||||
it("errors when both --install and --no-install are passed", () => {
|
||||
expect(() => parseFlags(argv("--install", "--no-install"))).toThrow(FlagError);
|
||||
});
|
||||
});
|
||||
|
||||
describe("parseFlags — --yes / -y", () => {
|
||||
it("--yes sets yes: true", () => {
|
||||
expect(parseFlags(argv("--yes")).yes).toBe(true);
|
||||
});
|
||||
|
||||
it("-y sets yes: true", () => {
|
||||
expect(parseFlags(argv("-y")).yes).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe("parseFlags — --force", () => {
|
||||
it("--force sets force: true", () => {
|
||||
expect(parseFlags(argv("--force")).force).toBe(true);
|
||||
});
|
||||
|
||||
it("force defaults to false", () => {
|
||||
expect(parseFlags(argv()).force).toBe(false);
|
||||
});
|
||||
|
||||
it("--force composes with --yes", () => {
|
||||
const flags = parseFlags(argv("--yes", "--force"));
|
||||
expect(flags.yes).toBe(true);
|
||||
expect(flags.force).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe("wantsHelp", () => {
|
||||
it("returns true when --help is present", () => {
|
||||
expect(wantsHelp(["node", "script", "--help"])).toBe(true);
|
||||
});
|
||||
|
||||
it("returns true when -h is present", () => {
|
||||
expect(wantsHelp(["node", "script", "-h"])).toBe(true);
|
||||
});
|
||||
|
||||
it("returns true even when --help is preceded by an invalid flag", () => {
|
||||
// This is the whole point of wantsHelp — we want help even when
|
||||
// strict parseArgs would reject the rest of argv.
|
||||
expect(wantsHelp(["node", "script", "--templat", "x", "--help"])).toBe(true);
|
||||
});
|
||||
|
||||
it("returns false when neither flag is present", () => {
|
||||
expect(wantsHelp(["node", "script"])).toBe(false);
|
||||
expect(wantsHelp(["node", "script", "my-blog", "--yes"])).toBe(false);
|
||||
});
|
||||
|
||||
it("does not match a positional that happens to spell 'help'", () => {
|
||||
// A user passing `help` as a project name is invalid in
|
||||
// PROJECT_NAME_PATTERN terms (it's actually fine — `help` is
|
||||
// lowercase letters), but the point is wantsHelp matches the flag
|
||||
// only, not arbitrary tokens.
|
||||
expect(wantsHelp(["node", "script", "help"])).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe("parseFlags — --help / -h", () => {
|
||||
it("--help sets help: true", () => {
|
||||
expect(parseFlags(argv("--help")).help).toBe(true);
|
||||
});
|
||||
|
||||
it("-h sets help: true", () => {
|
||||
expect(parseFlags(argv("-h")).help).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe("parseFlags — unknown flags", () => {
|
||||
it("throws on unknown flags rather than silently ignoring them", () => {
|
||||
// parseArgs in strict mode (the default) throws TypeError. We
|
||||
// don't re-wrap it because the message it produces is already
|
||||
// user-facing-friendly: 'Unknown option \'--templat\''.
|
||||
expect(() => parseFlags(argv("--templat", "blog"))).toThrow();
|
||||
});
|
||||
});
|
||||
|
||||
describe("parseFlags — full one-shot install line", () => {
|
||||
it("parses the example from the issue", () => {
|
||||
const flags = parseFlags(
|
||||
argv("my-blog", "--template", "cloudflare:blog", "--pm", "pnpm", "--yes"),
|
||||
);
|
||||
expect(flags).toEqual({
|
||||
name: "my-blog",
|
||||
platform: "cloudflare",
|
||||
template: "blog",
|
||||
packageManager: "pnpm",
|
||||
yes: true,
|
||||
force: false,
|
||||
help: false,
|
||||
});
|
||||
});
|
||||
|
||||
it("parses split-flag form", () => {
|
||||
const flags = parseFlags(
|
||||
argv(
|
||||
"my-blog",
|
||||
"--platform",
|
||||
"node",
|
||||
"--template",
|
||||
"starter",
|
||||
"--pm",
|
||||
"npm",
|
||||
"--no-install",
|
||||
"--yes",
|
||||
),
|
||||
);
|
||||
expect(flags).toEqual({
|
||||
name: "my-blog",
|
||||
platform: "node",
|
||||
template: "starter",
|
||||
packageManager: "npm",
|
||||
install: false,
|
||||
yes: true,
|
||||
force: false,
|
||||
help: false,
|
||||
});
|
||||
});
|
||||
|
||||
it("parses cwd-overwrite form (--yes . --force)", () => {
|
||||
const flags = parseFlags(argv(".", "--yes", "--force"));
|
||||
expect(flags.name).toBe(".");
|
||||
expect(flags.yes).toBe(true);
|
||||
expect(flags.force).toBe(true);
|
||||
});
|
||||
});
|
||||
|
||||
describe("HELP_TEXT", () => {
|
||||
it("documents every supported flag", () => {
|
||||
// Cheap lint to keep HELP_TEXT in sync with parseFlags. If you
|
||||
// add a new flag and don't document it, this fails.
|
||||
for (const flag of [
|
||||
"--template",
|
||||
"--platform",
|
||||
"--pm",
|
||||
"--package-manager",
|
||||
"--install",
|
||||
"--no-install",
|
||||
"--yes",
|
||||
"--force",
|
||||
"--help",
|
||||
]) {
|
||||
expect(HELP_TEXT).toContain(flag);
|
||||
}
|
||||
});
|
||||
|
||||
it("documents the short-form aliases", () => {
|
||||
expect(HELP_TEXT).toContain("-y");
|
||||
expect(HELP_TEXT).toContain("-h");
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user