@garyr/pt-cli 0.30.1 → 0.32.0

package/tests/config-utils.test.ts

@@ -0,0 +1,473 @@
+import { test, after } from 'node:test';
+import assert from 'node:assert';
+import fs from 'fs';
+import path from 'path';
+
+// Force a temporary home directory for testing BEFORE importing from the CLI
+const testHome = path.join(process.cwd(), '.test-home-config-utils');
+process.env.HOME = testHome;
+
+import {
+  ensureConfigDir,
+  getTemplateNames,
+  getDefaultPostConfig,
+  shouldExclude,
+  shouldIgnore,
+  shouldExcludeFile,
+  sanitizePath,
+  DEFAULT_EXCLUDES,
+  HOME_DIR,
+  PtConfig,
+} from '../src/config.js';
+
+// Clean up test home after all tests
+after(() => {
+  if (fs.existsSync(testHome)) {
+    fs.rmSync(testHome, { recursive: true, force: true });
+  }
+});
+
+// ─── ensureConfigDir ─────────────────────────────────────────────────────────
+
+test('ensureConfigDir creates dir when it does not exist', () => {
+  // Make sure the dir does NOT exist before the test
+  if (fs.existsSync(HOME_DIR)) {
+    fs.rmSync(HOME_DIR, { recursive: true, force: true });
+  }
+  assert.ok(!fs.existsSync(HOME_DIR), 'Precondition: HOME_DIR should not exist');
+
+  ensureConfigDir();
+
+  assert.ok(fs.existsSync(HOME_DIR), 'HOME_DIR should be created');
+  assert.ok(fs.statSync(HOME_DIR).isDirectory(), 'HOME_DIR should be a directory');
+});
+
+test('ensureConfigDir does nothing when dir already exists', () => {
+  // Ensure directory exists first
+  if (!fs.existsSync(HOME_DIR)) {
+    fs.mkdirSync(HOME_DIR, { recursive: true });
+  }
+  // Place a marker file inside to prove the dir is not recreated
+  const markerPath = path.join(HOME_DIR, '.marker');
+  fs.writeFileSync(markerPath, 'exists');
+
+  ensureConfigDir();
+
+  assert.ok(fs.existsSync(HOME_DIR), 'HOME_DIR should still exist');
+  assert.ok(fs.existsSync(markerPath), 'Marker file inside HOME_DIR should still exist');
+
+  // Clean up marker
+  fs.unlinkSync(markerPath);
+});
+
+// ─── getTemplateNames ────────────────────────────────────────────────────────
+
+test('getTemplateNames returns empty array for empty templates', () => {
+  const config: PtConfig = { version: '3.0', templates: {} };
+  const names = getTemplateNames(config);
+  assert.deepStrictEqual(names, []);
+});
+
+test('getTemplateNames returns correct names', () => {
+  const config: PtConfig = {
+    version: '3.0',
+    templates: {
+      'node-api': { description: 'Node API', folders: [] },
+      'react-app': { description: 'React App', folders: [] },
+      'python-cli': { description: 'Python CLI', folders: [] },
+    },
+  };
+  const names = getTemplateNames(config);
+  assert.deepStrictEqual(names, ['node-api', 'react-app', 'python-cli']);
+});
+
+test('getTemplateNames handles undefined templates', () => {
+  // Simulate a config with templates missing entirely
+  const config = { version: '3.0' } as PtConfig;
+  const names = getTemplateNames(config);
+  assert.deepStrictEqual(names, []);
+});
+
+// ─── getDefaultPostConfig ────────────────────────────────────────────────────
+
+test('getDefaultPostConfig returns empty array when no default_post_config', () => {
+  const config: PtConfig = { version: '3.0', templates: {} };
+  const tasks = getDefaultPostConfig(config);
+  assert.deepStrictEqual(tasks, []);
+});
+
+test('getDefaultPostConfig returns empty array when default_post_config is undefined', () => {
+  const config = { version: '3.0', templates: {} } as PtConfig;
+  delete (config as any).default_post_config;
+  const tasks = getDefaultPostConfig(config);
+  assert.deepStrictEqual(tasks, []);
+});
+
+test('getDefaultPostConfig defaults checked to true', () => {
+  const config: PtConfig = {
+    version: '3.0',
+    templates: {},
+    default_post_config: [
+      { description: 'Install deps', command: 'npm install' },
+      { description: 'Run lint', command: 'npm run lint' },
+    ],
+  };
+  const tasks = getDefaultPostConfig(config);
+
+  assert.strictEqual(tasks.length, 2);
+  assert.strictEqual(tasks[0].checked, true, 'First task should default checked to true');
+  assert.strictEqual(tasks[1].checked, true, 'Second task should default checked to true');
+  assert.strictEqual(tasks[0].description, 'Install deps');
+  assert.strictEqual(tasks[0].command, 'npm install');
+});
+
+test('getDefaultPostConfig preserves checked=false', () => {
+  const config: PtConfig = {
+    version: '3.0',
+    templates: {},
+    default_post_config: [
+      { description: 'Optional step', command: 'echo optional', checked: false },
+      { description: 'Required step', command: 'echo required', checked: true },
+      { description: 'Default step', command: 'echo default' },
+    ],
+  };
+  const tasks = getDefaultPostConfig(config);
+
+  assert.strictEqual(tasks.length, 3);
+  assert.strictEqual(tasks[0].checked, false, 'Explicitly false should stay false');
+  assert.strictEqual(tasks[1].checked, true, 'Explicitly true should stay true');
+  assert.strictEqual(tasks[2].checked, true, 'Undefined checked should default to true');
+});
+
+// ─── DEFAULT_EXCLUDES ────────────────────────────────────────────────────────
+
+test('DEFAULT_EXCLUDES contains expected patterns', () => {
+  assert.ok(Array.isArray(DEFAULT_EXCLUDES), 'DEFAULT_EXCLUDES should be an array');
+  assert.ok(DEFAULT_EXCLUDES.includes('.git'), 'Should include .git');
+  assert.ok(DEFAULT_EXCLUDES.includes('node_modules'), 'Should include node_modules');
+  assert.ok(DEFAULT_EXCLUDES.includes('dist'), 'Should include dist');
+  assert.ok(DEFAULT_EXCLUDES.includes('build'), 'Should include build');
+  assert.ok(DEFAULT_EXCLUDES.includes('.DS_Store'), 'Should include .DS_Store');
+  assert.ok(DEFAULT_EXCLUDES.includes('.vscode'), 'Should include .vscode');
+  assert.ok(DEFAULT_EXCLUDES.includes('Thumbs.db'), 'Should include Thumbs.db');
+});
+
+// ─── shouldExclude ───────────────────────────────────────────────────────────
+
+test('shouldExclude excludes default patterns', () => {
+  const dirPath = '/project';
+  // Each default exclude should be matched by name
+  for (const name of DEFAULT_EXCLUDES) {
+    const fullPath = path.join(dirPath, name);
+    assert.ok(
+      shouldExclude(dirPath, fullPath),
+      `Should exclude "${name}" (default pattern)`
+    );
+  }
+});
+
+test('shouldExclude does NOT exclude normal directories', () => {
+  const dirPath = '/project';
+  const normalDirs = ['src', 'lib', 'tests', 'docs', 'scripts', 'assets', 'public'];
+  for (const name of normalDirs) {
+    const fullPath = path.join(dirPath, name);
+    assert.ok(
+      !shouldExclude(dirPath, fullPath),
+      `Should NOT exclude "${name}"`
+    );
+  }
+});
+
+test('shouldExclude handles custom excludes', () => {
+  const dirPath = '/project';
+  const customExcludes = ['vendor', 'tmp', 'coverage'];
+
+  for (const name of customExcludes) {
+    const fullPath = path.join(dirPath, name);
+    assert.ok(
+      shouldExclude(dirPath, fullPath, customExcludes),
+      `Should exclude custom pattern "${name}"`
+    );
+  }
+
+  // Normal dirs still pass
+  assert.ok(!shouldExclude(dirPath, path.join(dirPath, 'src'), customExcludes));
+});
+
+test('shouldExclude handles git submodules via .gitmodules detection', () => {
+  // Create a temporary project structure with a .gitmodules file
+  const tmpProject = path.join(testHome, '_test_shouldExclude_submodule');
+  const submoduleName = 'my-submodule';
+  const submodulePath = path.join(tmpProject, submoduleName);
+  fs.mkdirSync(submodulePath, { recursive: true });
+
+  // Write a .gitmodules file that references the submodule
+  const gitmodulesContent = `[submodule "${submoduleName}"]\n\tpath = ${submoduleName}\n\turl = https://example.com/repo.git\n`;
+  fs.writeFileSync(path.join(tmpProject, '.gitmodules'), gitmodulesContent);
+
+  // shouldExclude checks for .gitmodules in the parent of fullPath
+  const result = shouldExclude(tmpProject, submodulePath);
+  assert.ok(result, 'Should exclude a git submodule listed in .gitmodules');
+
+  // Non-submodule dir in the same project should NOT be excluded
+  const otherDir = path.join(tmpProject, 'regular-dir');
+  fs.mkdirSync(otherDir, { recursive: true });
+  const otherResult = shouldExclude(tmpProject, otherDir);
+  assert.ok(!otherResult, 'Should NOT exclude a non-submodule directory');
+
+  // Clean up
+  fs.rmSync(tmpProject, { recursive: true, force: true });
+});
+
+test('shouldExclude with empty custom excludes behaves like default only', () => {
+  const dirPath = '/project';
+  assert.ok(shouldExclude(dirPath, path.join(dirPath, 'node_modules'), []));
+  assert.ok(!shouldExclude(dirPath, path.join(dirPath, 'src'), []));
+});
+
+// ─── shouldIgnore ────────────────────────────────────────────────────────────
+
+test('shouldIgnore returns false when no patterns provided', () => {
+  assert.strictEqual(shouldIgnore('src', 'src'), false);
+  assert.strictEqual(shouldIgnore('src', 'src', []), false);
+  assert.strictEqual(shouldIgnore('src', 'src', undefined), false);
+});
+
+test('shouldIgnore deep match with **/FOLDER', () => {
+  assert.ok(
+    shouldIgnore('logs', 'app/data/logs', ['**/logs']),
+    'Should match "logs" at any depth via **/logs'
+  );
+  assert.ok(
+    shouldIgnore('logs', 'logs', ['**/logs']),
+    'Should match "logs" at root via **/logs'
+  );
+  assert.ok(
+    !shouldIgnore('src', 'app/src', ['**/logs']),
+    'Should not match folder named "src" when pattern is **/logs'
+  );
+});
+
+test('shouldIgnore deep match with **/FOLDER/ trailing slash', () => {
+  assert.ok(
+    shouldIgnore('cache', 'deep/nested/cache', ['**/cache/']),
+    'Should match with trailing slash in pattern'
+  );
+});
+
+test('shouldIgnore FOLDER/* wildcard children match', () => {
+  // FOLDER/* should match children of FOLDER, not FOLDER itself
+  assert.ok(
+    shouldIgnore('child', 'DAILIES/child', ['DAILIES/*']),
+    'Should match child inside DAILIES with DAILIES/*'
+  );
+  assert.ok(
+    !shouldIgnore('DAILIES', 'DAILIES', ['DAILIES/*']),
+    'Should NOT match DAILIES itself with DAILIES/*'
+  );
+  assert.ok(
+    shouldIgnore('deep', 'DAILIES/deep', ['DAILIES/*']),
+    'Should match any immediate child of DAILIES'
+  );
+});
+
+test('shouldIgnore FOLDER/** deep wildcard match', () => {
+  assert.ok(
+    shouldIgnore('nested', 'DAILIES/nested', ['DAILIES/**']),
+    'Should match child inside DAILIES with DAILIES/**'
+  );
+  assert.ok(
+    !shouldIgnore('DAILIES', 'DAILIES', ['DAILIES/**']),
+    'Should NOT match DAILIES itself with DAILIES/**'
+  );
+  assert.ok(
+    shouldIgnore('deep', 'DAILIES/deep', ['DAILIES/**']),
+    'Should match deep nested child of DAILIES'
+  );
+});
+
+test('shouldIgnore exact match by name', () => {
+  assert.ok(
+    shouldIgnore('temp', 'temp', ['temp']),
+    'Should match exact folder name'
+  );
+  assert.ok(
+    !shouldIgnore('temporary', 'temporary', ['temp']),
+    'Should NOT match partial folder name'
+  );
+});
+
+test('shouldIgnore exact match by path', () => {
+  assert.ok(
+    shouldIgnore('logs', 'data/logs', ['data/logs']),
+    'Should match exact relative path'
+  );
+  assert.ok(
+    !shouldIgnore('logs', 'other/logs', ['data/logs']),
+    'Should NOT match different path with same name'
+  );
+});
+
+test('shouldIgnore trailing slash handling on exact match', () => {
+  assert.ok(
+    shouldIgnore('temp', 'temp', ['temp/']),
+    'Should match exact name even with trailing slash in pattern'
+  );
+});
+
+test('shouldIgnore returns false for non-matching patterns', () => {
+  const patterns = ['**/cache', 'vendor/*', 'tmp'];
+  assert.strictEqual(shouldIgnore('src', 'src', patterns), false);
+  assert.strictEqual(shouldIgnore('lib', 'project/lib', patterns), false);
+  assert.strictEqual(shouldIgnore('app', 'app', patterns), false);
+});
+
+test('shouldIgnore handles multiple patterns', () => {
+  const patterns = ['**/logs', 'tmp', 'data/*'];
+
+  assert.ok(shouldIgnore('logs', 'deep/logs', patterns), 'Should match **/logs');
+  assert.ok(shouldIgnore('tmp', 'tmp', patterns), 'Should match tmp');
+  assert.ok(shouldIgnore('file', 'data/file', patterns), 'Should match data/*');
+  assert.ok(!shouldIgnore('src', 'src', patterns), 'Should not match src');
+});
+
+// ─── shouldExcludeFile ───────────────────────────────────────────────────────
+
+test('shouldExcludeFile excludes wildcard extension patterns', () => {
+  const wildcardExcludes = [
+    'module.pyc',
+    'cache.pyo',
+    'native.pyd',
+    'info.egg-info',
+    'dist.egg',
+    'dep.whl',
+    'lib.so',
+    'lib.dll',
+    'lib.dylib',
+    'app.exe',
+    'main.o',
+    'archive.a',
+    'static.lib',
+    'Main.class',
+    'app.jar',
+    'app.war',
+    'app.ear',
+    'server.log',
+    'data.tmp',
+    'file.swp',
+    'file.swo',
+    'backup~',
+    'readme.md',
+    'notes.txt',
+    'data.json',
+    'config.yaml',
+    'settings.yml',
+    'setup.ini',
+    'app.conf',
+    'lint.config',
+  ];
+
+  for (const file of wildcardExcludes) {
+    assert.ok(
+      shouldExcludeFile(file),
+      `Should exclude "${file}"`
+    );
+  }
+});
+
+test('shouldExcludeFile excludes exact match files', () => {
+  const exactExcludes = [
+    '.Python',
+    '.bak',
+    '.gitconfig',
+    '.makerc',
+    'Gemfile.lock',
+    'package.json',
+    'package-lock.json',
+    'yarn.lock',
+    'pnpm-lock.yaml',
+    'composer.json',
+    'composer.lock',
+  ];
+
+  for (const file of exactExcludes) {
+    assert.ok(
+      shouldExcludeFile(file),
+      `Should exclude exact match "${file}"`
+    );
+  }
+});
+
+test('shouldExcludeFile does NOT exclude normal source files', () => {
+  const normalFiles = [
+    'index.js',
+    'app.ts',
+    'styles.css',
+    'template.html',
+    'image.png',
+    'photo.jpg',
+    'Dockerfile',
+    'Makefile',
+    'script.sh',
+    'main.go',
+    'lib.rs',
+    'App.vue',
+    'Component.jsx',
+    'handler.py',
+    'server.rb',
+  ];
+
+  for (const file of normalFiles) {
+    assert.ok(
+      !shouldExcludeFile(file),
+      `Should NOT exclude "${file}"`
+    );
+  }
+});
+
+// ─── sanitizePath ────────────────────────────────────────────────────────────
+
+test('sanitizePath removes .. segments', () => {
+  const result = sanitizePath('foo/../bar');
+  assert.strictEqual(result, ['foo', 'bar'].join(path.sep));
+});
+
+test('sanitizePath removes . segments', () => {
+  const result = sanitizePath('foo/./bar');
+  assert.strictEqual(result, ['foo', 'bar'].join(path.sep));
+});
+
+test('sanitizePath removes empty segments', () => {
+  const result = sanitizePath('foo//bar///baz');
+  assert.strictEqual(result, ['foo', 'bar', 'baz'].join(path.sep));
+});
+
+test('sanitizePath handles mixed separators', () => {
+  const result = sanitizePath('foo\\..\\bar/./baz');
+  assert.strictEqual(result, ['foo', 'bar', 'baz'].join(path.sep));
+});
+
+test('sanitizePath normal path passes through', () => {
+  const result = sanitizePath('src/components/App');
+  assert.strictEqual(result, ['src', 'components', 'App'].join(path.sep));
+});
+
+test('sanitizePath strips leading traversal attempts', () => {
+  const result = sanitizePath('../../etc/passwd');
+  assert.strictEqual(result, ['etc', 'passwd'].join(path.sep));
+});
+
+test('sanitizePath handles path with only dots and slashes', () => {
+  const result = sanitizePath('../../../..');
+  assert.strictEqual(result, '');
+});
+
+test('sanitizePath trims whitespace from segments', () => {
+  const result = sanitizePath(' foo / bar / baz ');
+  assert.strictEqual(result, ['foo', 'bar', 'baz'].join(path.sep));
+});
+
+test('sanitizePath returns empty string for empty input', () => {
+  const result = sanitizePath('');
+  assert.strictEqual(result, '');
+});

