@patternfly/patternfly-cli 1.0.2

package/src/__tests__/cli.test.ts

@@ -0,0 +1,171 @@
+jest.mock('inquirer', () => ({
+  __esModule: true,
+  default: { prompt: jest.fn() },
+}));
+
+import path from 'path';
+import fs from 'fs-extra';
+import { loadCustomTemplates, mergeTemplates } from '../template-loader.js';
+import templates from '../templates.js';
+import { sanitizeRepoName } from '../github.js';
+
+const fixturesDir = path.join(process.cwd(), 'src', '__tests__', 'fixtures');
+
+describe('loadCustomTemplates', () => {
+  const exitSpy = jest.spyOn(process, 'exit').mockImplementation(((code?: number) => {
+    throw new Error(`process.exit(${code})`);
+  }) as () => never);
+  const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+  afterEach(() => {
+    consoleErrorSpy.mockClear();
+  });
+
+  afterAll(() => {
+    exitSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  it('loads and parses a valid template file', () => {
+    const filePath = path.join(fixturesDir, 'valid-templates.json');
+    const result = loadCustomTemplates(filePath);
+
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual({
+      name: 'custom-one',
+      description: 'A custom template',
+      repo: 'https://github.com/example/custom-one.git',
+    });
+    expect(result[1]).toEqual({
+      name: 'custom-with-options',
+      description: 'Custom with clone options',
+      repo: 'https://github.com/example/custom.git',
+      options: ['--depth', '1'],
+      packageManager: 'pnpm',
+    });
+  });
+
+  it('exits when file does not exist', () => {
+    const filePath = path.join(fixturesDir, 'nonexistent.json');
+
+    expect(() => loadCustomTemplates(filePath)).toThrow('process.exit(1)');
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Template file not found'),
+    );
+  });
+
+  it('exits when file contains invalid JSON', async () => {
+    const invalidPath = path.join(fixturesDir, 'invalid-json.txt');
+    await fs.writeFile(invalidPath, 'not valid json {');
+
+    try {
+      expect(() => loadCustomTemplates(invalidPath)).toThrow('process.exit(1)');
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Invalid JSON'),
+      );
+    } finally {
+      await fs.remove(invalidPath);
+    }
+  });
+
+  it('exits when JSON is not an array', () => {
+    const filePath = path.join(fixturesDir, 'not-array.json');
+
+    expect(() => loadCustomTemplates(filePath)).toThrow('process.exit(1)');
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('must be a JSON array'),
+    );
+  });
+
+  it('exits when template is missing required name', () => {
+    const filePath = path.join(fixturesDir, 'invalid-template-missing-name.json');
+
+    expect(() => loadCustomTemplates(filePath)).toThrow('process.exit(1)');
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('"name" must be'),
+    );
+  });
+
+  it('exits when template has invalid options (non-string array)', () => {
+    const filePath = path.join(fixturesDir, 'invalid-template-bad-options.json');
+
+    expect(() => loadCustomTemplates(filePath)).toThrow('process.exit(1)');
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('"options" must be'),
+    );
+  });
+});
+
+describe('mergeTemplates', () => {
+  const exitSpy = jest.spyOn(process, 'exit').mockImplementation(((code?: number) => {
+    throw new Error(`process.exit(${code})`);
+  }) as () => never);
+
+  afterAll(() => {
+    exitSpy.mockRestore();
+  });
+  it('returns built-in templates when no custom file path is provided', () => {
+    const result = mergeTemplates(templates);
+
+    expect(result).toEqual(templates);
+    expect(result).toHaveLength(templates.length);
+  });
+
+  it('returns built-in templates when custom file path is undefined', () => {
+    const result = mergeTemplates(templates, undefined);
+
+    expect(result).toEqual(templates);
+  });
+
+  it('merges custom templates with built-in, custom overrides by name', () => {
+    const customPath = path.join(fixturesDir, 'valid-templates.json');
+    const result = mergeTemplates(templates, customPath);
+
+    const names = result.map((t) => t.name);
+    expect(names).toContain('custom-one');
+    expect(names).toContain('custom-with-options');
+
+    const customOne = result.find((t) => t.name === 'custom-one');
+    expect(customOne?.repo).toBe('https://github.com/example/custom-one.git');
+  });
+
+  it('overrides built-in template when custom has same name', async () => {
+    const builtInStarter = templates.find((t) => t.name === 'starter');
+    expect(builtInStarter).toBeDefined();
+
+    const customPath = path.join(fixturesDir, 'override-starter.json');
+    await fs.writeJson(customPath, [
+      {
+        name: 'starter',
+        description: 'Overridden starter',
+        repo: 'https://github.com/custom/overridden-starter.git',
+      },
+    ]);
+
+    try {
+      const result = mergeTemplates(templates, customPath);
+      const starter = result.find((t) => t.name === 'starter');
+      expect(starter?.description).toBe('Overridden starter');
+      expect(starter?.repo).toBe('https://github.com/custom/overridden-starter.git');
+    } finally {
+      await fs.remove(customPath);
+    }
+  });
+});
+
+describe('GitHub support (create command)', () => {
+  it('derives repo name from package name the same way the create command does', () => {
+    // Create command uses sanitizeRepoName(pkgJson.name) for initial repo name
+    expect(sanitizeRepoName('my-app')).toBe('my-app');
+    expect(sanitizeRepoName('@patternfly/my-project')).toBe('my-project');
+    expect(sanitizeRepoName('My Project Name')).toBe('my-project-name');
+  });
+
+  it('builds repo URL in the format used by the create command', () => {
+    // Create command builds https://github.com/${auth.username}/${repoName}
+    const username = 'testuser';
+    const repoName = sanitizeRepoName('@org/my-package');
+    const repoUrl = `https://github.com/${username}/${repoName}`;
+    expect(repoUrl).toBe('https://github.com/testuser/my-package');
+  });
+});

