slicejs-cli 3.5.1 → 3.6.1

package/tests/path-helper.test.js

@@ -1,206 +0,0 @@
-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);
-  });
-});

package/tests/perf-budget.test.js

@@ -1,86 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import fs from 'fs-extra';
-import { createTestProject, cleanupTestProject } from './helpers/setup.js';
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-const FIXTURES = path.resolve(__dirname, 'e2e/fixtures/components');
-const FW_PKG = path.resolve(__dirname, '../node_modules/slicejs-web-framework');
-
-// Performance budgets for the realistic starter app (App Shell + the vendored
-// starter components). Bundle byte sizes are fully deterministic, so a surprise
-// failure here means a change degraded the output — review it, and only bump a
-// budget when the growth is intentional. (Actuals shown for reference.)
-const BUDGET = {
-  bundleCount: 5, //            actual: 4
-  totalBundleBytes: 165_000, // actual: ~133.6 KB
-  criticalBytes: 51_200, //     actual: ~40.8 KB (bundler's own critical cap is 50 KB)
-  frameworkBytes: 85_000, //    actual: ~67.4 KB (tracks the slicejs-web-framework package)
-  buildMs: 30_000, //           actual: ~1 s — generous ceiling to catch pathological slowdowns
-};
-
-async function assembleAndBuild() {
-  process.env.NODE_ENV = 'production';
-  const app = await createTestProject();
-
-  await fs.ensureDir(path.join(app, 'node_modules'));
-  await fs
-    .ensureSymlink(FW_PKG, path.join(app, 'node_modules', 'slicejs-web-framework'), 'dir')
-    .catch(() => fs.copy(FW_PKG, path.join(app, 'node_modules', 'slicejs-web-framework')));
-
-  await fs.copy(path.join(FIXTURES, 'Visual'), path.join(app, 'src', 'Components', 'Visual'));
-  await fs.copy(path.join(FIXTURES, 'Service'), path.join(app, 'src', 'Components', 'Service'));
-
-  process.env.INIT_CWD = app;
-  (await import('../commands/listComponents/listComponents.js')).default();
-
-  const build = (await import('../commands/build/build.js')).default;
-  const start = Date.now();
-  const ok = await build({ minify: true, obfuscate: true });
-  const buildMs = Date.now() - start;
-  assert.equal(ok, true, 'build should succeed');
-  return { app, buildMs };
-}
-
-test('production build stays within performance budgets', async () => {
-  const { app, buildMs } = await assembleAndBuild();
-  try {
-    const bundlesDir = path.join(app, 'dist', 'bundles');
-    const files = (await fs.readdir(bundlesDir)).filter(
-      (f) => f.startsWith('slice-bundle.') && f.endsWith('.js')
-    );
-
-    const sizes = {};
-    let totalBundleBytes = 0;
-    for (const f of files) {
-      sizes[f] = (await fs.stat(path.join(bundlesDir, f))).size;
-      totalBundleBytes += sizes[f];
-    }
-    const cfg = await fs.readJson(path.join(bundlesDir, 'bundle.config.json'));
-    const criticalBytes = sizes['slice-bundle.critical.js'] || 0;
-    const frameworkBytes = sizes['slice-bundle.framework.js'] || 0;
-
-    // Always print the metrics so trends are visible even on a passing run.
-    console.log(
-      `\n  [perf] bundles=${files.length} total=${Math.round(totalBundleBytes / 1024)}KB ` +
-        `critical=${Math.round(criticalBytes / 1024)}KB framework=${Math.round(frameworkBytes / 1024)}KB ` +
-        `requestReduction=${100 - Math.round((files.length / cfg.stats.totalComponents) * 100)}% build=${buildMs}ms`
-    );
-
-    assert.ok(files.length <= BUDGET.bundleCount, `bundle count ${files.length} exceeds budget ${BUDGET.bundleCount}`);
-    assert.ok(
-      totalBundleBytes <= BUDGET.totalBundleBytes,
-      `total bundle bytes ${totalBundleBytes} exceeds budget ${BUDGET.totalBundleBytes}`
-    );
-    assert.ok(criticalBytes <= BUDGET.criticalBytes, `critical bundle ${criticalBytes} exceeds budget ${BUDGET.criticalBytes}`);
-    assert.ok(frameworkBytes <= BUDGET.frameworkBytes, `framework bundle ${frameworkBytes} exceeds budget ${BUDGET.frameworkBytes}`);
-    assert.ok(buildMs <= BUDGET.buildMs, `build took ${buildMs}ms, over budget ${BUDGET.buildMs}ms`);
-
-    // Sanity: the realistic app actually bundled its full component set.
-    assert.ok(cfg.stats.totalComponents >= 20, `unexpectedly few components bundled: ${cfg.stats.totalComponents}`);
-  } finally {
-    await cleanupTestProject(app);
-  }
-});

