44r0n7/privacy.sexy
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix invisible script execution on Windows #264

Browse Source 
This commit addresses an issue in the privacy.sexy desktop application
where scripts executed as administrator on Windows were running in the
background. This was observed in environments like Windows Pro VMs on
Azure, where operations typically run with administrative privileges.

Previously, the application used the `"$path"` shell command to execute
scripts. This mechanism failed to activate the logic for requesting
admin privileges if the app itself was running as an administrator.
To resolve this, the script execution process has been modified to
explicitly ask for administrator privileges using the `VerbAs` method.
This ensures that the script always runs in a new `cmd.exe` window,
enhancing visibility and user interaction.

Other supporting changes:

- Rename the generated script file from `run-{timestamp}-{extension}` er
  to `{timestamp}-privacy-script-{extension}` for clearer identification
  and better file sorting.
- Refactor `ScriptFileCreator` to parameterize file extension and
  script name.
- Rename `OsTimestampedFilenameGenerator` to
  `TimestampedFilenameGenerator` to better reflect its new and more
  scoped functionality after refactoring mentioned abvoe.
- Remove `setAppName()` due to ineffective behavior in Windows.
- Update `SECURITY.md` to highlight that the app doesn't require admin
  rights for standard operations.
- Add `.editorconfig` settings for PowerShell scripts.
- Add a integration test for script execution logic. Improve environment
  detection for more reliable test execution.
- Disable application logging during unit/integration tests to keep test
  outputs clean and focused.
This commit is contained in:
undergroundwires
2024-01-09 20:44:06 +01:00
parent 728584240c
commit b404a91ada
32 changed files with 716 additions and 290 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
tests/integration/infrastructure/CodeRunner/ScriptFileCodeRunner.spec.ts Normal file
View File

@@ -0,0 +1,89 @@
import { mkdtemp } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join } from 'node:path';
import { exec } from 'node:child_process';
import { describe, it } from 'vitest';
import { ScriptDirectoryProvider } from '@/infrastructure/CodeRunner/Creation/Directory/ScriptDirectoryProvider';
import { ScriptFileCreationOrchestrator } from '@/infrastructure/CodeRunner/Creation/ScriptFileCreationOrchestrator';
import { ScriptFileCodeRunner } from '@/infrastructure/CodeRunner/ScriptFileCodeRunner';
import { expectDoesNotThrowAsync } from '@tests/shared/Assertions/ExpectThrowsAsync';
import { CurrentEnvironment } from '@/infrastructure/RuntimeEnvironment/RuntimeEnvironmentFactory';
import { OperatingSystem } from '@/domain/OperatingSystem';
import { LinuxTerminalEmulator } from '@/infrastructure/CodeRunner/Execution/VisibleTerminalScriptFileExecutor';
describe('ScriptFileCodeRunner', () => {
it('executes simple script correctly', async ({ skip }) => {
// arrange
const currentOperatingSystem = CurrentEnvironment.os;
if (await shouldSkipTest(currentOperatingSystem)) {
skip();
}
const temporaryDirectoryProvider = createTemporaryDirectoryProvider();
const codeRunner = createCodeRunner(temporaryDirectoryProvider);
const args = getPlatformSpecificArguments(currentOperatingSystem);
// act
const act = () => codeRunner.runCode(...args);
// assert
await expectDoesNotThrowAsync(act);
});
});
function getPlatformSpecificArguments(
os: OperatingSystem | undefined,
): Parameters<ScriptFileCodeRunner['runCode']> {
switch (os) {
case undefined:
throw new Error('Operating system detection failed: Unable to identify the current platform.');
case OperatingSystem.Windows:
return [
[
'@echo off',
'echo Hello, World!',
'exit /b 0',
].join('\n'),
'bat',
];
case OperatingSystem.macOS:
case OperatingSystem.Linux:
return [
[
'#!/bin/bash',
'echo "Hello, World!"',
'exit 0',
].join('\n'),
'sh',
];
default:
throw new Error(`Platform not supported: The current operating system (${os}) is not compatible with this script execution.`);
}
}
function shouldSkipTest(
os: OperatingSystem | undefined,
): Promise<boolean> {
return new Promise((resolve) => {
if (os !== OperatingSystem.Linux) {
resolve(false);
}
exec(`which ${LinuxTerminalEmulator}`).on('close', (exitCode) => {
resolve(exitCode !== 0);
});
});
}
function createCodeRunner(directoryProvider: ScriptDirectoryProvider): ScriptFileCodeRunner {
return new ScriptFileCodeRunner(
undefined,
new ScriptFileCreationOrchestrator(undefined, undefined, directoryProvider),
);
}
function createTemporaryDirectoryProvider(): ScriptDirectoryProvider {
return {
provideScriptDirectory: async () => {
const temporaryDirectoryPathPrefix = join(tmpdir(), 'privacy-sexy-tests-');
const temporaryDirectoryFullPath = await mkdtemp(temporaryDirectoryPathPrefix);
return temporaryDirectoryFullPath;
},
};
}