package/src/__tests__/fixtures/invalid-template-bad-options.json

@@ -0,0 +1 @@
+[{"name": "bad", "description": "Bad options", "repo": "https://example.com/repo.git", "options": [123]}]

package/src/__tests__/fixtures/invalid-template-missing-name.json

@@ -0,0 +1 @@
+[{"description": "No name", "repo": "https://example.com/repo.git"}]

package/src/__tests__/fixtures/not-array.json

@@ -0,0 +1 @@
+{"templates": []}

package/src/__tests__/fixtures/valid-templates.json

@@ -0,0 +1,14 @@
+[
+  {
+    "name": "custom-one",
+    "description": "A custom template",
+    "repo": "https://github.com/example/custom-one.git"
+  },
+  {
+    "name": "custom-with-options",
+    "description": "Custom with clone options",
+    "repo": "https://github.com/example/custom.git",
+    "options": ["--depth", "1"],
+    "packageManager": "pnpm"
+  }
+]

package/src/__tests__/github.test.ts

@@ -0,0 +1,214 @@
+jest.mock('execa', () => ({
+  __esModule: true,
+  execa: jest.fn(),
+}));
+
+jest.mock('inquirer', () => ({
+  __esModule: true,
+  default: { prompt: jest.fn() },
+}));
+
+import {
+  sanitizeRepoName,
+  checkGhAuth,
+  repoExists,
+  createRepo,
+} from '../github.js';
+import { execa as mockExeca } from 'execa';
+
+describe('sanitizeRepoName', () => {
+  it('returns lowercase name with invalid chars replaced by hyphen', () => {
+    expect(sanitizeRepoName('My Project')).toBe('my-project');
+    expect(sanitizeRepoName('my_project')).toBe('my_project');
+  });
+
+  it('strips npm scope and uses package name only', () => {
+    expect(sanitizeRepoName('@my-org/my-package')).toBe('my-package');
+    expect(sanitizeRepoName('@scope/package-name')).toBe('package-name');
+  });
+
+  it('collapses multiple hyphens', () => {
+    expect(sanitizeRepoName('my---project')).toBe('my-project');
+    expect(sanitizeRepoName('  spaces  ')).toBe('spaces');
+  });
+
+  it('strips leading and trailing hyphens', () => {
+    expect(sanitizeRepoName('--my-project--')).toBe('my-project');
+    expect(sanitizeRepoName('-single-')).toBe('single');
+  });
+
+  it('allows alphanumeric, hyphens, underscores, and dots', () => {
+    expect(sanitizeRepoName('my.project_1')).toBe('my.project_1');
+    expect(sanitizeRepoName('v1.0.0')).toBe('v1.0.0');
+  });
+
+  it('returns "my-project" when result would be empty', () => {
+    expect(sanitizeRepoName('@scope/---')).toBe('my-project');
+    expect(sanitizeRepoName('!!!')).toBe('my-project');
+  });
+
+  it('handles scoped package with only special chars after scope', () => {
+    expect(sanitizeRepoName('@org/---')).toBe('my-project');
+  });
+});
+
+describe('checkGhAuth', () => {
+  beforeEach(() => {
+    mockExeca.mockReset();
+  });
+
+  it('returns ok: false when gh auth status fails', async () => {
+    mockExeca.mockRejectedValueOnce(new Error('not logged in'));
+
+    const result = await checkGhAuth();
+
+    expect(result).toEqual({
+      ok: false,
+      message: expect.stringContaining('GitHub CLI (gh) is not installed'),
+    });
+    expect(mockExeca).toHaveBeenCalledWith('gh', ['auth', 'status'], { reject: true });
+  });
+
+  it('returns ok: false when gh api user returns empty login', async () => {
+    mockExeca.mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+    mockExeca.mockResolvedValueOnce({ stdout: '\n  \n', stderr: '', exitCode: 0 });
+
+    const result = await checkGhAuth();
+
+    expect(result).toEqual({
+      ok: false,
+      message: expect.stringContaining('Could not determine your GitHub username'),
+    });
+  });
+
+  it('returns ok: false when gh api user throws', async () => {
+    mockExeca.mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+    mockExeca.mockRejectedValueOnce(new Error('API error'));
+
+    const result = await checkGhAuth();
+
+    expect(result).toEqual({
+      ok: false,
+      message: expect.stringContaining('Could not fetch your GitHub username'),
+    });
+  });
+
+  it('returns ok: true with username when auth and api succeed', async () => {
+    mockExeca.mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+    mockExeca.mockResolvedValueOnce({
+      stdout: '  octocat  ',
+      stderr: '',
+      exitCode: 0,
+    });
+
+    const result = await checkGhAuth();
+
+    expect(result).toEqual({ ok: true, username: 'octocat' });
+    expect(mockExeca).toHaveBeenNthCalledWith(2, 'gh', ['api', 'user', '--jq', '.login'], {
+      encoding: 'utf8',
+    });
+  });
+});
+
+describe('repoExists', () => {
+  beforeEach(() => {
+    mockExeca.mockReset();
+  });
+
+  it('returns true when gh api repos/owner/repo succeeds', async () => {
+    mockExeca.mockResolvedValueOnce({ stdout: '{}', stderr: '', exitCode: 0 });
+
+    const result = await repoExists('octocat', 'my-repo');
+
+    expect(result).toBe(true);
+    expect(mockExeca).toHaveBeenCalledWith('gh', ['api', 'repos/octocat/my-repo'], {
+      reject: true,
+    });
+  });
+
+  it('returns false when gh api throws (e.g. 404)', async () => {
+    mockExeca.mockRejectedValueOnce(new Error('Not Found'));
+
+    const result = await repoExists('octocat', 'nonexistent');
+
+    expect(result).toBe(false);
+  });
+});
+
+describe('createRepo', () => {
+  const projectPath = '/tmp/my-app';
+  const username = 'octocat';
+
+  beforeEach(() => {
+    mockExeca.mockReset();
+    mockExeca.mockResolvedValue({ stdout: '', stderr: '', exitCode: 0 });
+  });
+
+  it('initializes git and calls gh repo create with expected args and returns repo URL', async () => {
+    mockExeca
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockRejectedValueOnce(new Error('no HEAD'))
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+
+    const url = await createRepo({
+      repoName: 'my-app',
+      projectPath,
+      username,
+    });
+
+    expect(url).toBe('https://github.com/octocat/my-app.git');
+    expect(mockExeca).toHaveBeenCalledTimes(5);
+    expect(mockExeca).toHaveBeenNthCalledWith(1, 'git', ['init'], {
+      stdio: 'inherit',
+      cwd: projectPath,
+    });
+    expect(mockExeca).toHaveBeenNthCalledWith(2, 'git', ['rev-parse', '--verify', 'HEAD'], expect.any(Object));
+    expect(mockExeca).toHaveBeenNthCalledWith(3, 'git', ['add', '.'], {
+      stdio: 'inherit',
+      cwd: projectPath,
+    });
+    expect(mockExeca).toHaveBeenNthCalledWith(4, 'git', ['commit', '-m', 'Initial commit'], {
+      stdio: 'inherit',
+      cwd: projectPath,
+    });
+    expect(mockExeca).toHaveBeenNthCalledWith(
+      5,
+      'gh',
+      [
+        'repo',
+        'create',
+        'my-app',
+        '--public',
+        `--source=${projectPath}`,
+        '--remote=origin',
+        '--push',
+      ],
+      { stdio: 'inherit', cwd: projectPath },
+    );
+  });
+
+  it('passes description when provided', async () => {
+    mockExeca
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockRejectedValueOnce(new Error('no HEAD'))
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 })
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 });
+
+    await createRepo({
+      repoName: 'my-app',
+      projectPath,
+      username,
+      description: 'My cool project',
+    });
+
+    expect(mockExeca).toHaveBeenNthCalledWith(
+      5,
+      'gh',
+      expect.arrayContaining(['--description=My cool project']),
+      expect.any(Object),
+    );
+  });
+});

