mirror of
https://github.com/affaan-m/ECC.git
synced 2026-10-14 20:25:26 +02:00
391 lines
14 KiB
JavaScript
391 lines
14 KiB
JavaScript
/**
|
|
* Tests for install.ps1 wrapper delegation
|
|
*/
|
|
|
|
const assert = require('assert');
|
|
const fs = require('fs');
|
|
const os = require('os');
|
|
const path = require('path');
|
|
const { execFileSync, spawnSync } = require('child_process');
|
|
|
|
const SCRIPT = path.join(__dirname, '..', '..', 'install.ps1');
|
|
const PACKAGE_JSON = path.join(__dirname, '..', '..', 'package.json');
|
|
|
|
function createTempDir(prefix) {
|
|
return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
|
|
}
|
|
|
|
function cleanup(dirPath) {
|
|
fs.rmSync(dirPath, { recursive: true, force: true });
|
|
}
|
|
|
|
function normalizePathForOutput(value) {
|
|
const normalized = String(value).replace(/\\/g, '/');
|
|
return process.platform === 'win32' ? normalized.toLowerCase() : normalized;
|
|
}
|
|
|
|
function canonicalizePlannedPath(value) {
|
|
const resolved = path.resolve(String(value).trim());
|
|
const canonicalParent = fs.realpathSync.native(path.dirname(resolved));
|
|
return normalizePathForOutput(path.join(canonicalParent, path.basename(resolved)));
|
|
}
|
|
|
|
function extractInstallRoot(stdout) {
|
|
const match = String(stdout).match(/^Install root:\s*(.+?)\r?$/m);
|
|
assert.ok(match, `dry-run output should include an Install root field:\n${stdout}`);
|
|
return match[1];
|
|
}
|
|
|
|
function resolvePowerShellCommand() {
|
|
const candidates = process.platform === 'win32'
|
|
? ['powershell.exe', 'pwsh.exe', 'pwsh']
|
|
: ['pwsh'];
|
|
|
|
for (const candidate of candidates) {
|
|
const result = spawnSync(candidate, ['-NoLogo', '-NoProfile', '-Command', '$PSVersionTable.PSVersion.ToString()'], {
|
|
encoding: 'utf8',
|
|
stdio: ['pipe', 'pipe', 'pipe'],
|
|
timeout: 5000,
|
|
});
|
|
|
|
if (!result.error && result.status === 0) {
|
|
try {
|
|
const whereCmd = process.platform === 'win32' ? 'where.exe' : 'which';
|
|
const resolved = execFileSync(whereCmd, [candidate], { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] })
|
|
.trim()
|
|
.split(/\r?\n/)[0];
|
|
if (resolved && fs.existsSync(resolved)) {
|
|
return fs.realpathSync.native ? fs.realpathSync.native(resolved) : fs.realpathSync(resolved);
|
|
}
|
|
} catch {
|
|
// fallback to candidate name if resolving full path fails
|
|
}
|
|
return candidate;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
function run(powerShellCommand, args = [], options = {}) {
|
|
const baseEnv = {
|
|
...process.env,
|
|
HOME: options.homeDir || process.env.HOME,
|
|
USERPROFILE: options.homeDir || process.env.USERPROFILE,
|
|
};
|
|
|
|
const env = options.env
|
|
? Object.fromEntries([
|
|
...Object.entries(baseEnv).filter(([k]) => {
|
|
const lowerKey = k.toLowerCase();
|
|
return !Object.keys(options.env).some((overrideKey) => overrideKey.toLowerCase() === lowerKey);
|
|
}),
|
|
...Object.entries(options.env),
|
|
])
|
|
: baseEnv;
|
|
|
|
try {
|
|
const scriptToRun = options.script || SCRIPT;
|
|
const stdout = execFileSync(powerShellCommand, ['-NoLogo', '-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', scriptToRun, ...args], {
|
|
cwd: options.cwd,
|
|
env,
|
|
encoding: 'utf8',
|
|
stdio: ['pipe', 'pipe', 'pipe'],
|
|
timeout: 30000,
|
|
});
|
|
|
|
return { code: 0, stdout, stderr: '' };
|
|
} catch (error) {
|
|
return {
|
|
code: error.status || 1,
|
|
stdout: error.stdout || '',
|
|
stderr: error.stderr || '',
|
|
};
|
|
}
|
|
}
|
|
|
|
function test(name, fn) {
|
|
try {
|
|
fn();
|
|
console.log(` \u2713 ${name}`);
|
|
return true;
|
|
} catch (error) {
|
|
console.log(` \u2717 ${name}`);
|
|
console.log(` Error: ${error.message}`);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function runTests() {
|
|
console.log('\n=== Testing install.ps1 ===\n');
|
|
|
|
let passed = 0;
|
|
let failed = 0;
|
|
const powerShellCommand = resolvePowerShellCommand();
|
|
|
|
if (test('publishes ecc-install through the Node installer runtime for cross-platform npm usage', () => {
|
|
const packageJson = JSON.parse(fs.readFileSync(PACKAGE_JSON, 'utf8'));
|
|
assert.strictEqual(packageJson.bin['ecc-install'], 'scripts/install-apply.js');
|
|
})) passed++; else failed++;
|
|
|
|
if (test('compares planned install roots by canonical path instead of leaf name', () => {
|
|
const fixtureRoot = createTempDir('install-ps1-paths-');
|
|
const expectedProject = path.join(fixtureRoot, 'expected', 'same-project');
|
|
const unrelatedProject = path.join(fixtureRoot, 'unrelated', 'same-project');
|
|
|
|
try {
|
|
fs.mkdirSync(expectedProject, { recursive: true });
|
|
fs.mkdirSync(unrelatedProject, { recursive: true });
|
|
assert.notStrictEqual(
|
|
canonicalizePlannedPath(path.join(expectedProject, '.agents')),
|
|
canonicalizePlannedPath(path.join(unrelatedProject, '.agents'))
|
|
);
|
|
} finally {
|
|
cleanup(fixtureRoot);
|
|
}
|
|
})) passed++; else failed++;
|
|
|
|
if (!powerShellCommand) {
|
|
console.log(' - skipped delegation test; PowerShell is not available in PATH');
|
|
} else if (test('delegates to the Antigravity installer while preserving the project cwd', () => {
|
|
const homeDir = createTempDir('install-ps1-home-');
|
|
const projectDir = createTempDir('install-ps1-project-');
|
|
|
|
try {
|
|
const result = run(powerShellCommand, ['--target', 'antigravity', '--dry-run', 'typescript'], {
|
|
cwd: projectDir,
|
|
homeDir,
|
|
});
|
|
|
|
assert.strictEqual(result.code, 0, result.stderr);
|
|
assert.ok(result.stdout.includes('Dry-run install plan'));
|
|
assert.strictEqual(
|
|
canonicalizePlannedPath(extractInstallRoot(result.stdout)),
|
|
canonicalizePlannedPath(path.join(projectDir, '.agents')),
|
|
`dry-run output should target the project .agents directory:\n${result.stdout}`
|
|
);
|
|
assert.ok(!fs.existsSync(path.join(projectDir, '.agents')));
|
|
} finally {
|
|
cleanup(homeDir);
|
|
cleanup(projectDir);
|
|
}
|
|
})) passed++; else failed++;
|
|
|
|
if (!powerShellCommand) {
|
|
console.log(' - skipped help text test; PowerShell is not available in PATH');
|
|
} else if (test('exposes the corrected Claude target help text', () => {
|
|
const result = run(powerShellCommand, ['--help']);
|
|
assert.strictEqual(result.code, 0, result.stderr);
|
|
assert.ok(
|
|
result.stdout.includes('claude (default) - Install ECC into ~/.claude/'),
|
|
'help text should describe the Claude target as a full ~/.claude install surface'
|
|
);
|
|
})) passed++; else failed++;
|
|
|
|
if (!powerShellCommand) {
|
|
console.log(' - skipped missing Node.js preflight test; PowerShell is not available in PATH');
|
|
} else if (test('rejects execution when Node.js is missing from PATH with actionable message', () => {
|
|
const isolatedDir = createTempDir('install-ps1-no-node-');
|
|
try {
|
|
const pPath = [
|
|
isolatedDir,
|
|
process.env.SystemRoot ? path.join(process.env.SystemRoot, 'System32') : '',
|
|
].filter(Boolean).join(path.delimiter);
|
|
|
|
const result = run(powerShellCommand, ['--help'], {
|
|
env: {
|
|
PATH: pPath,
|
|
SystemRoot: process.env.SystemRoot || 'C:\\Windows',
|
|
},
|
|
});
|
|
|
|
assert.notStrictEqual(result.code, 0, 'installer should fail when node is absent');
|
|
const combinedOutput = `${result.stdout}\n${result.stderr}`;
|
|
assert.ok(
|
|
combinedOutput.includes('[ECC] Node.js is required but was not found in PATH'),
|
|
`error output should explain missing Node.js requirement:\n${combinedOutput}`
|
|
);
|
|
} finally {
|
|
cleanup(isolatedDir);
|
|
}
|
|
})) passed++; else failed++;
|
|
|
|
if (!powerShellCommand) {
|
|
console.log(' - skipped outdated Node.js preflight test; PowerShell is not available in PATH');
|
|
} else if (test('rejects execution when Node.js version is older than 18', () => {
|
|
const UNSUPPORTED_NODE_VERSION = 'v16.20.0';
|
|
const mockBinDir = createTempDir('install-ps1-mock-node-');
|
|
try {
|
|
if (process.platform === 'win32') {
|
|
fs.writeFileSync(path.join(mockBinDir, 'node.cmd'), `@echo ${UNSUPPORTED_NODE_VERSION}\r\n`);
|
|
} else {
|
|
const mockNode = path.join(mockBinDir, 'node');
|
|
fs.writeFileSync(mockNode, `#!/bin/sh\necho ${UNSUPPORTED_NODE_VERSION}\n`);
|
|
fs.chmodSync(mockNode, 0o755);
|
|
}
|
|
|
|
const pPath = [
|
|
mockBinDir,
|
|
process.env.SystemRoot ? path.join(process.env.SystemRoot, 'System32') : '',
|
|
].filter(Boolean).join(path.delimiter);
|
|
|
|
const result = run(powerShellCommand, ['--help'], {
|
|
env: {
|
|
PATH: pPath,
|
|
PATHEXT: process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD',
|
|
SystemRoot: process.env.SystemRoot || 'C:\\Windows',
|
|
},
|
|
});
|
|
|
|
assert.notStrictEqual(result.code, 0, 'installer should fail when node version is < 18');
|
|
const combinedOutput = `${result.stdout}\n${result.stderr}`;
|
|
assert.ok(
|
|
combinedOutput.includes(`[ECC] Node.js 18 or newer is required (found ${UNSUPPORTED_NODE_VERSION})`),
|
|
`error output should explain Node.js version requirement:\n${combinedOutput}`
|
|
);
|
|
} finally {
|
|
cleanup(mockBinDir);
|
|
}
|
|
})) passed++; else failed++;
|
|
|
|
if (!powerShellCommand) {
|
|
console.log(' - skipped unparseable Node.js preflight test; PowerShell is not available in PATH');
|
|
} else if (test('rejects execution when Node.js version is unparseable', () => {
|
|
const INVALID_NODE_VERSION_OUTPUT = 'unexpected-node-output';
|
|
const mockBinDir = createTempDir('install-ps1-invalid-node-');
|
|
try {
|
|
if (process.platform === 'win32') {
|
|
fs.writeFileSync(path.join(mockBinDir, 'node.cmd'), `@echo ${INVALID_NODE_VERSION_OUTPUT}\r\n`);
|
|
} else {
|
|
const mockNode = path.join(mockBinDir, 'node');
|
|
fs.writeFileSync(mockNode, `#!/bin/sh\necho ${INVALID_NODE_VERSION_OUTPUT}\n`);
|
|
fs.chmodSync(mockNode, 0o755);
|
|
}
|
|
|
|
const pPath = [
|
|
mockBinDir,
|
|
path.dirname(powerShellCommand),
|
|
process.env.SystemRoot ? path.join(process.env.SystemRoot, 'System32') : '',
|
|
].filter(Boolean).join(path.delimiter);
|
|
|
|
const result = run(powerShellCommand, ['--help'], {
|
|
env: {
|
|
PATH: pPath,
|
|
PATHEXT: process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD',
|
|
SystemRoot: process.env.SystemRoot || 'C:\\Windows',
|
|
},
|
|
});
|
|
|
|
assert.notStrictEqual(result.code, 0, 'installer should fail when node version is unparseable');
|
|
const combinedOutput = `${result.stdout}\n${result.stderr}`;
|
|
assert.ok(
|
|
combinedOutput.includes(`Failed to determine Node.js version (found '${INVALID_NODE_VERSION_OUTPUT}')`),
|
|
`error output should explain unparseable Node.js version:\n${combinedOutput}`
|
|
);
|
|
} finally {
|
|
cleanup(mockBinDir);
|
|
}
|
|
})) passed++; else failed++;
|
|
|
|
if (!powerShellCommand) {
|
|
console.log(' - skipped missing npm preflight test; PowerShell is not available in PATH');
|
|
} else if (test('rejects execution when node_modules is missing and npm is absent from PATH', () => {
|
|
const isolatedDir = createTempDir('install-ps1-no-npm-');
|
|
const mockBinDir = createTempDir('install-ps1-mock-node-');
|
|
try {
|
|
const tempScript = path.join(isolatedDir, 'install.ps1');
|
|
fs.copyFileSync(SCRIPT, tempScript);
|
|
|
|
const VALID_NODE_VERSION = 'v18.0.0';
|
|
if (process.platform === 'win32') {
|
|
fs.writeFileSync(path.join(mockBinDir, 'node.cmd'), `@echo ${VALID_NODE_VERSION}\r\n`);
|
|
} else {
|
|
const mockNode = path.join(mockBinDir, 'node');
|
|
fs.writeFileSync(mockNode, `#!/bin/sh\necho ${VALID_NODE_VERSION}\n`);
|
|
fs.chmodSync(mockNode, 0o755);
|
|
}
|
|
|
|
const pPath = [
|
|
mockBinDir,
|
|
path.dirname(powerShellCommand),
|
|
process.env.SystemRoot ? path.join(process.env.SystemRoot, 'System32') : '',
|
|
].filter(Boolean).join(path.delimiter);
|
|
|
|
const result = run(powerShellCommand, ['--help'], {
|
|
script: tempScript,
|
|
env: {
|
|
PATH: pPath,
|
|
PATHEXT: process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD',
|
|
SystemRoot: process.env.SystemRoot || 'C:\\Windows',
|
|
},
|
|
});
|
|
|
|
assert.notStrictEqual(result.code, 0, 'installer should fail when node_modules is absent and npm is missing');
|
|
const combinedOutput = `${result.stdout}\n${result.stderr}`;
|
|
assert.ok(
|
|
combinedOutput.includes('[ECC] npm is required to install dependencies but was not found in PATH'),
|
|
`error output should explain missing npm requirement:\n${combinedOutput}`
|
|
);
|
|
} finally {
|
|
cleanup(mockBinDir);
|
|
cleanup(isolatedDir);
|
|
}
|
|
})) passed++; else failed++;
|
|
|
|
if (!powerShellCommand) {
|
|
console.log(' - skipped npm install failure test; PowerShell is not available in PATH');
|
|
} else if (test('propagates exit code and error when npm install fails', () => {
|
|
const isolatedDir = createTempDir('install-ps1-npm-fail-');
|
|
const mockBinDir = createTempDir('install-ps1-mock-bin-');
|
|
try {
|
|
const tempScript = path.join(isolatedDir, 'install.ps1');
|
|
fs.copyFileSync(SCRIPT, tempScript);
|
|
|
|
const VALID_NODE_VERSION = 'v18.0.0';
|
|
const NPM_FAILURE_CODE = 42;
|
|
if (process.platform === 'win32') {
|
|
fs.writeFileSync(path.join(mockBinDir, 'node.cmd'), `@echo ${VALID_NODE_VERSION}\r\n`);
|
|
fs.writeFileSync(path.join(mockBinDir, 'npm.cmd'), `@exit /b ${NPM_FAILURE_CODE}\r\n`);
|
|
} else {
|
|
const mockNode = path.join(mockBinDir, 'node');
|
|
fs.writeFileSync(mockNode, `#!/bin/sh\necho ${VALID_NODE_VERSION}\n`);
|
|
fs.chmodSync(mockNode, 0o755);
|
|
|
|
const mockNpm = path.join(mockBinDir, 'npm');
|
|
fs.writeFileSync(mockNpm, `#!/bin/sh\nexit ${NPM_FAILURE_CODE}\n`);
|
|
fs.chmodSync(mockNpm, 0o755);
|
|
}
|
|
|
|
const pPath = [
|
|
mockBinDir,
|
|
path.dirname(powerShellCommand),
|
|
process.env.SystemRoot ? path.join(process.env.SystemRoot, 'System32') : '',
|
|
].filter(Boolean).join(path.delimiter);
|
|
|
|
const result = run(powerShellCommand, ['--help'], {
|
|
script: tempScript,
|
|
env: {
|
|
PATH: pPath,
|
|
PATHEXT: process.env.PATHEXT || '.COM;.EXE;.BAT;.CMD',
|
|
SystemRoot: process.env.SystemRoot || 'C:\\Windows',
|
|
},
|
|
});
|
|
|
|
assert.strictEqual(result.code, NPM_FAILURE_CODE, 'installer should propagate npm install exit code');
|
|
const combinedOutput = `${result.stdout}\n${result.stderr}`;
|
|
assert.ok(
|
|
combinedOutput.includes(`npm install failed with exit code ${NPM_FAILURE_CODE}`),
|
|
`error output should report npm install failure:\n${combinedOutput}`
|
|
);
|
|
} finally {
|
|
cleanup(mockBinDir);
|
|
cleanup(isolatedDir);
|
|
}
|
|
})) passed++; else failed++;
|
|
|
|
console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
|
|
process.exit(failed > 0 ? 1 : 0);
|
|
}
|
|
|
|
runTests();
|