8
tests/shared/Assertions/ExpectExists.ts
View File

@@ -7,8 +7,12 @@
* non-nullable in the subsequent code. This can prevent potential type errors
* and enhance code safety and clarity.
*/
export function expectExists<T>(value: T): asserts value is NonNullable<T> {
export function expectExists<T>(value: T, errorMessage?: string): asserts value is NonNullable<T> {
if (value === null || value === undefined) {
throw new Error('Expected value to exist');
throw new Error([
'Assertion failed: expected value is either null or undefined.',
'Expected a non-null and non-undefined value.',
...(errorMessage ? [errorMessage] : []),
].join('\n'));
}
}

103
tests/unit/infrastructure/CodeRunner/Creation/Filename/OsTimestampedFilenameGenerator.spec.ts
View File

@@ -1,103 +0,0 @@
import { describe, it, expect } from 'vitest';
import { AllSupportedOperatingSystems, SupportedOperatingSystem } from '@tests/shared/TestCases/SupportedOperatingSystems';
import { OperatingSystem } from '@/domain/OperatingSystem';
import { formatAssertionMessage } from '@tests/shared/FormatAssertionMessage';
import { RuntimeEnvironmentStub } from '@tests/unit/shared/Stubs/RuntimeEnvironmentStub';
import { OsTimestampedFilenameGenerator } from '@/infrastructure/CodeRunner/Creation/Filename/OsTimestampedFilenameGenerator';
describe('OsTimestampedFilenameGenerator', () => {
describe('generateFilename', () => {
it('generates correct prefix', () => {
// arrange
const expectedPrefix = 'run';
// act
const filename = generateFilenamePartsForTesting();
// assert
expect(filename.prefix).to.equal(expectedPrefix);
});
it('generates correct timestamp', () => {
// arrange
const currentDate = '2023-01-01T12:00:00.000Z';
const expectedTimestamp = '2023-01-01_12-00-00';
const date = new Date(currentDate);
// act
const filename = generateFilenamePartsForTesting({ date });
// assert
expect(filename.timestamp).to.equal(expectedTimestamp, formatAssertionMessage[
`Generated file name: ${filename.generatedFileName}`
]);
});
describe('generates correct extension', () => {
const testScenarios: Record<SupportedOperatingSystem, string> = {
[OperatingSystem.Windows]: 'bat',
[OperatingSystem.Linux]: 'sh',
[OperatingSystem.macOS]: 'sh',
};
AllSupportedOperatingSystems.forEach((operatingSystem) => {
it(`on ${OperatingSystem[operatingSystem]}`, () => {
// arrange
const expectedExtension = testScenarios[operatingSystem];
// act
const filename = generateFilenamePartsForTesting({ operatingSystem });
// assert
expect(filename.extension).to.equal(expectedExtension, formatAssertionMessage[
`Generated file name: ${filename.generatedFileName}`
]);
});
});
});
describe('generates filename without extension for unknown OS', () => {
// arrange
const testScenarios: ReadonlyArray<{
readonly description: string;
readonly unknownOs?: OperatingSystem;
}> = [
{
description: 'unsupported OS',
unknownOs: 'Unsupported' as unknown as OperatingSystem,
},
{
description: 'undefined OS',
unknownOs: undefined,
},
];
testScenarios.forEach(({ description, unknownOs }) => {
it(description, () => {
// act
const filename = generateFilenamePartsForTesting({ operatingSystem: unknownOs });
// assert
expect(filename.extension).toBeUndefined();
});
});
});
});
});
interface TestFileNameComponents {
readonly prefix: string;
readonly timestamp: string;
readonly extension?: string;
readonly generatedFileName: string;
}
function generateFilenamePartsForTesting(testScenario?: {
operatingSystem?: OperatingSystem,
date?: Date,
}): TestFileNameComponents {
const date = testScenario?.date ?? new Date();
const sut = new OsTimestampedFilenameGenerator(
new RuntimeEnvironmentStub().withOs(testScenario?.operatingSystem),
);
const filename = sut.generateFilename(date);
const pattern = /^(?<prefix>[^-]+)-(?<timestamp>[^.]+)(?:\.(?<extension>[^.]+))?$/; // prefix-timestamp.extension
const match = filename.match(pattern);
if (!match?.groups?.prefix || !match?.groups?.timestamp) {
throw new Error(`Failed to parse prefix or timestamp: ${filename}`);
}
return {
generatedFileName: filename,
prefix: match.groups.prefix,
timestamp: match.groups.timestamp,
extension: match.groups.extension,
};
}

124
tests/unit/infrastructure/CodeRunner/Creation/Filename/TimestampedFilenameGenerator.spec.ts Normal file
View File

@@ -0,0 +1,124 @@
import { describe, it, expect } from 'vitest';
import { formatAssertionMessage } from '@tests/shared/FormatAssertionMessage';
import { TimestampedFilenameGenerator } from '@/infrastructure/CodeRunner/Creation/Filename/TimestampedFilenameGenerator';
import { itEachAbsentStringValue } from '@tests/unit/shared/TestCases/AbsentTests';
describe('TimestampedFilenameGenerator', () => {
describe('generateFilename', () => {
describe('script name', () => {
it('uses correct script name', () => {
// arrange
const expectedScriptName = 'test-script';
// act
const filename = generateFilenamePartsForTesting({
scriptName: expectedScriptName,
});
// assert
expect(filename.scriptName).to.equal(expectedScriptName);
});
describe('error for missing script name', () => {
itEachAbsentStringValue((absentValue) => {
// arrange
const expectedError = 'Script name is required but not provided.';
// act
const act = () => generateFilenamePartsForTesting({
scriptName: absentValue,
});
// assert
expect(act).to.throw(expectedError);
}, { excludeNull: true, excludeUndefined: true });
});
});
it('generates expected timestamp', () => {
// arrange
const currentDate = '2023-01-01T12:00:00.000Z';
const expectedTimestamp = '2023-01-01_12-00-00';
const date = new Date(currentDate);
// act
const filename = generateFilenamePartsForTesting({ date });
// assert
expect(filename.timestamp).to.equal(expectedTimestamp, formatAssertionMessage[
`Generated file name: ${filename.generatedFilename}`
]);
});
describe('extension', () => {
it('uses correct extension', () => {
// arrange
const expectedExtension = 'sexy';
// act
const filename = generateFilenamePartsForTesting({ extension: expectedExtension });
// assert
expect(filename.extension).to.equal(expectedExtension, formatAssertionMessage[
`Generated file name: ${filename.generatedFilename}`
]);
});
describe('handles absent extension', () => {
itEachAbsentStringValue((absentExtension) => {
// arrange
const expectedExtension = undefined;
// act
const filename = generateFilenamePartsForTesting({ extension: absentExtension });
// assert
expect(filename.extension).to.equal(expectedExtension, formatAssertionMessage[
`Generated file name: ${filename.generatedFilename}`
]);
}, { excludeNull: true });
});
it('errors on dot-starting extension', () => {
// arrange
const invalidExtension = '.sexy';
const expectedError = 'File extension should not start with a dot.';
// act
const act = () => generateFilenamePartsForTesting({ extension: invalidExtension });
// assert
expect(act).to.throw(expectedError);
});
});
});
});
interface TestFileNameComponents {
readonly scriptName: string;
readonly timestamp: string;
readonly extension?: string;
readonly generatedFilename: string;
}
function generateFilenamePartsForTesting(testScenario?: {
readonly date?: Date,
readonly extension?: string,
readonly scriptName?: string,
}): TestFileNameComponents {
const date = testScenario?.date ?? new Date();
const sut = new TimestampedFilenameGenerator();
const filename = sut.generateFilename(
{
scriptName: testScenario?.scriptName ?? 'privacy-script',
scriptFileExtension: testScenario?.extension,
},
date,
);
return parseFilename(filename);
}
function parseFilename(generatedFilename: string): TestFileNameComponents {
const pattern = /^(?<timestamp>\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2})-(?<scriptName>[^.]+?)(?:\.(?<extension>[^.]+))?$/;// timestamp-scriptName.extension
const match = generatedFilename.match(pattern);
function assertMatch(name: string, value: string | undefined): asserts value is string {
if (!value) {
throw new Error([
`Missing "${name}" match in generated filename.`,
`Generated filename: ${generatedFilename}`,
`Match object: ${JSON.stringify(match)}`,
].join('\n'));
}
}
assertMatch('script name', match?.groups?.scriptName);
assertMatch('timestamp', match?.groups?.timestamp);
return {
generatedFilename,
scriptName: match.groups.scriptName,
timestamp: match.groups.timestamp,
extension: match.groups.extension,
};
}

