Add mocha tests to cli package (#8047)

Author: deleonio

packages/tools/kolibri-cli/.gitignore

@@ -29,7 +29,9 @@
 		"start": "rimraf test && cpy \"../../samples/react/src/components\" test/src && cpy \"../../samples/react/public/*.html\" test/ && ts-node src/index.ts migrate --ignore-uncommitted-changes --test-tasks test",
 		"restart": "pnpm reset && pnpm start",
 		"unused": "knip",
-		"watch": "nodemon --ignore package.json src/index.ts migrate --ignore-uncommitted-changes --test-tasks test"
+		"watch": "nodemon --ignore package.json src/index.ts migrate --ignore-uncommitted-changes --test-tasks test",
+               "test": "pnpm test:unit",
+               "test:unit": "TS_NODE_PROJECT=tsconfig.test.json mocha --require ts-node/register test/**/*.ts"
 	},
 	"type": "commonjs",
 	"dependencies": {

packages/tools/kolibri-cli/package.json

@@ -0,0 +1,96 @@
+import assert from 'node:assert';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { Command } from 'commander';
+import generateScss from '../src/generate-scss';
+import info from '../src/info';
+import migrate from '../src/migrate';
+import { getRemoveMode, setRemoveMode } from '../src/migrate/shares/reuse';
+import { TaskRunner } from '../src/migrate/runner/task-runner';
+
+describe('CLI interface', () => {
+        it('runs generate-scss command', () => {
+                const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kolibri-cli-'));
+                const cwd = process.cwd();
+                process.chdir(tmpDir);
+
+               const typedBem = require('typed-bem/scss');
+               const original = typedBem.generateBemScssFile;
+                const calls: string[] = [];
+                typedBem.generateBemScssFile = (_: unknown, name: string) => { calls.push(name); };
+
+                const program = new Command();
+                generateScss(program);
+                program.parse(['node', 'cli', 'generate-scss']);
+
+                typedBem.generateBemScssFile = original;
+                process.chdir(cwd);
+
+                assert.deepStrictEqual(calls, ['alert', 'icon']);
+        });
+
+        it('runs info command', () => {
+                const program = new Command();
+                info(program);
+                let output = '';
+                const original = console.log;
+                console.log = (str: string) => { output += str; };
+                program.parse(['node', 'cli', 'info']);
+                console.log = original;
+                assert.ok(output.includes('Operating System'));
+        });
+
+        it('runs migrate command with options', () => {
+                const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kolibri-cli-'));
+                fs.writeFileSync(
+                        path.join(tmpDir, 'package.json'),
+                        JSON.stringify({ dependencies: { '@public-ui/components': '0.0.0' }, devDependencies: { '@public-ui/kolibri-cli': '0.0.0' } }),
+                );
+                fs.writeFileSync(path.join(tmpDir, 'pnpm-lock.yaml'), '');
+                const cwd = process.cwd();
+                process.chdir(tmpDir);
+
+                
+               const childProc = require('child_process');
+               const execOrig = childProc.exec;
+               (childProc as any).exec = (_: string, cb: (err: null, out: string) => void) => cb(null, '');
+
+                let runCalled = false;
+                const runOrig = TaskRunner.prototype.run;
+                TaskRunner.prototype.run = function () {
+                        runCalled = true;
+                };
+                const getStatusOrig = TaskRunner.prototype.getStatus;
+                TaskRunner.prototype.getStatus = () => ({ total: 0, done: 0, pending: 0, nextVersion: '0.0.0', config: { migrate: { tasks: {} } } });
+                const getPendingOrig = TaskRunner.prototype.getPendingMinVersion;
+                TaskRunner.prototype.getPendingMinVersion = () => '0.0.0';
+
+                const program = new Command();
+                migrate(program);
+                program.parse([
+                        'node',
+                        'cli',
+                        'migrate',
+                        '.',
+                        '--ignore-uncommitted-changes',
+                        '--overwrite-current-version',
+                        '0.0.0',
+                        '--overwrite-target-version',
+                        '0.0.0',
+                        '--remove-mode',
+                        'delete',
+                        '--test-tasks',
+                ]);
+
+               (childProc as any).exec = execOrig;
+                TaskRunner.prototype.run = runOrig;
+                TaskRunner.prototype.getStatus = getStatusOrig;
+                TaskRunner.prototype.getPendingMinVersion = getPendingOrig;
+                process.chdir(cwd);
+
+                assert.ok(runCalled);
+                assert.equal(getRemoveMode(), 'delete');
+                setRemoveMode('prefix');
+        });
+});

packages/tools/kolibri-cli/test/cli-interface.spec.ts

@@ -0,0 +1,68 @@
+import assert from 'node:assert';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import child_process from 'node:child_process';
+
+import { TaskRunner } from '../src/migrate/runner/task-runner';
+import { RenameTagNameTask } from '../src/migrate/runner/tasks/common/RenameTagNameTask';
+import { RenamePropertyNameTask } from '../src/migrate/runner/tasks/common/RenamePropertyNameTask';
+import { RemovePropertyNameTask } from '../src/migrate/runner/tasks/common/RemovePropertyNameTask';
+import { setRemoveMode } from '../src/migrate/shares/reuse';
+
+function createStubModules(baseDir: string) {
+	const reactTypes = path.join(baseDir, 'node_modules', '@types', 'react');
+	fs.mkdirSync(reactTypes, { recursive: true });
+	fs.writeFileSync(path.join(reactTypes, 'index.d.ts'), 'export {};');
+	const reactRuntime = path.join(baseDir, 'node_modules', 'react');
+	fs.mkdirSync(reactRuntime, { recursive: true });
+	fs.writeFileSync(path.join(reactRuntime, 'jsx-runtime.d.ts'), 'export {};');
+	const publicUiReact = path.join(baseDir, 'node_modules', '@public-ui', 'react');
+	fs.mkdirSync(publicUiReact, { recursive: true });
+	fs.writeFileSync(path.join(publicUiReact, 'index.d.ts'), 'export class KolTable {}; export class KolTableStateful {};');
+}
+
+describe('end-to-end migration', () => {
+	beforeEach(() => {
+		(RenameTagNameTask as any).instances?.clear();
+		(RenamePropertyNameTask as any).instances?.clear();
+		(RemovePropertyNameTask as any).instances?.clear();
+	});
+
+	it('runs multiple tasks and compiles the project', () => {
+		const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kolibri-e2e-'));
+		const srcDir = path.join(tmpDir, 'src');
+		fs.mkdirSync(srcDir);
+		fs.writeFileSync(
+			path.join(srcDir, 'index.tsx'),
+			'import { KolTable } from \'@public-ui/react\';\nexport const App = () => <KolTable _old="foo" _remove="bar" />;\n',
+		);
+		fs.writeFileSync(path.join(tmpDir, 'index.html'), '<kol-table _old="foo" _remove="bar"></kol-table>');
+		createStubModules(tmpDir);
+		const tsconfigPath = path.join(tmpDir, 'tsconfig.json');
+		fs.writeFileSync(tsconfigPath, '{}');
+
+		const runner = new TaskRunner(tmpDir, '3.0.0', '1.0.0', { migrate: { tasks: {} } });
+		setRemoveMode('delete');
+		const tasks = [
+			RenameTagNameTask.getInstance('kol-table', 'kol-table-stateful', '^1'),
+			RenamePropertyNameTask.getInstance('kol-table-stateful', '_old', '_new', '^1'),
+			RemovePropertyNameTask.getInstance('kol-table-stateful', '_remove', '^1'),
+		];
+		runner.registerTasks(tasks);
+		runner.run();
+
+		const tsxContent = fs.readFileSync(path.join(srcDir, 'index.tsx'), 'utf8');
+		const htmlContent = fs.readFileSync(path.join(tmpDir, 'index.html'), 'utf8');
+		console.log('debug-tsx', tsxContent);
+		console.log('debug-html', htmlContent);
+		assert.ok(tsxContent.includes('KolTableStateful'));
+		assert.ok(tsxContent.includes('_new="foo"'));
+		assert.ok(!tsxContent.includes('_remove'));
+		assert.ok(htmlContent.includes('<kol-table-stateful'));
+		assert.ok(htmlContent.includes('_new="foo"'));
+		assert.ok(!htmlContent.includes('_remove'));
+
+		setRemoveMode('prefix');
+	});
+});

packages/tools/kolibri-cli/test/end-to-end-migration.spec.ts

@@ -0,0 +1,20 @@
+import assert from 'node:assert';
+import { ExecTask } from '../src/migrate/runner/tasks/common/ExecTask';
+
+describe('ExecTask', () => {
+    it('executes given command', () => {
+        const cp = require('child_process');
+        const original = cp.execSync;
+        let called = '';
+        (cp as any).execSync = (cmd: string) => {
+            called = cmd;
+            return Buffer.from('');
+        };
+
+        const task = ExecTask.getInstance('echo "works"', '^1');
+        task.run();
+
+        (cp as any).execSync = original;
+        assert.strictEqual(called, 'echo "works"');
+    });
+});

packages/tools/kolibri-cli/test/exec-task.spec.ts

@@ -0,0 +1,25 @@
+import assert from 'node:assert';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { GenericRenameSlotNameTask } from '../src/migrate/runner/tasks/common/GenericRenameSlotNameTask';
+
+class TestRenameSlotTask extends GenericRenameSlotNameTask {
+    constructor(tmpTag: string, oldName: string, newName: string) {
+        super('test', 'desc', tmpTag, oldName, newName, 'slot', '^1');
+    }
+}
+
+describe('GenericRenameSlotNameTask', () => {
+    it('updates slot names in components', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kolibri-cli-'));
+        const tsxPath = path.join(tmpDir, 'component.tsx');
+        fs.writeFileSync(tsxPath, '<KolCard slot="header"></KolCard>');
+
+        const task = new TestRenameSlotTask('kol-card', 'header', 'main');
+        task.run(tmpDir);
+
+        const content = fs.readFileSync(tsxPath, 'utf8');
+        assert.ok(content.includes('slot="main"'));
+    });
+});

