mirror of
https://github.com/affaan-m/ECC.git
synced 2026-10-14 12:15:29 +02:00
666 lines
22 KiB
JavaScript
666 lines
22 KiB
JavaScript
/**
|
|
* Tests for scripts/auto-update.js
|
|
*/
|
|
|
|
const assert = require('assert');
|
|
const fs = require('fs');
|
|
const os = require('os');
|
|
const path = require('path');
|
|
const { execFileSync } = require('child_process');
|
|
const { LOCALE_ALIAS_TO_COMPONENT_ID } = require('../../scripts/lib/install-manifests');
|
|
const { normalizeInstallRequest, parseInstallArgs } = require('../../scripts/lib/install/request');
|
|
|
|
const {
|
|
parseArgs,
|
|
deriveRepoRootFromState,
|
|
buildInstallApplyArgs,
|
|
determineInstallCwd,
|
|
runAutoUpdate,
|
|
} = require('../../scripts/auto-update');
|
|
const {
|
|
createInstallState,
|
|
} = require('../../scripts/lib/install-state');
|
|
|
|
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 createTempDir(prefix) {
|
|
return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
|
|
}
|
|
|
|
function cleanup(dirPath) {
|
|
fs.rmSync(dirPath, { recursive: true, force: true });
|
|
}
|
|
|
|
function makeRecord({ repoRoot, homeDir, projectRoot, adapter, request, resolution, operations }) {
|
|
const targetRoot = adapter.kind === 'project'
|
|
? path.join(projectRoot, `.${adapter.target}`)
|
|
: path.join(homeDir, '.claude');
|
|
const installStatePath = adapter.kind === 'project'
|
|
? path.join(targetRoot, 'ecc-install-state.json')
|
|
: path.join(targetRoot, 'ecc', 'install-state.json');
|
|
|
|
const state = createInstallState({
|
|
adapter,
|
|
targetRoot,
|
|
installStatePath,
|
|
request,
|
|
resolution,
|
|
operations,
|
|
source: {
|
|
repoVersion: '1.10.0',
|
|
repoCommit: 'abc123',
|
|
manifestVersion: 1,
|
|
},
|
|
});
|
|
|
|
return {
|
|
adapter,
|
|
targetRoot,
|
|
installStatePath,
|
|
exists: true,
|
|
state,
|
|
error: null,
|
|
repoRoot,
|
|
};
|
|
}
|
|
|
|
function ensureFakeRepo(repoRoot) {
|
|
fs.mkdirSync(path.join(repoRoot, 'scripts'), { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(repoRoot, 'package.json'),
|
|
JSON.stringify({ name: 'everything-claude-code', version: '1.10.0' }, null, 2)
|
|
);
|
|
fs.writeFileSync(path.join(repoRoot, 'scripts', 'install-apply.js'), '#!/usr/bin/env node\n');
|
|
}
|
|
|
|
function runTests() {
|
|
console.log('\n=== Testing auto-update.js ===\n');
|
|
|
|
let passed = 0;
|
|
let failed = 0;
|
|
|
|
if (test('parseArgs reads repo-root, target, dry-run, and json flags', () => {
|
|
const parsed = parseArgs([
|
|
'node',
|
|
'scripts/auto-update.js',
|
|
'--target',
|
|
'cursor',
|
|
'--repo-root',
|
|
'/tmp/ecc',
|
|
'--dry-run',
|
|
'--json',
|
|
]);
|
|
|
|
assert.deepStrictEqual(parsed.targets, ['cursor']);
|
|
assert.strictEqual(parsed.repoRoot, '/tmp/ecc');
|
|
assert.strictEqual(parsed.dryRun, true);
|
|
assert.strictEqual(parsed.json, true);
|
|
})) passed += 1; else failed += 1;
|
|
|
|
if (test('parseArgs rejects unknown arguments', () => {
|
|
assert.throws(
|
|
() => parseArgs(['node', 'scripts/auto-update.js', '--bogus']),
|
|
/Unknown argument: --bogus/
|
|
);
|
|
})) passed += 1; else failed += 1;
|
|
|
|
if (test('deriveRepoRootFromState uses sourcePath and sourceRelativePath', () => {
|
|
const state = {
|
|
operations: [
|
|
{
|
|
sourcePath: path.join('/tmp', 'ecc', 'scripts', 'setup-package-manager.js'),
|
|
sourceRelativePath: path.join('scripts', 'setup-package-manager.js'),
|
|
},
|
|
],
|
|
};
|
|
|
|
assert.strictEqual(
|
|
deriveRepoRootFromState(state),
|
|
path.resolve(path.join('/tmp', 'ecc'))
|
|
);
|
|
})) passed += 1; else failed += 1;
|
|
|
|
if (test('deriveRepoRootFromState fails when source metadata is unavailable', () => {
|
|
assert.throws(
|
|
() => deriveRepoRootFromState({ operations: [{ destinationPath: '/tmp/file' }] }),
|
|
/Unable to infer ECC repo root/
|
|
);
|
|
})) passed += 1; else failed += 1;
|
|
|
|
if (test('buildInstallApplyArgs reconstructs legacy installs', () => {
|
|
const record = {
|
|
adapter: { target: 'claude', kind: 'home' },
|
|
state: {
|
|
target: { target: 'claude' },
|
|
request: {
|
|
profile: null,
|
|
modules: [],
|
|
includeComponents: [],
|
|
excludeComponents: [],
|
|
legacyLanguages: ['typescript', 'python'],
|
|
legacyMode: true,
|
|
},
|
|
},
|
|
};
|
|
|
|
assert.deepStrictEqual(buildInstallApplyArgs(record), [
|
|
'--target', 'claude',
|
|
'typescript',
|
|
'python',
|
|
]);
|
|
})) passed += 1; else failed += 1;
|
|
|
|
if (test('replays every locale alias with legacy languages and hook consent', () => {
|
|
for (const target of ['claude', 'claude-project']) {
|
|
for (const [alias, componentId] of Object.entries(LOCALE_ALIAS_TO_COMPONENT_ID)) {
|
|
const original = normalizeInstallRequest(parseInstallArgs([
|
|
'node', 'install-apply.js', '--target', target,
|
|
'--locale', alias, 'typescript', 'python', '--no-hooks',
|
|
]));
|
|
const record = makeRecord({
|
|
repoRoot: '/tmp/ecc', homeDir: '/tmp/home', projectRoot: '/tmp/project',
|
|
adapter: { id: target, target, kind: target === 'claude' ? 'home' : 'project' },
|
|
request: {
|
|
profile: original.profileId, modules: original.moduleIds,
|
|
includeComponents: original.includeComponentIds,
|
|
excludeComponents: original.excludeComponentIds,
|
|
legacyLanguages: original.legacyLanguages,
|
|
legacyMode: true, hookConsent: original.hookConsent,
|
|
},
|
|
resolution: { selectedModules: [], skippedModules: [] }, operations: [],
|
|
});
|
|
const replay = normalizeInstallRequest(parseInstallArgs([
|
|
'node', 'install-apply.js', ...buildInstallApplyArgs(record),
|
|
]));
|
|
assert.deepStrictEqual(replay, original, `${target}: ${alias} -> ${componentId}`);
|
|
}
|
|
}
|
|
})) passed += 1; else failed += 1;
|
|
|
|
for (const target of ['claude', 'claude-project']) {
|
|
if (test(`end-to-end: auto-update plans a recorded ${target} locale and language install`, () => {
|
|
const fixture = createTempDir('auto-update-locale-');
|
|
const homeDir = path.join(fixture, 'home');
|
|
const projectRoot = path.join(fixture, 'project');
|
|
const repoRoot = path.resolve(__dirname, '..', '..');
|
|
const env = { ...process.env, HOME: homeDir, USERPROFILE: homeDir, ECC_DRY_RUN: '0' };
|
|
fs.mkdirSync(homeDir);
|
|
fs.mkdirSync(projectRoot);
|
|
try {
|
|
const installed = JSON.parse(execFileSync(process.execPath, [
|
|
path.join(repoRoot, 'scripts', 'install-apply.js'),
|
|
'--target', target, '--locale', 'zh', 'typescript', '--no-hooks', '--json',
|
|
], { cwd: projectRoot, env, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 }));
|
|
assert.strictEqual(installed.result.applied, true);
|
|
const statePath = installed.result.installStatePath;
|
|
const stateBefore = fs.readFileSync(statePath, 'utf8');
|
|
const state = JSON.parse(stateBefore);
|
|
assert.deepStrictEqual(state.request.includeComponents, ['locale:zh-cn']);
|
|
assert.deepStrictEqual(state.request.legacyLanguages, ['typescript']);
|
|
|
|
const updated = JSON.parse(execFileSync(process.execPath, [
|
|
path.join(repoRoot, 'scripts', 'auto-update.js'), '--target', target,
|
|
'--repo-root', repoRoot, '--dry-run', '--json',
|
|
], { cwd: projectRoot, env, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 }));
|
|
assert.strictEqual(updated.summary.errorCount, 0);
|
|
assert.strictEqual(updated.summary.checkedCount, 1);
|
|
assert.strictEqual(updated.results[0].status, 'planned');
|
|
const plan = updated.results[0].payload.plan;
|
|
assert.strictEqual(plan.mode, 'legacy-compat');
|
|
assert.deepStrictEqual(plan.legacyLanguages, ['typescript']);
|
|
assert.deepStrictEqual(plan.includedComponentIds, ['locale:zh-cn']);
|
|
assert.ok(plan.selectedModuleIds.includes('docs-zh-cn'));
|
|
assert.ok(plan.selectedModuleIds.includes('framework-language'));
|
|
assert.ok(!plan.selectedModuleIds.includes('hooks-runtime'));
|
|
assert.strictEqual(plan.statePreview.request.hookConsent, 'declined');
|
|
assert.strictEqual(fs.readFileSync(statePath, 'utf8'), stateBefore);
|
|
} finally {
|
|
cleanup(fixture);
|
|
}
|
|
})) passed += 1; else failed += 1;
|
|
}
|
|
|
|
if (test('buildInstallApplyArgs reconstructs manifest installs', () => {
|
|
const record = {
|
|
adapter: { target: 'cursor', kind: 'project' },
|
|
state: {
|
|
target: { target: 'cursor' },
|
|
request: {
|
|
profile: 'developer',
|
|
modules: ['platform-configs'],
|
|
includeComponents: ['component:alpha'],
|
|
excludeComponents: ['component:beta'],
|
|
legacyLanguages: [],
|
|
legacyMode: false,
|
|
hookConsent: 'declined',
|
|
},
|
|
},
|
|
};
|
|
|
|
assert.deepStrictEqual(buildInstallApplyArgs(record), [
|
|
'--target', 'cursor',
|
|
'--profile', 'developer',
|
|
'--modules', 'platform-configs',
|
|
'--with', 'component:alpha',
|
|
'--without', 'component:beta',
|
|
'--no-hooks',
|
|
]);
|
|
})) passed += 1; else failed += 1;
|
|
|
|
if (test('buildInstallApplyArgs infers enabled hooks for older install-state records', () => {
|
|
const record = {
|
|
adapter: { target: 'cursor', kind: 'project' },
|
|
state: {
|
|
target: { target: 'cursor' },
|
|
request: {
|
|
profile: 'core',
|
|
modules: [],
|
|
includeComponents: [],
|
|
excludeComponents: [],
|
|
legacyLanguages: [],
|
|
legacyMode: false,
|
|
},
|
|
resolution: {
|
|
selectedModules: ['rules-core', 'hooks-runtime'],
|
|
skippedModules: [],
|
|
},
|
|
operations: [
|
|
{
|
|
kind: 'copy-file',
|
|
moduleId: 'hooks-runtime',
|
|
sourceRelativePath: '.cursor/hooks.json',
|
|
destinationPath: '/tmp/project/.cursor/hooks.json',
|
|
},
|
|
],
|
|
},
|
|
};
|
|
|
|
assert.deepStrictEqual(buildInstallApplyArgs(record), [
|
|
'--target', 'cursor',
|
|
'--profile', 'core',
|
|
'--enable-hooks',
|
|
]);
|
|
})) passed += 1; else failed += 1;
|
|
|
|
if (test('determineInstallCwd uses the project root for project installs', () => {
|
|
const record = {
|
|
adapter: { kind: 'project' },
|
|
state: {
|
|
target: {
|
|
root: path.join('/tmp', 'project', '.cursor'),
|
|
},
|
|
},
|
|
};
|
|
|
|
assert.strictEqual(determineInstallCwd(record, '/tmp/ecc'), path.join('/tmp', 'project'));
|
|
})) passed += 1; else failed += 1;
|
|
|
|
if (test('runAutoUpdate reports when no install-state files are present', () => {
|
|
const result = runAutoUpdate(
|
|
{
|
|
homeDir: '/tmp/home',
|
|
projectRoot: '/tmp/project',
|
|
dryRun: true,
|
|
},
|
|
{
|
|
discoverInstalledStates: () => [],
|
|
}
|
|
);
|
|
|
|
assert.strictEqual(result.results.length, 0);
|
|
assert.strictEqual(result.summary.checkedCount, 0);
|
|
assert.strictEqual(result.summary.errorCount, 0);
|
|
})) passed += 1; else failed += 1;
|
|
|
|
if (test('runAutoUpdate rejects mixed inferred repo roots', () => {
|
|
const homeDir = createTempDir('auto-update-home-');
|
|
const projectRoot = createTempDir('auto-update-project-');
|
|
const repoOne = createTempDir('auto-update-repo-');
|
|
const repoTwo = createTempDir('auto-update-repo-');
|
|
|
|
try {
|
|
ensureFakeRepo(repoOne);
|
|
ensureFakeRepo(repoTwo);
|
|
|
|
const records = [
|
|
makeRecord({
|
|
repoRoot: repoOne,
|
|
homeDir,
|
|
projectRoot,
|
|
adapter: { id: 'claude-home', target: 'claude', kind: 'home' },
|
|
request: {
|
|
profile: null,
|
|
modules: [],
|
|
includeComponents: [],
|
|
excludeComponents: [],
|
|
legacyLanguages: ['typescript'],
|
|
legacyMode: true,
|
|
},
|
|
resolution: { selectedModules: ['legacy-claude-rules'], skippedModules: [] },
|
|
operations: [
|
|
{
|
|
kind: 'copy-file',
|
|
moduleId: 'legacy-claude-rules',
|
|
sourcePath: path.join(repoOne, 'rules', 'common', 'coding-style.md'),
|
|
sourceRelativePath: path.join('rules', 'common', 'coding-style.md'),
|
|
destinationPath: path.join(homeDir, '.claude', 'rules', 'common', 'coding-style.md'),
|
|
strategy: 'preserve-relative-path',
|
|
ownership: 'managed',
|
|
scaffoldOnly: false,
|
|
},
|
|
],
|
|
}),
|
|
makeRecord({
|
|
repoRoot: repoTwo,
|
|
homeDir,
|
|
projectRoot,
|
|
adapter: { id: 'cursor-project', target: 'cursor', kind: 'project' },
|
|
request: {
|
|
profile: 'core',
|
|
modules: [],
|
|
includeComponents: [],
|
|
excludeComponents: [],
|
|
legacyLanguages: [],
|
|
legacyMode: false,
|
|
},
|
|
resolution: { selectedModules: ['rules-core'], skippedModules: [] },
|
|
operations: [
|
|
{
|
|
kind: 'copy-file',
|
|
moduleId: 'rules-core',
|
|
sourcePath: path.join(repoTwo, '.cursor', 'mcp.json'),
|
|
sourceRelativePath: path.join('.cursor', 'mcp.json'),
|
|
destinationPath: path.join(projectRoot, '.cursor', 'mcp.json'),
|
|
strategy: 'sync-root-children',
|
|
ownership: 'managed',
|
|
scaffoldOnly: false,
|
|
},
|
|
],
|
|
}),
|
|
];
|
|
|
|
assert.throws(
|
|
() => runAutoUpdate(
|
|
{
|
|
homeDir,
|
|
projectRoot,
|
|
dryRun: true,
|
|
},
|
|
{
|
|
discoverInstalledStates: () => records,
|
|
}
|
|
),
|
|
/Multiple ECC repo roots detected/
|
|
);
|
|
} finally {
|
|
cleanup(homeDir);
|
|
cleanup(projectRoot);
|
|
cleanup(repoOne);
|
|
cleanup(repoTwo);
|
|
}
|
|
})) passed += 1; else failed += 1;
|
|
|
|
if (test('runAutoUpdate fetches, pulls, and reinstalls using reconstructed args', () => {
|
|
const homeDir = createTempDir('auto-update-home-');
|
|
const projectRoot = createTempDir('auto-update-project-');
|
|
const repoRoot = createTempDir('auto-update-repo-');
|
|
|
|
try {
|
|
ensureFakeRepo(repoRoot);
|
|
|
|
const records = [
|
|
makeRecord({
|
|
repoRoot,
|
|
homeDir,
|
|
projectRoot,
|
|
adapter: { id: 'cursor-project', target: 'cursor', kind: 'project' },
|
|
request: {
|
|
profile: 'developer',
|
|
modules: [],
|
|
includeComponents: ['component:alpha'],
|
|
excludeComponents: ['component:beta'],
|
|
legacyLanguages: [],
|
|
legacyMode: false,
|
|
},
|
|
resolution: { selectedModules: ['rules-core'], skippedModules: [] },
|
|
operations: [
|
|
{
|
|
kind: 'copy-file',
|
|
moduleId: 'platform-configs',
|
|
sourcePath: path.join(repoRoot, '.cursor', 'mcp.json'),
|
|
sourceRelativePath: path.join('.cursor', 'mcp.json'),
|
|
destinationPath: path.join(projectRoot, '.cursor', 'mcp.json'),
|
|
strategy: 'sync-root-children',
|
|
ownership: 'managed',
|
|
scaffoldOnly: false,
|
|
},
|
|
],
|
|
}),
|
|
];
|
|
|
|
const commands = [];
|
|
const result = runAutoUpdate(
|
|
{
|
|
homeDir,
|
|
projectRoot,
|
|
dryRun: false,
|
|
},
|
|
{
|
|
discoverInstalledStates: () => records,
|
|
runExternalCommand: (command, args, options) => {
|
|
commands.push({ command, args, options });
|
|
if (command === process.execPath) {
|
|
return {
|
|
stdout: JSON.stringify({
|
|
dryRun: false,
|
|
result: {
|
|
installStatePath: path.join(projectRoot, '.cursor', 'ecc-install-state.json'),
|
|
},
|
|
}),
|
|
stderr: '',
|
|
};
|
|
}
|
|
|
|
return { stdout: '', stderr: '' };
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.strictEqual(result.summary.checkedCount, 1);
|
|
assert.strictEqual(result.summary.updatedCount, 1);
|
|
assert.deepStrictEqual(commands.map(entry => [entry.command, entry.args[0]]), [
|
|
['git', 'fetch'],
|
|
['git', 'pull'],
|
|
[process.execPath, path.join(repoRoot, 'scripts', 'install-apply.js')],
|
|
]);
|
|
assert.deepStrictEqual(commands[2].args.slice(1), [
|
|
'--target', 'cursor',
|
|
'--profile', 'developer',
|
|
'--with', 'component:alpha',
|
|
'--without', 'component:beta',
|
|
'--json',
|
|
]);
|
|
assert.strictEqual(commands[2].options.cwd, projectRoot);
|
|
} finally {
|
|
cleanup(homeDir);
|
|
cleanup(projectRoot);
|
|
cleanup(repoRoot);
|
|
}
|
|
})) passed += 1; else failed += 1;
|
|
|
|
if (test('runAutoUpdate excludes residual legacy Antigravity records', () => {
|
|
const homeDir = createTempDir('auto-update-home-');
|
|
const projectRoot = createTempDir('auto-update-project-');
|
|
const repoRoot = createTempDir('auto-update-repo-');
|
|
|
|
try {
|
|
ensureFakeRepo(repoRoot);
|
|
const canonical = makeRecord({
|
|
repoRoot,
|
|
homeDir,
|
|
projectRoot,
|
|
adapter: { id: 'antigravity-project', target: 'antigravity', kind: 'project' },
|
|
request: {
|
|
profile: null,
|
|
modules: [],
|
|
includeComponents: [],
|
|
excludeComponents: [],
|
|
legacyLanguages: ['typescript'],
|
|
legacyMode: true,
|
|
},
|
|
resolution: { selectedModules: ['legacy-antigravity-install'], skippedModules: [] },
|
|
operations: [],
|
|
});
|
|
const legacy = {
|
|
...canonical,
|
|
installStatePath: path.join(projectRoot, '.agent', 'ecc-install-state.json'),
|
|
legacy: true,
|
|
};
|
|
const commands = [];
|
|
|
|
const result = runAutoUpdate(
|
|
{
|
|
homeDir,
|
|
projectRoot,
|
|
repoRoot,
|
|
dryRun: true,
|
|
},
|
|
{
|
|
discoverInstalledStates: () => [canonical, legacy],
|
|
runExternalCommand(command, args) {
|
|
commands.push({ command, args });
|
|
return {
|
|
stdout: JSON.stringify({ dryRun: true, plan: {} }),
|
|
stderr: '',
|
|
};
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.strictEqual(result.summary.checkedCount, 1);
|
|
assert.strictEqual(result.summary.updatedCount, 1);
|
|
assert.strictEqual(commands.length, 1);
|
|
assert.strictEqual(commands[0].command, process.execPath);
|
|
} finally {
|
|
cleanup(homeDir);
|
|
cleanup(projectRoot);
|
|
cleanup(repoRoot);
|
|
}
|
|
})) passed += 1; else failed += 1;
|
|
|
|
if (test('runAutoUpdate explains a legacy-only Antigravity install', () => {
|
|
const homeDir = createTempDir('auto-update-home-');
|
|
const projectRoot = createTempDir('auto-update-project-');
|
|
const repoRoot = createTempDir('auto-update-repo-');
|
|
|
|
try {
|
|
ensureFakeRepo(repoRoot);
|
|
const legacy = {
|
|
...makeRecord({
|
|
repoRoot,
|
|
homeDir,
|
|
projectRoot,
|
|
adapter: { id: 'antigravity-project', target: 'antigravity', kind: 'project' },
|
|
request: {
|
|
profile: null,
|
|
modules: [],
|
|
includeComponents: [],
|
|
excludeComponents: [],
|
|
legacyLanguages: ['typescript'],
|
|
legacyMode: true,
|
|
},
|
|
resolution: { selectedModules: ['legacy-antigravity-install'], skippedModules: [] },
|
|
operations: [],
|
|
}),
|
|
installStatePath: path.join(projectRoot, '.agent', 'ecc-install-state.json'),
|
|
legacy: true,
|
|
};
|
|
const commands = [];
|
|
|
|
const result = runAutoUpdate(
|
|
{ homeDir, projectRoot, repoRoot, dryRun: true },
|
|
{
|
|
discoverInstalledStates: () => [legacy],
|
|
runExternalCommand(command, args) {
|
|
commands.push({ command, args });
|
|
},
|
|
}
|
|
);
|
|
|
|
assert.deepStrictEqual(result.results, []);
|
|
assert.strictEqual(result.summary.checkedCount, 0);
|
|
assert.strictEqual(result.summary.updatedCount, 0);
|
|
assert.strictEqual(result.summary.errorCount, 0);
|
|
assert.strictEqual(commands.length, 0);
|
|
assert.ok(result.warnings.some(warning => warning.includes(
|
|
'Run the Antigravity installer once to migrate it to .agents'
|
|
)));
|
|
} finally {
|
|
cleanup(homeDir);
|
|
cleanup(projectRoot);
|
|
cleanup(repoRoot);
|
|
}
|
|
})) passed += 1; else failed += 1;
|
|
|
|
if (test('runAutoUpdate gives legacy-only OpenCode migration guidance', () => {
|
|
const homeDir = createTempDir('auto-update-home-');
|
|
const projectRoot = createTempDir('auto-update-project-');
|
|
const repoRoot = createTempDir('auto-update-repo-');
|
|
|
|
try {
|
|
ensureFakeRepo(repoRoot);
|
|
const legacy = {
|
|
...makeRecord({
|
|
repoRoot,
|
|
homeDir,
|
|
projectRoot,
|
|
adapter: { id: 'opencode-home', target: 'opencode', kind: 'home' },
|
|
request: {
|
|
profile: null,
|
|
modules: ['workflow-quality'],
|
|
includeComponents: [],
|
|
excludeComponents: [],
|
|
legacyLanguages: [],
|
|
legacyMode: false,
|
|
},
|
|
resolution: { selectedModules: ['workflow-quality'], skippedModules: [] },
|
|
operations: [],
|
|
}),
|
|
installStatePath: path.join(homeDir, '.opencode', 'ecc-install-state.json'),
|
|
legacy: true,
|
|
legacyLayout: 'opencode',
|
|
};
|
|
|
|
const result = runAutoUpdate(
|
|
{ homeDir, projectRoot, repoRoot, dryRun: true },
|
|
{ discoverInstalledStates: () => [legacy] }
|
|
);
|
|
|
|
assert.deepStrictEqual(result.results, []);
|
|
assert.ok(result.warnings.some(warning => warning.includes(
|
|
'Run the OpenCode installer once to migrate it to the configured OpenCode directory'
|
|
)));
|
|
assert.ok(result.warnings.every(warning => !warning.includes('Antigravity')));
|
|
} finally {
|
|
cleanup(homeDir);
|
|
cleanup(projectRoot);
|
|
cleanup(repoRoot);
|
|
}
|
|
})) passed += 1; else failed += 1;
|
|
|
|
console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
|
|
process.exit(failed > 0 ? 1 : 0);
|
|
}
|
|
|
|
runTests();
|