package/tests/postinstall-command.test.js

@@ -1,72 +0,0 @@
-import { test, describe } 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('postinstall command is registered in client.js', () => {
-  const hasSetupCommand = source.includes('.command("postinstall")');
-  assert.ok(hasSetupCommand, 'client.js must register a "postinstall" command');
-});
-
-test('postinstall command has a description', () => {
-  const match = source.match(/\.command\(["']postinstall["']\)\s*\.description\(["']([^"']+)["']\)/);
-  assert.ok(match, 'postinstall command must have a .description() call');
-  assert.ok(match[1].length > 0, 'postinstall command description must not be empty');
-});
-
-test('postinstall command checks npm_config_global environment variable', () => {
-  const hasGlobalCheck = source.includes('npm_config_global');
-  assert.ok(hasGlobalCheck, 'postinstall command must check npm_config_global to detect global installation');
-});
-
-test('postinstall command prints global install warning', () => {
-  const hasGlobalWarning = source.includes('Global installation');
-  assert.ok(hasGlobalWarning, 'postinstall command must warn about global installation');
-});
-
-test('postinstall command prints local install success message', () => {
-  const hasSuccessMsg = source.includes('installed successfully');
-  assert.ok(hasSuccessMsg, 'postinstall command must show success message for local installs');
-});
-
-test('postinstall command uses getProjectRoot from PathHelper', () => {
-  const hasPathHelper = source.includes("getProjectRoot(import.meta.url)");
-  assert.ok(hasPathHelper, 'postinstall command must use getProjectRoot resolver');
-});
-
-test('postinstall command writes npm scripts to package.json via fs', () => {
-  const hasFsWrite = source.includes('writeFileSync(pkgPath');
-  assert.ok(hasFsWrite, 'postinstall command must write scripts to package.json');
-});
-
-test('postinstall command writes slice:dev script to package.json', () => {
-  const hasDevScript = source.includes("'slice:dev': 'slice dev'");
-  assert.ok(hasDevScript, 'postinstall command must add "slice:dev" script to package.json');
-});
-
-test('postinstall command writes all slice:* scripts to package.json', () => {
-  const scripts = [
-    'slice:dev', 'slice:start', 'slice:create', 'slice:list',
-    'slice:delete', 'slice:init', 'slice:get', 'slice:browse',
-    'slice:sync', 'slice:version', 'slice:update'
-  ];
-  for (const script of scripts) {
-    assert.ok(source.includes(script), `postinstall command must configure ${script} script`);
-  }
-});
-
-test('postinstall command action is a function', () => {
-  const SetupActionPattern = /\.command\(["']postinstall["']\)[\s\S]*?\.action\(\(\)\s*=>\s*\{[\s\S]*?\}\)/;
-  const match = source.match(SetupActionPattern);
-  assert.ok(match, 'postinstall command must have an .action() with arrow function');
-});
-
-test('postinstall command provides npm uninstall -g instruction for global installs', () => {
-  const hasUninstallInstruction = source.includes('npm uninstall -g slicejs-cli');
-  assert.ok(hasUninstallInstruction, 'postinstall command must tell users how to uninstall global CLI');
-});