@patternfly/patternfly-cli 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@patternfly/patternfly-cli",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "Patternfly cli for scaffolding projects, performing code mods, and running project related tasks",
   "author": "Red Hat",
   "license": "MIT",
@@ -50,7 +50,7 @@
     ]
   },
   "dependencies": {
-    "0g": "^0.4.2",
+    "gh-pages": "^6.3.0",
     "commander": "^12.1.0",
     "execa": "^9.3.0",
     "fs-extra": "^11.2.0",

package/src/__tests__/cli.test.ts

@@ -1,13 +1,7 @@
-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');
 
@@ -152,20 +146,3 @@ describe('mergeTemplates', () => {
     }
   });
 });
-
-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__/create.test.ts

@@ -0,0 +1,306 @@
+jest.mock('inquirer', () => ({
+  __esModule: true,
+  default: { prompt: jest.fn() },
+}));
+
+jest.mock('fs-extra', () => {
+  const real = jest.requireActual<typeof import('fs-extra')>('fs-extra');
+  return {
+    __esModule: true,
+    default: {
+      pathExists: jest.fn(),
+      readJson: jest.fn(),
+      writeJson: jest.fn(),
+      remove: jest.fn(),
+      existsSync: real.existsSync,
+      readFileSync: real.readFileSync,
+    },
+  };
+});
+
+jest.mock('execa', () => ({
+  __esModule: true,
+  execa: jest.fn(),
+}));
+
+jest.mock('../github.js', () => ({
+  ...jest.requireActual('../github.js'),
+  offerAndCreateGitHubRepo: jest.fn(),
+}));
+
+import path from 'path';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+import inquirer from 'inquirer';
+import { sanitizeRepoName, offerAndCreateGitHubRepo } from '../github.js';
+import { runCreate } from '../create.js';
+import { defaultTemplates } from '../templates.js';
+
+const mockPathExists = fs.pathExists as jest.MockedFunction<typeof fs.pathExists>;
+const mockReadJson = fs.readJson as jest.MockedFunction<typeof fs.readJson>;
+const mockWriteJson = fs.writeJson as jest.MockedFunction<typeof fs.writeJson>;
+const mockRemove = fs.remove as jest.MockedFunction<typeof fs.remove>;
+const mockExeca = execa as jest.MockedFunction<typeof execa>;
+const mockPrompt = inquirer.prompt as jest.MockedFunction<typeof inquirer.prompt>;
+const mockOfferAndCreateGitHubRepo = offerAndCreateGitHubRepo as jest.MockedFunction<
+  typeof offerAndCreateGitHubRepo
+>;
+
+const projectDir = 'my-test-project';
+const projectPath = path.resolve(projectDir);
+
+const projectData = {
+  name: 'my-app',
+  version: '1.0.0',
+  description: 'Test app',
+  author: 'Test Author',
+};
+
+function setupHappyPathMocks() {
+  mockExeca.mockResolvedValue({ stdout: '', stderr: '', exitCode: 0 } as Awaited<ReturnType<typeof execa>>);
+  mockPathExists.mockResolvedValue(true);
+  mockReadJson.mockResolvedValue({ name: 'template-name', version: '0.0.0' });
+  mockWriteJson.mockResolvedValue(undefined);
+  mockRemove.mockResolvedValue(undefined);
+  mockOfferAndCreateGitHubRepo.mockResolvedValue(undefined);
+  mockPrompt.mockResolvedValue(projectData);
+  return projectData;
+}
+
+describe('GitHub support (create command)', () => {
+  it('derives repo name from package name the same way the create command does', () => {
+    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', () => {
+    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');
+  });
+});
+
+describe('runCreate', () => {
+  const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+  const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterAll(() => {
+    consoleErrorSpy.mockRestore();
+    consoleLogSpy.mockRestore();
+  });
+
+  it('throws when template name is not found', async () => {
+    await expect(runCreate(projectDir, 'nonexistent-template')).rejects.toThrow(
+      'Template "nonexistent-template" not found'
+    );
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Template "nonexistent-template" not found')
+    );
+    expect(mockExeca).not.toHaveBeenCalled();
+  });
+
+  it('prompts for project directory when not provided', async () => {
+    setupHappyPathMocks();
+
+    await runCreate(undefined, 'starter');
+
+    expect(mockPrompt).toHaveBeenCalledWith(
+      expect.arrayContaining([
+        expect.objectContaining({
+          type: 'input',
+          name: 'projectDirectory',
+          message: expect.stringContaining('directory where you want to create the project'),
+          default: 'my-app',
+        }),
+      ])
+    );
+  });
+
+  it('prompts for template when not provided', async () => {
+    setupHappyPathMocks();
+    mockPrompt
+      .mockResolvedValueOnce({ templateName: 'starter' })
+      .mockResolvedValueOnce(projectData);
+
+    await runCreate(projectDir, undefined);
+
+    expect(mockPrompt).toHaveBeenCalledWith(
+      expect.arrayContaining([
+        expect.objectContaining({
+          type: 'list',
+          name: 'templateName',
+          message: 'Select a template:',
+          choices: expect.any(Array),
+        }),
+      ])
+    );
+  });
+
+  it('uses HTTPS repo URL when ssh option is false', async () => {
+    setupHappyPathMocks();
+
+    await runCreate(projectDir, 'starter', { ssh: false });
+
+    const starter = defaultTemplates.find(t => t.name === 'starter');
+    expect(mockExeca).toHaveBeenNthCalledWith(
+      1,
+      'git',
+      ['clone', starter!.repo, projectPath],
+      expect.objectContaining({ stdio: 'inherit' })
+    );
+  });
+
+  it('uses SSH repo URL when ssh option is true and template has repoSSH', async () => {
+    setupHappyPathMocks();
+
+    await runCreate(projectDir, 'starter', { ssh: true });
+
+    const starter = defaultTemplates.find(t => t.name === 'starter');
+    expect(mockExeca).toHaveBeenNthCalledWith(
+      1,
+      'git',
+      ['clone', starter!.repoSSH, projectPath],
+      expect.objectContaining({ stdio: 'inherit' })
+    );
+  });
+
+  it('passes template clone options to git clone', async () => {
+    setupHappyPathMocks();
+
+    await runCreate(projectDir, 'compass-starter');
+
+    const compass = defaultTemplates.find(t => t.name === 'compass-starter');
+    expect(mockExeca).toHaveBeenNthCalledWith(
+      1,
+      'git',
+      ['clone', ...compass!.options!, compass!.repo, projectPath],
+      expect.any(Object)
+    );
+  });
+
+  it('removes .git from cloned project and customizes package.json', async () => {
+    setupHappyPathMocks();
+
+    await runCreate(projectDir, 'starter');
+
+    expect(mockRemove).toHaveBeenCalledWith(path.join(projectPath, '.git'));
+    expect(mockReadJson).toHaveBeenCalledWith(path.join(projectPath, 'package.json'));
+    expect(mockWriteJson).toHaveBeenCalledWith(
+      path.join(projectPath, 'package.json'),
+      expect.objectContaining({
+        name: projectData.name,
+        version: projectData.version,
+        description: projectData.description,
+        author: projectData.author,
+      }),
+      { spaces: 2 }
+    );
+    expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Customized package.json'));
+  });
+
+  it('skips package.json customization when package.json does not exist', async () => {
+    setupHappyPathMocks();
+    mockPathExists.mockResolvedValue(false);
+
+    await runCreate(projectDir, 'starter');
+
+    expect(mockReadJson).not.toHaveBeenCalled();
+    expect(mockWriteJson).not.toHaveBeenCalled();
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('No package.json found in template')
+    );
+  });
+
+  it('uses template packageManager and runs install', async () => {
+    setupHappyPathMocks();
+
+    await runCreate(projectDir, 'starter');
+
+    expect(mockExeca).toHaveBeenNthCalledWith(
+      2,
+      'yarn',
+      ['install'],
+      expect.objectContaining({ cwd: projectPath, stdio: 'inherit' })
+    );
+  });
+
+  it('falls back to npm when template has no packageManager', async () => {
+    setupHappyPathMocks();
+    // rhoai_enabled_starter has no packageManager
+    const rhoai = defaultTemplates.find(t => t.name === 'rhoai_enabled_starter');
+    expect(rhoai?.packageManager).toBeUndefined();
+
+    await runCreate(projectDir, 'rhoai_enabled_starter');
+
+    expect(mockExeca).toHaveBeenNthCalledWith(
+      2,
+      'npm',
+      ['install'],
+      expect.objectContaining({ cwd: projectPath, stdio: 'inherit' })
+    );
+  });
+
+  it('calls offerAndCreateGitHubRepo after install', async () => {
+    setupHappyPathMocks();
+
+    await runCreate(projectDir, 'starter');
+
+    expect(mockOfferAndCreateGitHubRepo).toHaveBeenCalledWith(projectPath);
+  });
+
+  it('logs success message with project directory', async () => {
+    setupHappyPathMocks();
+
+    await runCreate(projectDir, 'starter');
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Project created successfully'));
+    expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining(`cd ${projectDir}`));
+  });
+
+  it('cleans up project directory and rethrows when clone fails', async () => {
+    mockExeca.mockRejectedValueOnce(new Error('clone failed'));
+    mockPathExists.mockResolvedValue(true);
+
+    await expect(runCreate(projectDir, 'starter')).rejects.toThrow('clone failed');
+
+    expect(mockRemove).toHaveBeenCalledWith(projectPath);
+    expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Cleaned up failed project directory'));
+  });
+
+  it('cleans up project directory and rethrows when install fails', async () => {
+    mockExeca
+      .mockResolvedValueOnce({ stdout: '', stderr: '', exitCode: 0 } as Awaited<ReturnType<typeof execa>>)
+      .mockRejectedValueOnce(new Error('install failed'));
+    mockPathExists.mockResolvedValue(true);
+    mockReadJson.mockResolvedValue({});
+    mockWriteJson.mockResolvedValue(undefined);
+    mockRemove.mockResolvedValue(undefined);
+    mockPrompt.mockResolvedValue(projectData);
+
+    await expect(runCreate(projectDir, 'starter')).rejects.toThrow('install failed');
+
+    expect(mockRemove).toHaveBeenCalledWith(projectPath);
+  });
+
+  it('uses custom templates when templateFile option is provided', async () => {
+    const fixturesDir = path.join(process.cwd(), 'src', '__tests__', 'fixtures');
+    const customPath = path.join(fixturesDir, 'valid-templates.json');
+    setupHappyPathMocks();
+    mockPrompt.mockResolvedValueOnce(projectData);
+
+    await runCreate(projectDir, 'custom-one', { templateFile: customPath });
+
+    expect(mockExeca).toHaveBeenNthCalledWith(
+      1,
+      'git',
+      ['clone', 'https://github.com/example/custom-one.git', projectPath],
+      expect.any(Object)
+    );
+  });
+});