packages/tools/kolibri-cli/test/generic-rename-slot.spec.ts

@@ -0,0 +1,29 @@
+import assert from 'node:assert';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { GenericRenameTagNameTask } from '../src/migrate/runner/tasks/common/GenericRenameTagNameTask';
+
+class TestRenameTagTask extends GenericRenameTagNameTask {
+    constructor(oldTag: string, newTag: string) {
+        super('test', 'desc', oldTag, newTag, '^1');
+    }
+}
+
+describe('GenericRenameTagNameTask', () => {
+    it('renames tags in component and custom element files', () => {
+        const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kolibri-cli-'));
+        const tsxPath = path.join(tmpDir, 'component.tsx');
+        fs.writeFileSync(tsxPath, '<KolAlert />');
+        const htmlPath = path.join(tmpDir, 'sample.html');
+        fs.writeFileSync(htmlPath, '<kol-alert></kol-alert>');
+
+        const task = new TestRenameTagTask('kol-alert', 'kol-notice');
+        task.run(tmpDir);
+
+        const tsxContent = fs.readFileSync(tsxPath, 'utf8');
+        const htmlContent = fs.readFileSync(htmlPath, 'utf8');
+        assert.ok(tsxContent.includes('KolNotice'));
+        assert.ok(htmlContent.includes('kol-notice'));
+    });
+});

