Files

261 lines
7.7 KiB
TypeScript
Raw Permalink Normal View History

2026-07-27 13:09:00 +02:00
/**
* Tests for nopy.executor module
*/
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
2026-07-27 13:09:00 +02:00
import {
type DeployCall,
type ExecutionResult,
2026-07-28 12:18:10 +02:00
maskCommand,
2026-07-27 13:09:00 +02:00
outputExecutionPlan,
summarizeResults,
} from '../src/nopy.executor.js';
/**
* Helper to create a test deploy call
*/
function createTestCall(cube: string, host: string, deps: string[] = []): DeployCall {
return {
cube,
host,
cwd: `/test/${cube}`,
command: ['pyinfra', host, '-y', `${cube}.deploy.py`],
env: { VAR: 'value' },
dependencies: deps,
};
}
/**
* Helper to create a test execution result
*/
function createTestResult(
cube: string,
host: string,
success: boolean,
duration = 1000
): ExecutionResult {
return {
cube,
host,
success,
duration,
...(success ? {} : { error: new Error('Test error') }),
};
}
describe('summarizeResults', () => {
it('summarizes successful results', () => {
const results: ExecutionResult[] = [
createTestResult('cube-a', 'host1', true, 1000),
createTestResult('cube-b', 'host1', true, 2000),
];
const summary = summarizeResults(results);
expect(summary.total).toBe(2);
expect(summary.successful).toBe(2);
expect(summary.failed).toBe(0);
expect(summary.totalDuration).toBe(3000);
expect(summary.failures).toHaveLength(0);
});
it('summarizes failed results', () => {
const results: ExecutionResult[] = [
createTestResult('cube-a', 'host1', true, 1000),
createTestResult('cube-b', 'host1', false, 500),
];
const summary = summarizeResults(results);
expect(summary.total).toBe(2);
expect(summary.successful).toBe(1);
expect(summary.failed).toBe(1);
expect(summary.totalDuration).toBe(1500);
expect(summary.failures).toHaveLength(1);
expect(summary.failures[0].cube).toBe('cube-b');
});
it('handles empty results', () => {
const summary = summarizeResults([]);
expect(summary.total).toBe(0);
expect(summary.successful).toBe(0);
expect(summary.failed).toBe(0);
expect(summary.totalDuration).toBe(0);
});
it('handles all failed results', () => {
const results: ExecutionResult[] = [
createTestResult('cube-a', 'host1', false, 100),
createTestResult('cube-b', 'host1', false, 200),
];
const summary = summarizeResults(results);
expect(summary.successful).toBe(0);
expect(summary.failed).toBe(2);
expect(summary.failures).toHaveLength(2);
});
});
describe('outputExecutionPlan', () => {
let consoleLogSpy: ReturnType<typeof vi.spyOn>;
beforeEach(() => {
consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
});
// vitest reuses an existing spy rather than re-wrapping, so recorded calls
// would otherwise leak from one test into the next.
afterEach(() => {
vi.restoreAllMocks();
});
2026-07-27 13:09:00 +02:00
it('outputs text format by default', () => {
const calls = [createTestCall('cube-a', 'host1')];
outputExecutionPlan(calls);
expect(consoleLogSpy).toHaveBeenCalled();
const output = consoleLogSpy.mock.calls.map((c) => c[0]).join('\n');
expect(output).toContain('Execution Plan');
expect(output).toContain('cube-a');
expect(output).toContain('host1');
});
2026-07-28 12:18:10 +02:00
it('masks variables the manifest declared secret', () => {
2026-07-27 13:09:00 +02:00
const call: DeployCall = {
...createTestCall('cube-a', 'host1'),
command: ['pyinfra', 'host1', '-y', '--data', 'PASSWORD=hunter2', '--data', 'OTHER=visible'],
2026-07-28 12:18:10 +02:00
env: { PASSWORD: 'hunter2', OTHER: 'visible' },
secrets: ['PASSWORD'],
2026-07-27 13:09:00 +02:00
};
outputExecutionPlan([call]);
const output = consoleLogSpy.mock.calls.map((c) => c[0]).join('\n');
expect(output).toContain('********');
2026-07-28 12:18:10 +02:00
// Both the variable list and the command line above it — the command used
// to be printed unmasked, which defeated the masking entirely.
expect(output).not.toContain('hunter2');
expect(output).toContain('visible');
});
it('leaves a password-looking variable alone when the manifest says nothing', () => {
const call: DeployCall = {
...createTestCall('cube-a', 'host1'),
env: { PASSWORD: 'visible' },
};
outputExecutionPlan([call]);
const output = consoleLogSpy.mock.calls.map((c) => c[0]).join('\n');
2026-07-27 13:09:00 +02:00
expect(output).toContain('visible');
});
it('shows step numbers', () => {
const calls = [createTestCall('cube-a', 'host1'), createTestCall('cube-b', 'host1')];
outputExecutionPlan(calls);
const output = consoleLogSpy.mock.calls.map((c) => c[0]).join('\n');
expect(output).toContain('Step 1');
expect(output).toContain('Step 2');
});
it('shows total count', () => {
const calls = [
createTestCall('cube-a', 'host1'),
createTestCall('cube-b', 'host1'),
createTestCall('cube-c', 'host1'),
];
outputExecutionPlan(calls);
const output = consoleLogSpy.mock.calls.map((c) => c[0]).join('\n');
expect(output).toContain('Total: 3');
});
});
2026-07-28 12:18:10 +02:00
describe('maskCommand', () => {
const call = (command: string[], secrets?: string[]): DeployCall => ({
...createTestCall('cube-a', 'host1'),
command,
secrets,
});
it('replaces the value of a declared secret', () => {
const masked = maskCommand(
call(['pyinfra', 'host1', '--data', 'PASSWORD=hunter2'], ['PASSWORD'])
2026-07-28 12:18:10 +02:00
);
expect(masked).toBe('pyinfra host1 --data PASSWORD=********');
2026-07-28 12:18:10 +02:00
});
it('leaves other data alone', () => {
const masked = maskCommand(
call(['--data', 'SSID=home', '--data', 'PASSWORD=hunter2'], ['PASSWORD'])
2026-07-28 12:18:10 +02:00
);
expect(masked).toBe('--data SSID=home --data PASSWORD=********');
2026-07-28 12:18:10 +02:00
});
it('masks a value containing spaces', () => {
const masked = maskCommand(
call(['--data', 'PASSWORD=two words', '--chdir', '/x'], ['PASSWORD'])
);
2026-07-28 12:18:10 +02:00
expect(masked).toBe('--data PASSWORD=******** --chdir /x');
2026-07-28 12:18:10 +02:00
});
it('masks an empty secret value', () => {
expect(maskCommand(call(['--data', 'PASSWORD='], ['PASSWORD']))).toBe(
'--data PASSWORD=********'
2026-07-28 12:18:10 +02:00
);
});
it('masks a secret whose value contains a quote', () => {
// The old implementation bounded the value on the closing `"` the builder
// had written, so a value containing one leaked the rest of itself.
const masked = maskCommand(call(['--data', 'PASSWORD=he said "hi"'], ['PASSWORD']));
expect(masked).toBe('--data PASSWORD=********');
expect(masked).not.toContain('hi');
});
2026-07-28 12:18:10 +02:00
it('masks the ssh password whether or not the cube declares secrets', () => {
const masked = maskCommand(
call(['pyinfra', 'host1', '--user', 'bob', '--password', 's3cr3t', '-y'])
);
2026-07-28 12:18:10 +02:00
expect(masked).toBe('pyinfra host1 --user bob --password ******** -y');
});
it('returns the command untouched when there is nothing to hide', () => {
expect(maskCommand(call(['pyinfra', 'host1', '-y']))).toBe('pyinfra host1 -y');
});
it('quotes an argument a shell would otherwise re-parse', () => {
// Display only — nothing runs through a shell — but `--print-only` output is
// meant to be pasteable, so it has to survive the round trip.
const masked = maskCommand(call(['--data', 'MOTD=$(id); rm -rf /']));
expect(masked).toBe(`--data 'MOTD=$(id); rm -rf /'`);
});
it('escapes an embedded single quote', () => {
expect(maskCommand(call(['--data', "NAME=o'brien"]))).toBe(`--data 'NAME=o'\\''brien'`);
});
it('quotes an empty argument rather than dropping it', () => {
expect(maskCommand(call(['pyinfra', '']))).toBe("pyinfra ''");
});
it('leaves a trailing --password with no value alone', () => {
expect(maskCommand(call(['pyinfra', '--password']))).toBe('pyinfra --password');
});
it('handles a --data argument with no equals sign', () => {
expect(maskCommand(call(['--data', 'BARE'], ['BARE']))).toBe('--data BARE=********');
});
2026-07-28 12:18:10 +02:00
});