slicejs-cli 3.4.0 → 3.5.0

package/tests/helpers/setup.js

@@ -0,0 +1,97 @@
+import fs from 'fs-extra'
+import path from 'path'
+import os from 'os'
+import { fileURLToPath } from 'url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const FW_DIR = path.resolve(__dirname, '../../../slice.js')
+const FIXTURES_DIR = path.resolve(__dirname, '../fixtures')
+
+let counter = 0
+
+export async function createTestProject(options = {}) {
+  const {
+    visualComponents = [],
+    frameworkDir = FW_DIR,
+  } = options
+
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), `slice-test-${process.pid}-${counter++}-`))
+
+  const fwExists = await fs.pathExists(frameworkDir)
+  const srcDir = path.join(dir, 'src')
+
+  if (fwExists) {
+    const fwSrc = path.join(frameworkDir, 'src')
+    const fwApi = path.join(frameworkDir, 'api')
+
+    if (await fs.pathExists(fwSrc)) {
+      await fs.copy(fwSrc, srcDir)
+    }
+    if (await fs.pathExists(fwApi)) {
+      await fs.copy(fwApi, path.join(dir, 'api'))
+    }
+  }
+
+  if (!(await fs.pathExists(srcDir))) {
+    await createMinimalScaffold(dir)
+  }
+
+  await fs.ensureDir(path.join(srcDir, 'Components', 'Visual'))
+
+  if (visualComponents.length > 0) {
+    const registryLines = visualComponents.map(n => `  "${n}": "Visual"`).join(',\n')
+    await fs.writeFile(
+      path.join(srcDir, 'Components', 'components.js'),
+      `const components = {\n${registryLines}\n}; export default components;\n`
+    )
+    for (const name of visualComponents) {
+      const compDir = path.join(srcDir, 'Components', 'Visual', name)
+      await fs.ensureDir(compDir)
+      await fs.writeFile(path.join(compDir, `${name}.js`), `export default class ${name} {}`)
+    }
+  }
+
+  return dir
+}
+
+export async function cleanupTestProject(dir) {
+  await fs.remove(dir)
+}
+
+export async function withTestProject(fn, options = {}) {
+  const dir = await createTestProject(options)
+  const origInitCwd = process.env.INIT_CWD
+  try {
+    process.env.INIT_CWD = dir
+    return await fn(dir)
+  } finally {
+    if (origInitCwd === undefined) {
+      delete process.env.INIT_CWD
+    } else {
+      process.env.INIT_CWD = origInitCwd
+    }
+    await cleanupTestProject(dir)
+  }
+}
+
+async function createMinimalScaffold(dir) {
+  const srcDir = path.join(dir, 'src')
+  await fs.ensureDir(path.join(srcDir, 'App'))
+  await fs.ensureDir(path.join(srcDir, 'Components', 'AppComponents', 'AppShell'))
+  await fs.ensureDir(path.join(srcDir, 'Components', 'Service', 'FetchManager'))
+  await fs.ensureDir(path.join(srcDir, 'Components', 'Visual'))
+  await fs.ensureDir(path.join(srcDir, 'Styles'))
+  await fs.ensureDir(path.join(srcDir, 'Themes'))
+  await fs.ensureDir(path.join(dir, 'api', 'middleware'))
+  await fs.ensureDir(path.join(dir, 'api', 'utils'))
+
+  const fixtureConfig = path.join(FIXTURES_DIR, 'sliceConfig.json')
+  if (await fs.pathExists(fixtureConfig)) {
+    await fs.copy(fixtureConfig, path.join(srcDir, 'sliceConfig.json'))
+  }
+
+  const fixtureComponents = path.join(FIXTURES_DIR, 'components.js')
+  if (await fs.pathExists(fixtureComponents)) {
+    await fs.copy(fixtureComponents, path.join(srcDir, 'Components', 'components.js'))
+  }
+}

package/tests/init-command-contract.test.js