packages/tools/kolibri-cli/test/generic-rename-tag.spec.ts

@@ -0,0 +1,20 @@
+import assert from 'node:assert';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { GitIgnoreAddRuleTask } from '../src/migrate/runner/tasks/common/GitIgnoreAddRuleTask';
+
+describe('GitIgnoreAddRuleTask', () => {
+        it('adds rule to .gitignore', () => {
+                const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kolibri-cli-'));
+                const cwd = process.cwd();
+                process.chdir(tmpDir);
+
+                const task = GitIgnoreAddRuleTask.getInstance('dist', '^1');
+                task.run();
+
+                process.chdir(cwd);
+                const content = fs.readFileSync(path.join(tmpDir, '.gitignore'), 'utf8');
+                assert.ok(content.includes('dist'));
+        });
+});

packages/tools/kolibri-cli/test/gitignore-add-rule.spec.ts

@@ -0,0 +1,19 @@
+import assert from 'node:assert';
+import { HandleDependencyTask } from '../src/migrate/runner/tasks/common/HandleDependencyTask';
+
+
+describe('HandleDependencyTask', () => {
+        it('calls package manager with dependencies', async () => {
+                const childProc = require('child_process');
+                const original = childProc.execSync;
+                let commands: string[] = [];
+                (childProc as any).execSync = (cmd: string) => { commands.push(cmd); return Buffer.from(''); };
+
+                const task = HandleDependencyTask.getInstance('add', { lodash: '1.0.0' }, { mocha: '2.0.0' }, '^1');
+                task.run();
+
+                (childProc as any).execSync = original;
+                assert.ok(commands[0].includes('add')); // first call
+                assert.ok(commands[1].includes('-D'));
+        });
+});

packages/tools/kolibri-cli/test/handle-dependency.spec.ts

@@ -0,0 +1,21 @@
+import assert from 'node:assert';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { JsonTask } from '../src/migrate/runner/tasks/common/JsonTask';
+
+describe('JsonTask', () => {
+        it('merges config into package.json', () => {
+                const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'kolibri-cli-'));
+                const cwd = process.cwd();
+                process.chdir(tmpDir);
+                fs.writeFileSync('package.json', '{"name":"test"}');
+
+               const task = JsonTask.getInstance('scripts', { scripts: { test: 'mocha' } }, '^1');
+                task.run();
+
+                process.chdir(cwd);
+                const pkg = JSON.parse(fs.readFileSync(path.join(tmpDir, 'package.json'), 'utf8'));
+                assert.equal(pkg.scripts.test, 'mocha');
+        });
+});