package/src/__tests__/gh-pages.test.ts

@@ -0,0 +1,283 @@
+jest.mock('fs-extra', () => ({
+  __esModule: true,
+  default: {
+    pathExists: jest.fn(),
+    readJson: jest.fn(),
+  },
+}));
+
+jest.mock('execa', () => ({
+  __esModule: true,
+  execa: jest.fn(),
+}));
+
+jest.mock('gh-pages', () => ({
+  __esModule: true,
+  default: {
+    publish: jest.fn(),
+  },
+}));
+
+jest.mock('../github.js', () => ({
+  checkGhAuth: jest.fn().mockResolvedValue({ ok: false }),
+}));
+
+import path from 'path';
+import fs from 'fs-extra';
+import { execa } from 'execa';
+import ghPages from 'gh-pages';
+import { runDeployToGitHubPages } from '../gh-pages.js';
+
+const mockPathExists = fs.pathExists as jest.MockedFunction<typeof fs.pathExists>;
+const mockReadJson = fs.readJson as jest.MockedFunction<typeof fs.readJson>;
+const mockExeca = execa as jest.MockedFunction<typeof execa>;
+const mockGhPagesPublish = ghPages.publish as jest.MockedFunction<typeof ghPages.publish>;
+
+const cwd = '/tmp/my-app';
+
+/** Setup pathExists to return values based on path (avoids brittle call-order chains) */
+function setupPathExists(checks: Record<string, boolean>) {
+  mockPathExists.mockImplementation((p: string) => {
+    for (const [key, value] of Object.entries(checks)) {
+      if (p.includes(key) || p === path.join(cwd, key)) return Promise.resolve(value);
+    }
+    return Promise.resolve(checks['*'] ?? false);
+  });
+}
+
+describe('runDeployToGitHubPages', () => {
+  const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  afterAll(() => {
+    consoleLogSpy.mockRestore();
+  });
+
+  it('throws when package.json does not exist', async () => {
+    mockPathExists.mockImplementation((p: string) =>
+      Promise.resolve(path.join(cwd, 'package.json') !== p)
+    );
+
+    await expect(runDeployToGitHubPages(cwd)).rejects.toThrow(
+      'No package.json found in this directory'
+    );
+    expect(mockPathExists).toHaveBeenCalledWith(path.join(cwd, 'package.json'));
+    expect(mockExeca).not.toHaveBeenCalled();
+  });
+
+  it('throws when git remote origin is not configured', async () => {
+    setupPathExists({ 'package.json': true });
+    mockExeca.mockRejectedValue(new Error('not a git repo'));
+
+    await expect(runDeployToGitHubPages(cwd)).rejects.toThrow(
+      'Please save your changes first, before deploying to GitHub Pages.'
+    );
+    expect(mockExeca).toHaveBeenCalledWith('git', ['remote', 'get-url', 'origin'], {
+      cwd,
+      reject: true,
+    });
+  });
+
+  it('throws when no build script and skipBuild is false', async () => {
+    setupPathExists({ 'package.json': true });
+    mockReadJson.mockResolvedValueOnce({ scripts: {} });
+    mockExeca.mockResolvedValue({
+      stdout: 'https://github.com/user/repo.git',
+      stderr: '',
+      exitCode: 0,
+    } as Awaited<ReturnType<typeof execa>>);
+
+    await expect(runDeployToGitHubPages(cwd, { skipBuild: false })).rejects.toThrow(
+      'No "build" script found in package.json'
+    );
+    expect(mockReadJson).toHaveBeenCalledWith(path.join(cwd, 'package.json'));
+    expect(mockExeca).toHaveBeenCalledTimes(1); // only git
+  });
+
+  it('runs build then deploys when skipBuild is false (npm)', async () => {
+    setupPathExists({ 'package.json': true, 'dist': true });
+    mockReadJson.mockResolvedValueOnce({
+      scripts: { build: 'webpack --config webpack.prod.js' },
+    });
+    mockExeca.mockResolvedValue({
+      stdout: 'https://github.com/user/repo.git',
+      stderr: '',
+      exitCode: 0,
+    } as Awaited<ReturnType<typeof execa>>);
+    mockGhPagesPublish.mockImplementation((_dir, _opts, cb) => cb(null));
+
+    await runDeployToGitHubPages(cwd, { skipBuild: false });
+
+    expect(mockExeca).toHaveBeenCalledTimes(2); // git, npm run build
+    expect(mockExeca).toHaveBeenNthCalledWith(2, 'npm', ['run', 'build'], {
+      cwd,
+      stdio: 'inherit',
+    });
+    expect(mockGhPagesPublish).toHaveBeenCalledWith(
+      path.join(cwd, 'dist'),
+      { branch: 'gh-pages', repo: 'https://github.com/user/repo.git' },
+      expect.any(Function)
+    );
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Running build')
+    );
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Deployed to GitHub Pages')
+    );
+  });
+
+  it('uses yarn when yarn.lock exists', async () => {
+    setupPathExists({ 'package.json': true, 'yarn.lock': true, 'dist': true });
+    mockReadJson.mockResolvedValueOnce({
+      scripts: { build: 'webpack' },
+    });
+    mockExeca.mockResolvedValue({
+      stdout: 'https://github.com/user/repo.git',
+      stderr: '',
+      exitCode: 0,
+    } as Awaited<ReturnType<typeof execa>>);
+    mockGhPagesPublish.mockImplementation((_dir, _opts, cb) => cb(null));
+
+    await runDeployToGitHubPages(cwd, { skipBuild: false });
+
+    expect(mockExeca).toHaveBeenNthCalledWith(2, 'yarn', ['build'], {
+      cwd,
+      stdio: 'inherit',
+    });
+  });
+
+  it('uses pnpm when pnpm-lock.yaml exists (and no yarn.lock)', async () => {
+    setupPathExists({ 'package.json': true, 'pnpm-lock.yaml': true, 'dist': true });
+    mockReadJson.mockResolvedValueOnce({
+      scripts: { build: 'vite build' },
+    });
+    mockExeca.mockResolvedValue({
+      stdout: 'https://github.com/user/repo.git',
+      stderr: '',
+      exitCode: 0,
+    } as Awaited<ReturnType<typeof execa>>);
+    mockGhPagesPublish.mockImplementation((_dir, _opts, cb) => cb(null));
+
+    await runDeployToGitHubPages(cwd, { skipBuild: false });
+
+    expect(mockExeca).toHaveBeenNthCalledWith(2, 'pnpm', ['build'], {
+      cwd,
+      stdio: 'inherit',
+    });
+  });
+
+  it('skips build and deploys when skipBuild is true', async () => {
+    setupPathExists({ 'package.json': true, 'dist': true });
+    mockExeca.mockResolvedValue({
+      stdout: 'https://github.com/user/repo.git',
+      stderr: '',
+      exitCode: 0,
+    } as Awaited<ReturnType<typeof execa>>);
+    mockGhPagesPublish.mockImplementation((_dir, _opts, cb) => cb(null));
+
+    await runDeployToGitHubPages(cwd, { skipBuild: true });
+
+    expect(mockReadJson).not.toHaveBeenCalled();
+    expect(mockExeca).toHaveBeenCalledTimes(1); // git only
+    expect(mockGhPagesPublish).toHaveBeenCalledWith(
+      path.join(cwd, 'dist'),
+      { branch: 'gh-pages', repo: 'https://github.com/user/repo.git' },
+      expect.any(Function)
+    );
+  });
+
+  it('throws when dist directory does not exist (after build)', async () => {
+    setupPathExists({ 'package.json': true, 'dist': false });
+    mockReadJson.mockResolvedValueOnce({
+      scripts: { build: 'npm run build' },
+    });
+    mockExeca.mockResolvedValue({
+      stdout: 'https://github.com/user/repo.git',
+      stderr: '',
+      exitCode: 0,
+    } as Awaited<ReturnType<typeof execa>>);
+
+    await expect(runDeployToGitHubPages(cwd, { skipBuild: false })).rejects.toThrow(
+      'Build output directory "dist" does not exist'
+    );
+    expect(mockExeca).toHaveBeenCalledTimes(2); // git, npm run build
+  });
+
+  it('throws when dist directory does not exist with skipBuild true', async () => {
+    setupPathExists({ 'package.json': true, 'dist': false });
+    mockExeca.mockResolvedValue({
+      stdout: 'https://github.com/user/repo.git',
+      stderr: '',
+      exitCode: 0,
+    } as Awaited<ReturnType<typeof execa>>);
+
+    await expect(runDeployToGitHubPages(cwd, { skipBuild: true })).rejects.toThrow(
+      'Build output directory "dist" does not exist'
+    );
+    expect(mockExeca).toHaveBeenCalledTimes(1); // git only
+  });
+
+  it('uses custom distDir and branch options', async () => {
+    setupPathExists({ 'package.json': true, 'build': true });
+    mockExeca.mockResolvedValue({
+      stdout: 'https://github.com/user/repo.git',
+      stderr: '',
+      exitCode: 0,
+    } as Awaited<ReturnType<typeof execa>>);
+    mockGhPagesPublish.mockImplementation((_dir, _opts, cb) => cb(null));
+
+    await runDeployToGitHubPages(cwd, {
+      skipBuild: true,
+      distDir: 'build',
+      branch: 'pages',
+    });
+
+    expect(mockGhPagesPublish).toHaveBeenCalledWith(
+      path.join(cwd, 'build'),
+      { branch: 'pages', repo: 'https://github.com/user/repo.git' },
+      expect.any(Function)
+    );
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining('Deploying "build" to GitHub Pages (branch: pages)')
+    );
+  });
+
+  it('propagates build failure', async () => {
+    setupPathExists({ 'package.json': true });
+    mockReadJson.mockResolvedValueOnce({
+      scripts: { build: 'webpack' },
+    });
+    mockExeca
+      .mockResolvedValueOnce({
+        stdout: 'https://github.com/user/repo.git',
+        stderr: '',
+        exitCode: 0,
+      } as Awaited<ReturnType<typeof execa>>)
+      .mockRejectedValueOnce(new Error('Build failed'));
+
+    await expect(runDeployToGitHubPages(cwd, { skipBuild: false })).rejects.toThrow(
+      'Build failed'
+    );
+    expect(mockExeca).toHaveBeenCalledTimes(2); // git, npm run build
+  });
+
+  it('propagates gh-pages deploy failure', async () => {
+    setupPathExists({ 'package.json': true, 'dist': true });
+    mockExeca.mockResolvedValue({
+      stdout: 'https://github.com/user/repo.git',
+      stderr: '',
+      exitCode: 0,
+    } as Awaited<ReturnType<typeof execa>>);
+    mockGhPagesPublish.mockImplementation((_dir, _opts, cb) =>
+      cb(new Error('Deploy failed'))
+    );
+
+    await expect(runDeployToGitHubPages(cwd, { skipBuild: true })).rejects.toThrow(
+      'Deploy failed'
+    );
+    expect(mockExeca).toHaveBeenCalledTimes(1); // git only
+  });
+});