38
tests/unit/infrastructure/CodeRunner/Creation/ScriptFileCreationOrchestrator.spec.ts
View File

@@ -11,6 +11,8 @@ import { FilenameGeneratorStub } from '@tests/unit/shared/Stubs/FilenameGenerato
import { SystemOperationsStub } from '@tests/unit/shared/Stubs/SystemOperationsStub';
import { SystemOperations } from '@/infrastructure/CodeRunner/System/SystemOperations';
import { LocationOpsStub } from '@tests/unit/shared/Stubs/LocationOpsStub';
import { ScriptFileNameParts } from '@/infrastructure/CodeRunner/Creation/ScriptFileCreator';
import { expectExists } from '@tests/shared/Assertions/ExpectExists';
describe('ScriptFileCreationOrchestrator', () => {
describe('createScriptFile', () => {
@@ -62,6 +64,28 @@ describe('ScriptFileCreationOrchestrator', () => {
.pop();
expect(actualFileName).to.equal(expectedFilename);
});
it('generates file name using specified parts', async () => {
// arrange
const expectedParts: ScriptFileNameParts = {
scriptName: 'expected-script-name',
scriptFileExtension: 'expected-script-file-extension',
};
const filenameGeneratorStub = new FilenameGeneratorStub();
const context = new ScriptFileCreationOrchestratorTestSetup()
.withFileNameParts(expectedParts)
.withFilenameGenerator(filenameGeneratorStub);
// act
await context.createScriptFile();
// assert
const fileNameGenerationCalls = filenameGeneratorStub.callHistory.filter((c) => c.methodName === 'generateFilename');
expect(fileNameGenerationCalls).to.have.lengthOf(1);
const callArguments = fileNameGenerationCalls[0].args;
const [scriptNameFileParts] = callArguments;
expectExists(scriptNameFileParts, `Call arguments: ${JSON.stringify(callArguments)}`);
expect(scriptNameFileParts).to.equal(expectedParts);
});
it('generates complete file path', async () => {
// arrange
const expectedPath = 'expected-script-path';
@@ -84,7 +108,7 @@ describe('ScriptFileCreationOrchestrator', () => {
expect(actualFilePath).to.equal(expectedPath);
});
});
describe('writing file to system', () => {
describe('file writing', () => {
it('writes file to the generated path', async () => {
// arrange
const filesystem = new FileSystemOpsStub();
@@ -133,6 +157,11 @@ class ScriptFileCreationOrchestratorTestSetup {
private fileContents = `[${ScriptFileCreationOrchestratorTestSetup.name}] script file contents`;
private fileNameParts: ScriptFileNameParts = {
scriptName: `[${ScriptFileCreationOrchestratorTestSetup.name}] script name`,
scriptFileExtension: `[${ScriptFileCreationOrchestratorTestSetup.name}] file extension`,
};
public withFileContents(fileContents: string): this {
this.fileContents = fileContents;
return this;
@@ -153,6 +182,11 @@ class ScriptFileCreationOrchestratorTestSetup {
return this;
}
public withFileNameParts(fileNameParts: ScriptFileNameParts): this {
this.fileNameParts = fileNameParts;
return this;
}
public createScriptFile(): ReturnType<ScriptFileCreationOrchestrator['createScriptFile']> {
const creator = new ScriptFileCreationOrchestrator(
this.system,
@@ -160,6 +194,6 @@ class ScriptFileCreationOrchestratorTestSetup {
this.directoryProvider,
this.logger,
);
return creator.createScriptFile(this.fileContents);
return creator.createScriptFile(this.fileContents, this.fileNameParts);
}
}

2
tests/unit/infrastructure/CodeRunner/Execution/VisibleTerminalScriptFileExecutor.spec.ts
View File

@@ -55,7 +55,7 @@ describe('VisibleTerminalScriptFileExecutor', () => {
{
description: 'encloses path in quotes',
filePath: 'file',
expectedCommand: '"file"',
expectedCommand: 'PowerShell Start-Process -Verb RunAs -FilePath "file"',
},
],
[OperatingSystem.macOS]: [

55
tests/unit/infrastructure/CodeRunner/ScriptFileCodeRunner.spec.ts
View File

@@ -2,6 +2,7 @@ import { describe, it, expect } from 'vitest';
import { ScriptFileCodeRunner } from '@/infrastructure/CodeRunner/ScriptFileCodeRunner';
import { LoggerStub } from '@tests/unit/shared/Stubs/LoggerStub';
import { Logger } from '@/application/Common/Log/Logger';
import { ScriptFileName } from '@/application/CodeRunner/ScriptFileName';
import { ScriptFileExecutor } from '@/infrastructure/CodeRunner/Execution/ScriptFileExecutor';
import { ScriptFileExecutorStub } from '@tests/unit/shared/Stubs/ScriptFileExecutorStub';
import { ScriptFileCreator } from '@/infrastructure/CodeRunner/Creation/ScriptFileCreator';
@@ -11,7 +12,7 @@ import { expectThrowsAsync } from '@tests/shared/Assertions/ExpectThrowsAsync';
describe('ScriptFileCodeRunner', () => {
describe('runCode', () => {
it('executes the script file as expected', async () => {
it('executes script file correctly', async () => {
// arrange
const expectedFilePath = 'expected script path';
const fileExecutor = new ScriptFileExecutorStub();
@@ -45,6 +46,41 @@ describe('ScriptFileCodeRunner', () => {
const [actualCode] = createCalls[0].args;
expect(actualCode).to.equal(expectedCode);
});
it('creates script file with provided extension', async () => {
// arrange
const expectedFileExtension = 'expected-file-extension';
const fileCreator = new ScriptFileCreatorStub();
const context = new CodeRunnerTestSetup()
.withFileCreator(fileCreator)
.withFileExtension(expectedFileExtension);
// act
await context.runCode();
// assert
const createCalls = fileCreator.callHistory.filter((call) => call.methodName === 'createScriptFile');
expect(createCalls.length).to.equal(1);
const [,scriptFileNameParts] = createCalls[0].args;
expectExists(scriptFileNameParts, JSON.stringify(`Call args: ${JSON.stringify(createCalls[0].args)}`));
expect(scriptFileNameParts.scriptFileExtension).to.equal(expectedFileExtension);
});
it('creates script file with provided name', async () => {
// arrange
const expectedScriptName = ScriptFileName;
const fileCreator = new ScriptFileCreatorStub();
const context = new CodeRunnerTestSetup()
.withFileCreator(fileCreator);
// act
await context.runCode();
// assert
const createCalls = fileCreator.callHistory.filter((call) => call.methodName === 'createScriptFile');
expect(createCalls.length).to.equal(1);
const [,scriptFileNameParts] = createCalls[0].args;
expectExists(scriptFileNameParts, JSON.stringify(`Call args: ${JSON.stringify(createCalls[0].args)}`));
expect(scriptFileNameParts.scriptName).to.equal(expectedScriptName);
});
describe('error handling', () => {
const testScenarios: ReadonlyArray<{
readonly description: string;
@@ -52,7 +88,7 @@ describe('ScriptFileCodeRunner', () => {
readonly faultyContext: CodeRunnerTestSetup;
}> = [
(() => {
const error = new Error('script file execution failed');
const error = new Error('Test Error: Script file execution intentionally failed for testing purposes.');
const executor = new ScriptFileExecutorStub();
executor.executeScriptFile = () => {
throw error;
@@ -64,7 +100,7 @@ describe('ScriptFileCodeRunner', () => {
};
})(),
(() => {
const error = new Error('script file creation failed');
const error = new Error('Test Error: Script file creation intentionally failed for testing purposes.');
const creator = new ScriptFileCreatorStub();
creator.createScriptFile = () => {
throw error;
@@ -76,7 +112,7 @@ describe('ScriptFileCodeRunner', () => {
};
})(),
];
describe('logs errors correctly', () => {
describe('logs errors', () => {
testScenarios.forEach(({ description, faultyContext }) => {
it(`logs error when ${description}`, async () => {
// arrange
@@ -94,7 +130,7 @@ describe('ScriptFileCodeRunner', () => {
});
});
});
describe('correctly rethrows errors', () => {
describe('rethrows errors', () => {
testScenarios.forEach(({ description, injectedException, faultyContext }) => {
it(`rethrows error when ${description}`, async () => {
// act
@@ -111,6 +147,8 @@ describe('ScriptFileCodeRunner', () => {
class CodeRunnerTestSetup {
private code = `[${CodeRunnerTestSetup.name}]code`;
private fileExtension = `[${CodeRunnerTestSetup.name}]file-extension`;
private fileCreator: ScriptFileCreator = new ScriptFileCreatorStub();
private fileExecutor: ScriptFileExecutor = new ScriptFileExecutorStub();
@@ -123,7 +161,7 @@ class CodeRunnerTestSetup {
this.fileCreator,
this.logger,
);
await runner.runCode(this.code);
await runner.runCode(this.code, this.fileExtension);
}
public withFileExecutor(fileExecutor: ScriptFileExecutor): this {
@@ -145,4 +183,9 @@ class CodeRunnerTestSetup {
this.fileCreator = fileCreator;
return this;
}
public withFileExtension(fileExtension: string): this {
this.fileExtension = fileExtension;
return this;
}
}

56
tests/unit/infrastructure/RuntimeEnvironment/RuntimeEnvironmentFactory.spec.ts
View File

@@ -1,7 +1,7 @@
import { describe, it, expect } from 'vitest';
import {
BrowserRuntimeEnvironmentFactory, NodeRuntimeEnvironmentFactory,
WindowAccessor, determineAndCreateRuntimeEnvironment,
GlobalAccessor as GlobalPropertiesAccessor, determineAndCreateRuntimeEnvironment,
} from '@/infrastructure/RuntimeEnvironment/RuntimeEnvironmentFactory';
import { RuntimeEnvironmentStub } from '@tests/unit/shared/Stubs/RuntimeEnvironmentStub';
@@ -11,7 +11,7 @@ describe('RuntimeEnvironmentFactory', () => {
// arrange
const expectedEnvironment = new RuntimeEnvironmentStub();
const context = new RuntimeEnvironmentFactoryTestSetup()
.withWindowAccessor(() => { return {} as Window; })
.withWindowAccessor(() => createWindowStub())
.withBrowserEnvironmentFactory(() => expectedEnvironment);
// act
const actualEnvironment = context.buildEnvironment();
@@ -21,7 +21,7 @@ describe('RuntimeEnvironmentFactory', () => {
it('passes correct window to browser environment', () => {
// arrange
const expectedWindow = {} as Window;
const expectedWindow = createWindowStub();
let actualWindow: Window | undefined;
const browserEnvironmentFactoryMock: BrowserRuntimeEnvironmentFactory = (providedWindow) => {
actualWindow = providedWindow;
@@ -41,18 +41,58 @@ describe('RuntimeEnvironmentFactory', () => {
const expectedEnvironment = new RuntimeEnvironmentStub();
const context = new RuntimeEnvironmentFactoryTestSetup()
.withWindowAccessor(() => undefined)
.withProcessAccessor(() => createProcessStub())
.withNodeEnvironmentFactory(() => expectedEnvironment);
// act
const actualEnvironment = context.buildEnvironment();
// assert
expect(actualEnvironment).to.equal(expectedEnvironment);
});
it('uses node environment when window is present too', () => { // This allows running integration tests
// arrange
const expectedEnvironment = new RuntimeEnvironmentStub();
const context = new RuntimeEnvironmentFactoryTestSetup()
.withWindowAccessor(() => createWindowStub())
.withProcessAccessor(() => createProcessStub())
.withNodeEnvironmentFactory(() => expectedEnvironment);
// act
const actualEnvironment = context.buildEnvironment();
// assert
expect(actualEnvironment).to.equal(expectedEnvironment);
});
it('throws if both node and window are missing', () => {
// arrange
const expectedError = 'Unsupported runtime environment: The current context is neither a recognized browser nor a Node.js environment.';
const context = new RuntimeEnvironmentFactoryTestSetup()
.withWindowAccessor(() => undefined)
.withProcessAccessor(() => undefined);
// act
const act = () => context.buildEnvironment();
// assert
expect(act).to.throw(expectedError);
});
});
});
function createWindowStub(): Window {
return {} as Window;
}
function createProcessStub(): NodeJS.Process {
return {} as NodeJS.Process;
}
type WindowAccessor = GlobalPropertiesAccessor['getGlobalWindow'];
type ProcessAccessor = GlobalPropertiesAccessor['getGlobalProcess'];
export class RuntimeEnvironmentFactoryTestSetup {
private windowAccessor: WindowAccessor = () => undefined;
private processAccessor: ProcessAccessor = () => undefined;
private browserEnvironmentFactory
: BrowserRuntimeEnvironmentFactory = () => new RuntimeEnvironmentStub();
@@ -64,6 +104,11 @@ export class RuntimeEnvironmentFactoryTestSetup {
return this;
}
public withProcessAccessor(processAccessor: ProcessAccessor): this {
this.processAccessor = processAccessor;
return this;
}
public withNodeEnvironmentFactory(
nodeEnvironmentFactory: NodeRuntimeEnvironmentFactory,
): this {
@@ -80,7 +125,10 @@ export class RuntimeEnvironmentFactoryTestSetup {
public buildEnvironment(): ReturnType<typeof determineAndCreateRuntimeEnvironment> {
return determineAndCreateRuntimeEnvironment(
this.windowAccessor,
{
getGlobalProcess: this.processAccessor,
getGlobalWindow: this.windowAccessor,
},
this.browserEnvironmentFactory,
this.nodeEnvironmentFactory,
);

171
tests/unit/presentation/bootstrapping/ClientLoggerFactory.spec.ts
View File

@@ -1,80 +1,159 @@
import {
describe, it, beforeEach, afterEach,
} from 'vitest';
// eslint-disable-next-line max-classes-per-file
import { describe, it } from 'vitest';
import { RuntimeEnvironment } from '@/infrastructure/RuntimeEnvironment/RuntimeEnvironment';
import { ClientLoggerFactory } from '@/presentation/bootstrapping/ClientLoggerFactory';
import { ClientLoggerFactory, LoggerCreationFunction, WindowAccessor } from '@/presentation/bootstrapping/ClientLoggerFactory';
import { Logger } from '@/application/Common/Log/Logger';
import { WindowInjectedLogger } from '@/infrastructure/Log/WindowInjectedLogger';
import { ConsoleLogger } from '@/infrastructure/Log/ConsoleLogger';
import { NoopLogger } from '@/infrastructure/Log/NoopLogger';
import { RuntimeEnvironmentStub } from '@tests/unit/shared/Stubs/RuntimeEnvironmentStub';
import { Constructible } from '@/TypeHelpers';
import { itIsSingleton } from '@tests/unit/shared/TestCases/SingletonTests';
import { LoggerStub } from '@tests/unit/shared/Stubs/LoggerStub';
describe('ClientLoggerFactory', () => {
describe('Current', () => {
itIsSingleton({
getter: () => ClientLoggerFactory.Current,
expectedType: ClientLoggerFactory,
describe('singleton behavior', () => {
itIsSingleton({
getter: () => ClientLoggerFactory.Current,
expectedType: ClientLoggerFactory,
});
});
});
describe('logger instantiation based on environment', () => {
const originalWindow = { ...window };
beforeEach(() => {
Object.assign(window, { log: new LoggerStub() });
});
afterEach(() => {
Object.assign(window, originalWindow);
});
const testCases: Array<{
readonly description: string,
readonly expectedType: Constructible<Logger>,
readonly environment: RuntimeEnvironment,
readonly build: (
builder: ClientLoggerFactoryBuilder,
expectedLogger: Logger,
) => ClientLoggerFactory,
}> = [
{
description: 'desktop environment',
expectedType: WindowInjectedLogger,
environment: new RuntimeEnvironmentStub()
.withIsDesktop(true),
description: 'production desktop environment',
build: (b, expectedLogger) => b
.withWindowInjectedLoggerFactory(() => expectedLogger)
.withEnvironment(new RuntimeEnvironmentStub()
.withIsDesktop(true)
.withIsNonProduction(false))
.withWindowAccessor(() => createWindowWithLogger())
.build(),
},
{
description: 'non-production and desktop environment',
expectedType: WindowInjectedLogger,
environment: new RuntimeEnvironmentStub()
.withIsDesktop(true)
.withIsNonProduction(true),
description: 'non-production desktop environment',
build: (b, expectedLogger) => b
.withWindowInjectedLoggerFactory(() => expectedLogger)
.withEnvironment(new RuntimeEnvironmentStub()
.withIsDesktop(true)
.withIsNonProduction(true))
.withWindowAccessor(() => createWindowWithLogger())
.build(),
},
{
description: 'non-production without desktop',
expectedType: ConsoleLogger,
environment: new RuntimeEnvironmentStub()
.withIsDesktop(false)
.withIsNonProduction(true),
description: 'non-production web environment',
build: (b, expectedLogger) => b
.withConsoleLoggerFactory(() => expectedLogger)
.withEnvironment(new RuntimeEnvironmentStub()
.withIsDesktop(false)
.withIsNonProduction(true))
.withWindowAccessor(() => createWindowWithLogger())
.build(),
},
{
description: 'production without desktop',
expectedType: NoopLogger,
environment: new RuntimeEnvironmentStub()
.withIsDesktop(false)
.withIsNonProduction(false),
description: 'production web environment',
build: (b, expectedLogger) => b
.withNoopLoggerFactory(() => expectedLogger)
.withEnvironment(new RuntimeEnvironmentStub()
.withIsDesktop(false)
.withIsNonProduction(false))
.withWindowAccessor(() => createWindowWithLogger())
.build(),
},
{
description: 'unit/integration tests environment',
build: (b, expectedLogger) => b
.withNoopLoggerFactory(() => expectedLogger)
.withEnvironment(new RuntimeEnvironmentStub().withIsDesktop(true))
.withWindowAccessor(() => createWindowWithLogger(null))
.build(),
},
];
testCases.forEach(({ description, expectedType, environment }) => {
it(`instantiates ${expectedType.name} for ${description}`, () => {
testCases.forEach(({ description, build }) => {
it(`creates correct logger for ${description}`, () => {
// arrange
const factory = new TestableClientLoggerFactory(environment);
const expectedLogger = new LoggerStub();
const factory = build(new ClientLoggerFactoryBuilder(), expectedLogger);
// act
const { logger } = factory;
// assert
expect(logger).to.be.instanceOf(expectedType);
expect(logger).to.equal(expectedLogger);
});
});
});
});
class TestableClientLoggerFactory extends ClientLoggerFactory {
public constructor(environment: RuntimeEnvironment) {
super(environment);
function createWindowWithLogger(logger: Logger | null = new LoggerStub()): Window {
return {
log: logger,
} as unknown as Window;
}
class ClientLoggerFactoryBuilder {
private environment: RuntimeEnvironment = new RuntimeEnvironmentStub();
private windowAccessor: WindowAccessor = () => ({} as Window);
private noopLoggerFactory: LoggerCreationFunction = () => new LoggerStub();
private windowInjectedLoggerFactory: LoggerCreationFunction = () => new LoggerStub();
private consoleLoggerFactory: LoggerCreationFunction = () => new LoggerStub();
public withWindowAccessor(windowAccessor: WindowAccessor): this {
this.windowAccessor = windowAccessor;
return this;
}
public withEnvironment(environment: RuntimeEnvironment): this {
this.environment = environment;
return this;
}
public withNoopLoggerFactory(factory: LoggerCreationFunction): this {
this.noopLoggerFactory = factory;
return this;
}
public withWindowInjectedLoggerFactory(factory: LoggerCreationFunction): this {
this.windowInjectedLoggerFactory = factory;
return this;
}
public withConsoleLoggerFactory(factory: LoggerCreationFunction): this {
this.consoleLoggerFactory = factory;
return this;
}
public build(): ClientLoggerFactory {
return new TestableClientLoggerFactory(
this.environment,
this.windowAccessor,
this.noopLoggerFactory,
this.windowInjectedLoggerFactory,
this.consoleLoggerFactory,
);
}
}
class TestableClientLoggerFactory extends ClientLoggerFactory {
public constructor(
environment: RuntimeEnvironment,
windowAccessor: WindowAccessor,
noopLoggerFactory: LoggerCreationFunction,
windowInjectedLoggerFactory: LoggerCreationFunction,
consoleLoggerFactory: LoggerCreationFunction,
) {
super(
environment,
windowAccessor,
noopLoggerFactory,
windowInjectedLoggerFactory,
consoleLoggerFactory,
);
}
}

2
tests/unit/shared/Stubs/CodeRunnerStub.ts
View File

@@ -1,4 +1,4 @@
import { CodeRunner } from '@/application/CodeRunner';
import { CodeRunner } from '@/application/CodeRunner/CodeRunner';
export class CodeRunnerStub implements CodeRunner {
public runCode(): Promise<void> {

12
tests/unit/shared/Stubs/FilenameGeneratorStub.ts
View File

@@ -1,9 +1,17 @@
import { FilenameGenerator } from '@/infrastructure/CodeRunner/Creation/Filename/FilenameGenerator';
import { ScriptFileNameParts } from '@/infrastructure/CodeRunner/Creation/ScriptFileCreator';
import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
export class FilenameGeneratorStub implements FilenameGenerator {
export class FilenameGeneratorStub
extends StubWithObservableMethodCalls<FilenameGenerator>
implements FilenameGenerator {
private filename = `[${FilenameGeneratorStub.name}]file-name-stub`;
public generateFilename(): string {
public generateFilename(scriptFileNameParts: ScriptFileNameParts): string {
this.registerMethodCall({
methodName: 'generateFilename',
args: [scriptFileNameParts],
});
return this.filename;
}

9
tests/unit/shared/Stubs/ScriptFileCreatorStub.ts
View File

@@ -1,4 +1,4 @@
import { ScriptFileCreator } from '@/infrastructure/CodeRunner/Creation/ScriptFileCreator';
import { ScriptFileCreator, ScriptFileNameParts } from '@/infrastructure/CodeRunner/Creation/ScriptFileCreator';
import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
export class ScriptFileCreatorStub
@@ -11,10 +11,13 @@ export class ScriptFileCreatorStub
return this;
}
public createScriptFile(contents: string): Promise<string> {
public createScriptFile(
contents: string,
scriptFileNameParts: ScriptFileNameParts,
): Promise<string> {
this.registerMethodCall({
methodName: 'createScriptFile',
args: [contents],
args: [contents, scriptFileNameParts],
});
return Promise.resolve(this.createdFilePath);
}

2
tests/unit/shared/Stubs/WindowVariablesStub.ts
View File

@@ -1,7 +1,7 @@
import { OperatingSystem } from '@/domain/OperatingSystem';
import { Logger } from '@/application/Common/Log/Logger';
import { WindowVariables } from '@/infrastructure/WindowVariables/WindowVariables';
import { CodeRunner } from '@/application/CodeRunner';
import { CodeRunner } from '@/application/CodeRunner/CodeRunner';
import { LoggerStub } from './LoggerStub';
import { CodeRunnerStub } from './CodeRunnerStub';