package/src/__tests__/load.test.ts

@@ -0,0 +1,106 @@
+jest.mock('fs-extra', () => ({
+  __esModule: true,
+  default: {
+    pathExists: jest.fn(),
+  },
+}));
+
+jest.mock('execa', () => ({
+  __esModule: true,
+  execa: jest.fn(),
+}));
+
+import fs from 'fs-extra';
+import { execa } from 'execa';
+import { runLoad } from '../load.js';
+
+const mockPathExists = fs.pathExists as jest.MockedFunction<typeof fs.pathExists>;
+const mockExeca = execa as jest.MockedFunction<typeof execa>;
+
+const cwd = '/tmp/my-repo';
+
+describe('runLoad', () => {
+  const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+  const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterAll(() => {
+    consoleErrorSpy.mockRestore();
+    consoleLogSpy.mockRestore();
+  });
+
+  it('throws and logs error when .git directory does not exist', async () => {
+    mockPathExists.mockResolvedValue(false);
+
+    await expect(runLoad(cwd)).rejects.toThrow('Not a git repository');
+    expect(mockPathExists).toHaveBeenCalledWith(`${cwd}/.git`);
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('This directory is not a git repository'),
+    );
+    expect(mockExeca).not.toHaveBeenCalled();
+  });
+
+  it('runs git pull and logs success when repo exists', async () => {
+    mockPathExists.mockResolvedValue(true);
+    mockExeca.mockResolvedValue({ stdout: '', stderr: '', exitCode: 0 } as Awaited<ReturnType<typeof execa>>);
+
+    await runLoad(cwd);
+
+    expect(mockExeca).toHaveBeenCalledTimes(1);
+    expect(mockExeca).toHaveBeenCalledWith('git', ['pull'], {
+      cwd,
+      stdio: 'inherit',
+    });
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Pulling latest updates from GitHub'),
+    );
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Latest updates loaded successfully'),
+    );
+  });
+
+  it('throws and logs pull-failure message when pull fails with exitCode 128', async () => {
+    mockPathExists.mockResolvedValue(true);
+    mockExeca.mockRejectedValueOnce(Object.assign(new Error('pull failed'), { exitCode: 128 }));
+
+    await expect(runLoad(cwd)).rejects.toMatchObject({ message: 'pull failed' });
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Pull failed'),
+    );
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('remote'),
+    );
+  });
+
+  it('throws and logs generic failure when pull fails with other exitCode', async () => {
+    mockPathExists.mockResolvedValue(true);
+    mockExeca.mockRejectedValueOnce(Object.assign(new Error('pull failed'), { exitCode: 1 }));
+
+    await expect(runLoad(cwd)).rejects.toMatchObject({ message: 'pull failed' });
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Pull failed'),
+    );
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('See the output above'),
+    );
+  });
+
+  it('throws and logs error when execa throws without exitCode', async () => {
+    mockPathExists.mockResolvedValue(true);
+    mockExeca.mockRejectedValueOnce(new Error('network error'));
+
+    await expect(runLoad(cwd)).rejects.toThrow('network error');
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('An error occurred'),
+    );
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('network error'),
+    );
+  });
+});