@@ -0,0 +1,46 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const clientPath = path.join(__dirname, '..', 'client.js');
+const source = fs.readFileSync(clientPath, 'utf-8');
+
+test('init command is registered in client.js', () => {
+  const hasInit = source.includes('.command("init")');
+  assert.ok(hasInit, 'client.js must register an "init" command');
+});
+
+test('init command has a description', () => {
+  const match = source.match(/\.command\(["']init["']\)\s*\.description\(["']([^"']+)["']\)/);
+  assert.ok(match, 'init command must have a .description() call');
+  assert.ok(match[1].length > 0, 'init command description must not be empty');
+});
+
+test('init command has -y / --yes option', () => {
+  const hasShort = source.includes('"-y, --yes');
+  assert.ok(hasShort, 'init command must have a -y/--yes option for non-interactive use');
+});
+
+test('init command action calls initializeProject', () => {
+  const hasCall = source.includes('initializeProject()');
+  assert.ok(hasCall, 'init command action must call initializeProject');
+});
+
+test('init command normalizes project name (lowercase, hyphens)', () => {
+  const hasFilter = source.includes('.toLowerCase()');
+  assert.ok(hasFilter, 'init command must normalize project name to lowercase');
+  assert.ok(source.includes('.replace(/\\s+/g'), 'init command must replace spaces with hyphens');
+});
+
+test('init command validates project name', () => {
+  assert.ok(source.includes("'Project name cannot be empty'"), 'init command must validate non-empty name');
+  assert.ok(source.includes("'Use a simple name, not a path'"), 'init command must reject path separators');
+});
+
+test('init command creates project directory', () => {
+  assert.ok(source.includes('fs.mkdirSync(projectDir'), 'init command must create the project directory');
+  assert.ok(source.includes('process.chdir(projectDir)'), 'init command must chdir into project');
+});

package/tests/local-cli-delegation.test.js

@@ -43,20 +43,22 @@ test('findNearestLocalCliEntry returns null when no candidate resolver hits', ()
 });
 
 test('findNearestLocalCliEntry returns first match while traversing upward', () => {
-  const cwd = '/repo/apps/web/src';
+  const cwd = path.resolve('/repo/apps/web/src');
+  const matchDir = path.resolve('/repo/apps/web');
+  const matchResult = path.resolve('/repo/apps/web/node_modules/slicejs-cli/client.js');
   const calls = [];
   const resolver = (dir) => {
     calls.push(dir);
-    if (dir === '/repo/apps/web') {
-      return '/repo/apps/web/node_modules/slicejs-cli/client.js';
+    if (dir === matchDir) {
+      return matchResult;
     }
     return null;
   };
 
   const result = findNearestLocalCliEntry(cwd, resolver);
 
-  assert.equal(result, '/repo/apps/web/node_modules/slicejs-cli/client.js');
-  assert.deepEqual(calls, ['/repo/apps/web/src', '/repo/apps/web']);
+  assert.equal(result, matchResult);
+  assert.deepEqual(calls, [cwd, matchDir]);
 });
 
 test('findNearestLocalCliEntry returns null when resolver is not a function', () => {

package/tests/path-helper.test.js

@@ -0,0 +1,206 @@
+import { test, describe, before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import fs from 'node:fs';
+import { createTestProject, cleanupTestProject } from './helpers/setup.js';
+
+/** @type {string} */
+let tmpRoot;
+const origInitCwd = process.env.INIT_CWD;
+
+before(async () => {
+  tmpRoot = await createTestProject();
+  process.env.INIT_CWD = tmpRoot;
+});
+
+after(async () => {
+  if (origInitCwd === undefined) {
+    delete process.env.INIT_CWD;
+  } else {
+    process.env.INIT_CWD = origInitCwd;
+  }
+  await cleanupTestProject(tmpRoot);
+});
+
+describe('getProjectRoot', () => {
+  test('resolves project root via INIT_CWD when pointing to a real project', async () => {
+    const { getProjectRoot } = await import('../commands/utils/PathHelper.js');
+    const root = getProjectRoot(import.meta.url);
+    assert.ok(root, 'should return a path');
+    assert.ok(fs.existsSync(root), `resolved path should exist: ${root}`);
+    assert.equal(path.resolve(root), path.resolve(tmpRoot));
+  });
+
+  test('resolves project root via cwd when INIT_CWD is not set', async () => {
+    const prev = process.env.INIT_CWD;
+    delete process.env.INIT_CWD;
+    try {
+      const { getProjectRoot } = await import('../commands/utils/PathHelper.js');
+      const root = getProjectRoot(import.meta.url);
+      assert.ok(root, 'should return a path');
+      assert.ok(fs.existsSync(root), `resolved path should exist: ${root}`);
+    } finally {
+      process.env.INIT_CWD = prev;
+    }
+  });
+});
+
+describe('getSrcPath', () => {
+  test('returns src path relative to project root', async () => {
+    const { getSrcPath } = await import('../commands/utils/PathHelper.js');
+    const srcPath = getSrcPath(import.meta.url);
+    assert.ok(srcPath.endsWith('src'), `should end with 'src': ${srcPath}`);
+    assert.ok(fs.existsSync(srcPath), `src path should exist: ${srcPath}`);
+  });
+
+  test('accepts subpath segments', async () => {
+    const { getSrcPath } = await import('../commands/utils/PathHelper.js');
+    const result = getSrcPath(import.meta.url, 'Components', 'components.js');
+    assert.ok(result.endsWith('src/Components/components.js') || result.endsWith('src\\Components\\components.js'));
+    assert.ok(fs.existsSync(result), `file should exist: ${result}`);
+  });
+});
+
+describe('getApiPath', () => {
+  test('returns api path relative to project root', async () => {
+    const { getApiPath } = await import('../commands/utils/PathHelper.js');
+    const apiPath = getApiPath(import.meta.url);
+    assert.ok(apiPath.endsWith('api'), `should end with 'api': ${apiPath}`);
+    assert.ok(fs.existsSync(apiPath), `api path should exist: ${apiPath}`);
+  });
+
+  test('appends subpath to api', async () => {
+    const { getApiPath } = await import('../commands/utils/PathHelper.js');
+    const result = getApiPath(import.meta.url, 'index.js');
+    assert.ok(result.endsWith('api/index.js') || result.endsWith('api\\index.js'));
+  });
+});
+
+describe('getDistPath', () => {
+  test('returns dist path relative to project root', async () => {
+    const { getDistPath } = await import('../commands/utils/PathHelper.js');
+    const distPath = getDistPath(import.meta.url);
+    assert.ok(distPath.endsWith('dist'), `should end with 'dist': ${distPath}`);
+  });
+});
+
+describe('getConfigPath', () => {
+  test('returns sliceConfig.json path', async () => {
+    const { getConfigPath } = await import('../commands/utils/PathHelper.js');
+    const configPath = getConfigPath(import.meta.url);
+    assert.ok(configPath.endsWith('sliceConfig.json'), `should end with 'sliceConfig.json': ${configPath}`);
+    assert.ok(fs.existsSync(configPath), `config file should exist: ${configPath}`);
+  });
+});
+
+describe('getComponentsJsPath', () => {
+  test('returns components.js path', async () => {
+    const { getComponentsJsPath } = await import('../commands/utils/PathHelper.js');
+    const compPath = getComponentsJsPath(import.meta.url);
+    assert.ok(compPath.endsWith('components.js'), `should end with 'components.js': ${compPath}`);
+    assert.ok(fs.existsSync(compPath), `components.js should exist: ${compPath}`);
+  });
+});
+
+describe('getPath', () => {
+  test('joins arbitrary segments to project root', async () => {
+    const { getPath } = await import('../commands/utils/PathHelper.js');
+    const result = getPath(import.meta.url, 'src', 'routes.js');
+    assert.ok(result.endsWith('routes.js'), `should end with 'routes.js': ${result}`);
+    assert.ok(fs.existsSync(result), `routes.js should exist: ${result}`);
+  });
+
+  test('sanitizes leading slashes from segments', async () => {
+    const { getPath } = await import('../commands/utils/PathHelper.js');
+    const result = getPath(import.meta.url, '/src/', '/routes.js');
+    assert.ok(result.endsWith('routes.js'), `should handle sanitized segments: ${result}`);
+  });
+});
+
+describe('resolveProjectRoot (fallback via candidates)', () => {
+  test('uses candidates() when INIT_CWD is not a valid path', async () => {
+    const orig = process.env.INIT_CWD;
+    process.env.INIT_CWD = 'C:\\nonexistent\\path';
+
+    try {
+      const { getProjectRoot } = await import('../commands/utils/PathHelper.js');
+      const root = getProjectRoot(import.meta.url);
+      assert.ok(root, 'should return a path');
+      assert.ok(fs.existsSync(root), `fallback path should exist: ${root}`);
+    } finally {
+      process.env.INIT_CWD = orig;
+    }
+  });
+});
+
+describe('joinRoot', () => {
+  test('joins segments relative to explicit root path', async () => {
+    const { joinRoot } = await import('../commands/utils/PathHelper.js');
+    const root = path.resolve('/test/project');
+    const result = joinRoot(root, 'src', 'components');
+    assert.equal(result, path.join(root, 'src', 'components'));
+  });
+
+  test('sanitizes leading slashes from segments', async () => {
+    const { joinRoot } = await import('../commands/utils/PathHelper.js');
+    const root = path.resolve('/test/project');
+    const result = joinRoot(root, '/src', '/components');
+    assert.equal(result, path.join(root, 'src', 'components'));
+  });
+
+  test('handles single segment', async () => {
+    const { joinRoot } = await import('../commands/utils/PathHelper.js');
+    const root = path.resolve('/test/project');
+    const result = joinRoot(root, 'package.json');
+    assert.equal(result, path.join(root, 'package.json'));
+  });
+
+  test('handles empty segments', async () => {
+    const { joinRoot } = await import('../commands/utils/PathHelper.js');
+    const root = path.resolve('/test/project');
+    const result = joinRoot(root);
+    assert.equal(result, root);
+  });
+});
+
+describe('getConfigPath with explicit root', () => {
+  test('returns sliceConfig.json under explicit root', async () => {
+    const { getConfigPath } = await import('../commands/utils/PathHelper.js');
+    const explicitRoot = path.resolve('/custom/project');
+    const result = getConfigPath(import.meta.url, explicitRoot);
+    assert.equal(result, path.join(explicitRoot, 'src', 'sliceConfig.json'));
+  });
+
+  test('returns sliceConfig.json without root (auto-resolve)', async () => {
+    const { getConfigPath } = await import('../commands/utils/PathHelper.js');
+    const result = getConfigPath(import.meta.url);
+    assert.ok(result.endsWith('sliceConfig.json'));
+    assert.ok(fs.existsSync(result));
+  });
+});
+
+describe('getComponentsJsPath with explicit root', () => {
+  test('returns components.js under explicit root', async () => {
+    const { getComponentsJsPath } = await import('../commands/utils/PathHelper.js');
+    const explicitRoot = path.resolve('/custom/project');
+    const result = getComponentsJsPath(import.meta.url, explicitRoot);
+    assert.equal(result, path.join(explicitRoot, 'src', 'Components', 'components.js'));
+  });
+
+  test('returns components.js without root (auto-resolve)', async () => {
+    const { getComponentsJsPath } = await import('../commands/utils/PathHelper.js');
+    const result = getComponentsJsPath(import.meta.url);
+    assert.ok(result.endsWith('components.js'));
+    assert.ok(fs.existsSync(result));
+  });
+});
+
+describe('getSrcPath integration', () => {
+  test('getSrcPath matches joinRoot with src prefix', async () => {
+    const { getSrcPath, getProjectRoot, joinRoot } = await import('../commands/utils/PathHelper.js');
+    const root = getProjectRoot(import.meta.url);
+    const viaHelper = getSrcPath(import.meta.url, 'Components', 'components.js');
+    const viaJoinRoot = joinRoot(root, 'src', 'Components', 'components.js');
+    assert.equal(viaHelper, viaJoinRoot);
+  });
+});