package/tests/config.test.ts

@@ -2,12 +2,16 @@ import { test, before, after } from 'node:test';
 import assert from 'node:assert';
 import fs from 'fs';
 import path from 'path';
+import os from 'os';
 
 // Force a temporary home directory for testing before importing anything from the CLI
 const testHome = path.join(process.cwd(), '.test-home-config');
-process.env.HOME = testHome;
 
-import { normalizeVariable, saveConfig, loadConfig, PtConfig, CONFIG_PATH } from '../src/config.js';
+// Mock os.homedir() to return the test directory (Node.js doesn't use HOME env var on Linux)
+const originalHomedir = os.homedir;
+os.homedir = () => testHome;
+
+import { normalizeVariable, saveConfig, loadConfig, PtConfig, CONFIG_PATH, HOME_DIR } from '../src/config.js';
 
 test('normalizeVariable key ordering', () => {
   const variableInput = {
@@ -368,10 +372,26 @@ test('saveConfig with empty config file', () => {
   // Create empty config file
   fs.writeFileSync(CONFIG_PATH, '');
   
-  // Try to load - should throw error
-  assert.throws(() => {
+  // loadConfig calls process.exit(1) on error, so we need to mock it
+  // to prevent the test runner from dying
+  let exitCalled = false;
+  let exitCode: number | undefined;
+  const originalExit = process.exit;
+  process.exit = ((code?: number) => {
+    exitCalled = true;
+    exitCode = code;
+    throw new Error('process.exit called');
+  }) as any;
+
+  try {
     loadConfig();
-  }, /Config file is empty/, 'Should throw error for empty config file');
+    assert.fail('loadConfig should have called process.exit');
+  } catch (e) {
+    assert.ok(exitCalled, 'process.exit should have been called');
+    assert.strictEqual(exitCode, 1, 'Should exit with code 1');
+  } finally {
+    process.exit = originalExit;
+  }
 
   // Clean up
   if (fs.existsSync(CONFIG_PATH)) {
@@ -551,7 +571,6 @@ test('loadConfig handles migration from v2.0', () => {
     templates: {
       'test-template': {
         name: 'Test Template',
-        description: 'Test Description',
         type: 'web',
         folders: []
       }
@@ -745,4 +764,15 @@ test('saveConfig preserves existing config when not deleting', () => {
   if (savedConfig) {
     saveConfig(savedConfig);
   }
+});
+
+// Cleanup: restore original os.homedir function and clean up test directory
+after(() => {
+  // Restore original os.homedir function
+  os.homedir = originalHomedir;
+  
+  // Clean up test home directory if it exists
+  if (fs.existsSync(testHome)) {
+    fs.rmdirSync(testHome, { recursive: true });
+  }
 });