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

Show native save dialogs in desktop app #50, #264

Browse Source 
This commit introduces native operating system file dialogs in the
desktop application replacing the existing web-based dialogs.

It lays the foundation for future enhancements such as:

- Providing error messages when saving or executing files, addressing
  #264.
- Creating system restore points, addressing #50.

Documentation updates:

- Update `desktop-vs-web-features.md` with added functionality.
- Update `README.md` with security feature highlights.
- Update home page documentation to emphasize security features.

Other supporting changes include:

- Integrate IPC communication channels for secure Electron dialog API
  interactions.
- Refactor `IpcRegistration` for more type-safety and simplicity.
- Introduce a Vue hook to encapsulate dialog functionality.
- Improve errors during IPC registration for easier troubleshooting.
- Move `ClientLoggerFactory` for consistency in hooks organization and
  remove `LoggerFactory` interface for simplicity.
- Add tests for the save file dialog in the browser context.
- Add `Blob` polyfill in tests to compensate for the missing
  `blob.text()` function in `jsdom` (see jsdom/jsdom#2555).

Improve environment detection logic:

- Treat test environment as browser environments to correctly activate
  features based on the environment. This resolves issues where the
  environment is misidentified as desktop, but Electron preloader APIs
  are missing.
- Rename `isDesktop` environment identification variable to
  `isRunningAsDesktopApplication` for better clarity and to avoid
  confusion with desktop environments in web/browser/test environments.
- Simplify `BrowserRuntimeEnvironment` to consistently detect
  non-desktop application environments.
- Improve environment detection for Electron main process
  (electron/electron#2288).
This commit is contained in:
undergroundwires
2024-01-13 18:04:23 +01:00
parent da4be500da
commit c546a33eff
65 changed files with 1384 additions and 345 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
tests/integration/infrastructure/CodeRunner/ScriptFileCodeRunner.spec.ts
View File

@@ -17,6 +17,7 @@ describe('ScriptFileCodeRunner', () => {
const currentOperatingSystem = CurrentEnvironment.os;
if (await shouldSkipTest(currentOperatingSystem)) {
skip();
return;
}
const temporaryDirectoryProvider = createTemporaryDirectoryProvider();
const codeRunner = createCodeRunner(temporaryDirectoryProvider);
@@ -61,10 +62,14 @@ function getPlatformSpecificArguments(
function shouldSkipTest(
os: OperatingSystem | undefined,
): Promise<boolean> {
if (os !== OperatingSystem.Linux) {
return Promise.resolve(false);
}
return isLinuxTerminalEmulatorSupported();
}
function isLinuxTerminalEmulatorSupported(): Promise<boolean> {
return new Promise((resolve) => {
if (os !== OperatingSystem.Linux) {
resolve(false);
}
exec(`which ${LinuxTerminalEmulator}`).on('close', (exitCode) => {
resolve(exitCode !== 0);
});

6
tests/integration/infrastructure/RuntimeEnvironment/BrowserOs/BrowserOsTestCases.ts
View File

@@ -39,6 +39,8 @@ export const BrowserOsTestCases: ReadonlyArray<BrowserOsTestCase> = [
'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.102 UBrowser/6.0.1308.1016 Safari/537.36',
// Electron:
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.5993.54 Electron/27.0.0 Safari/537.36',
// jsdom:
'Mozilla/5.0 (Windows) AppleWebKit/537.36 (KHTML, like Gecko) jsdom/22.1.0',
],
}),
...createTests({
@@ -60,6 +62,8 @@ export const BrowserOsTestCases: ReadonlyArray<BrowserOsTestCase> = [
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36 Edg/119.0.0.0',
// Electron:
'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.5993.54 Electron/27.0.0 Safari/537.36',
// jsdom:
'Mozilla/5.0 (darwin) AppleWebKit/537.36 (KHTML, like Gecko) jsdom/22.1.0',
],
}),
...createTests({
@@ -74,6 +78,8 @@ export const BrowserOsTestCases: ReadonlyArray<BrowserOsTestCase> = [
'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36 Edg/115.0.1901.188',
// Electron:
'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.5993.54 Electron/27.0.0 Safari/537.36',
// jsdom:
'Mozilla/5.0 (linux) AppleWebKit/537.36 (KHTML, like Gecko) jsdom/22.1.0',
],
}),
...createTests({

23
tests/integration/infrastructure/RuntimeEnvironment/RuntimeEnvironmentFactory.spec.ts Normal file
View File

@@ -0,0 +1,23 @@
import { describe, it, expect } from 'vitest';
import { CurrentEnvironment } from '@/infrastructure/RuntimeEnvironment/RuntimeEnvironmentFactory';
describe('RuntimeEnvironmentFactory', () => {
describe('CurrentEnvironment', () => {
it('identifies as browser in test environment', () => { // Ensures test independence from Electron IPC
// arrange
const expectedDesktopAppState = false;
// act
const isRunningAsDesktop = CurrentEnvironment.isRunningAsDesktopApplication;
// assert
expect(isRunningAsDesktop).to.equal(expectedDesktopAppState);
});
it('identifies as non-production in test environment', () => {
// arrange
const expectedNonProductionState = true;
// act
const isNonProductionEnvironment = CurrentEnvironment.isNonProduction;
// assert
expect(isNonProductionEnvironment).to.equal(expectedNonProductionState);
});
});
});

2
tests/integration/presentation/bootstrapping/Modules/MobileSafariActivePseudoClassEnabler.spec.ts
View File

@@ -29,7 +29,7 @@ describe('MobileSafariActivePseudoClassEnabler', () => {
`User agent\t\t: ${navigator.userAgent}`,
`Touch supported\t\t: ${supportsTouch}`,
`Current OS\t\t: ${patchedEnvironment.os === undefined ? 'unknown' : OperatingSystem[patchedEnvironment.os]}`,
`Is desktop?\t\t: ${patchedEnvironment.isDesktop ? 'Yes (Desktop app)' : 'No (Browser)'}`,
`Is desktop?\t\t: ${patchedEnvironment.isRunningAsDesktopApplication ? 'Yes (Desktop app)' : 'No (Browser)'}`,
`Listeners (${currentListeners.length})\t\t: ${JSON.stringify(currentListeners)}`,
]));
});

7
tests/shared/bootstrap/BlobPolyfill.ts Normal file
View File

@@ -0,0 +1,7 @@
import { Blob as BlobPolyfill } from 'node:buffer';
export function polyfillBlob() {
// eslint-disable-next-line @typescript-eslint/no-explicit-any
global.Blob = BlobPolyfill as any;
// Workaround as `blob.text()` is not available in jsdom (https://github.com/jsdom/jsdom/issues/2555)
}

2
tests/shared/bootstrap/setup.ts
View File

@@ -1,4 +1,6 @@
import { afterEach } from 'vitest';
import { enableAutoUnmount } from '@vue/test-utils';
import { polyfillBlob } from './BlobPolyfill';
enableAutoUnmount(afterEach);
polyfillBlob();

31
tests/unit/infrastructure/Dialog/Browser/BrowserDialog.spec.ts Normal file
View File

@@ -0,0 +1,31 @@
import { describe, it, expect } from 'vitest';
import { FileType } from '@/presentation/common/Dialog';
import { BrowserDialog } from '@/infrastructure/Dialog/Browser/BrowserDialog';
import { BrowserSaveFileDialog } from '@/infrastructure/Dialog/Browser/BrowserSaveFileDialog';
describe('BrowserDialog', () => {
describe('saveFile', () => {
it('passes correct arguments', () => {
// arrange
const expectedFileContents = 'test content';
const expectedFileName = 'test.sh';
const expectedFileType = FileType.ShellScript;
let actualSaveFileArgs: Parameters<BrowserSaveFileDialog['saveFile']> | undefined;
const fileSaverDialogSpy: BrowserSaveFileDialog = {
saveFile: (...args) => {
actualSaveFileArgs = args;
},
};
const browserDialog = new BrowserDialog(fileSaverDialogSpy);
// act
browserDialog.saveFile(expectedFileContents, expectedFileName, expectedFileType);
// assert
expect(actualSaveFileArgs)
.to
.deep
.equal([expectedFileContents, expectedFileName, expectedFileType]);
});
});
});

126
tests/unit/infrastructure/Dialog/Browser/FileSaverDialog.spec.ts Normal file
View File

@@ -0,0 +1,126 @@
import { describe, it, expect } from 'vitest';
import { FileSaverDialog, SaveAsFunction, WindowOpenFunction } from '@/infrastructure/Dialog/Browser/FileSaverDialog';
import { FileType } from '@/presentation/common/Dialog';
import { expectExists } from '@tests/shared/Assertions/ExpectExists';
describe('FileSaverDialog', () => {
describe('saveFile', () => {
describe('saving file with correct mime type', () => {
const testCases: ReadonlyArray<{
readonly fileType: FileType;
readonly expectedMimeType: string;
}> = [
{ fileType: FileType.BatchFile, expectedMimeType: 'application/bat' },
{ fileType: FileType.ShellScript, expectedMimeType: 'text/x-shellscript' },
];
testCases.forEach(({ fileType, expectedMimeType }) => {
it(`correct mimeType for ${FileType[fileType]}`, () => {
// arrange
let actualMimeType: string | undefined;
const saveAsSpy: SaveAsFunction = (blob) => {
actualMimeType = blob.type;
};
// act
new SaveFileTestSetup()
.withFileType(fileType)
.withSaveAs(saveAsSpy)
.saveFile();
// assert
expect(actualMimeType).to.equal(expectedMimeType);
});
});
});
it('blob contains correct file contents', async () => {
// arrange
const expectedFileContents = 'expected file contents';
let actualBlob: Blob | undefined;
const saveAsSpy: SaveAsFunction = (blob) => {
actualBlob = blob;
};
// act
new SaveFileTestSetup()
.withSaveAs(saveAsSpy)
.withFileContents(expectedFileContents)
.saveFile();
// assert
expectExists(actualBlob);
const actualFileContents = await actualBlob.text();
expect(actualFileContents).to.equal(expectedFileContents);
});
it('opens new window on save failure', () => {
// arrange
const fileContents = 'test file contents';
const failingSaveAs: SaveAsFunction = () => {
throw new Error('injected fail');
};
let calledArgs: Parameters<WindowOpenFunction> | undefined;
const windowOpenSpy: WindowOpenFunction = (...args) => {
calledArgs = args;
};
// act
new SaveFileTestSetup()
.withSaveAs(failingSaveAs)
.withFileType(FileType.BatchFile)
.withFileContents(fileContents)
.withWindowOpen(windowOpenSpy)
.saveFile();
// assert
expectExists(calledArgs);
const [url, target, features] = calledArgs;
const mimeType = 'application/bat';
expect(url).to.equal(`data:${mimeType},${encodeURIComponent(fileContents)}`);
expect(target).to.equal('_blank');
expect(features).to.equal('');
});
});
});
class SaveFileTestSetup {
private saveAs: SaveAsFunction = () => {};
private windowOpen: WindowOpenFunction = () => {};
private fileContents: string = `${SaveFileTestSetup.name} file contents`;
private fileName: string = `${SaveFileTestSetup.name} file name`;
private fileType: FileType = FileType.BatchFile;
public withSaveAs(saveAs: SaveAsFunction): this {
this.saveAs = saveAs;
return this;
}
public withFileContents(fileContents: string): this {
this.fileContents = fileContents;
return this;
}
public withFileType(fileType: FileType): this {
this.fileType = fileType;
return this;
}
public withWindowOpen(windowOpen: WindowOpenFunction): this {
this.windowOpen = windowOpen;
return this;
}
public saveFile() {
const dialog = new FileSaverDialog(
this.saveAs,
this.windowOpen,
);
return dialog.saveFile(
this.fileContents,
this.fileName,
this.fileType,
);
}
}

32
tests/unit/infrastructure/Dialog/Electron/ElectronDialog.spec.ts Normal file
View File

@@ -0,0 +1,32 @@
import { describe, it, expect } from 'vitest';
import { FileType } from '@/presentation/common/Dialog';
import { BrowserDialog } from '@/infrastructure/Dialog/Browser/BrowserDialog';
import { ElectronSaveFileDialog } from '@/infrastructure/Dialog/Electron/ElectronSaveFileDialog';
describe('BrowserDialog', () => {
describe('saveFile', () => {
it('passes correct arguments', async () => {
// arrange
const expectedFileContents = 'test content';
const expectedFileName = 'test.sh';
const expectedFileType = FileType.ShellScript;
let actualSaveFileArgs: Parameters<ElectronSaveFileDialog['saveFile']> | undefined;
const fileSaverDialogSpy: ElectronSaveFileDialog = {
saveFile: (...args) => {
actualSaveFileArgs = args;
return Promise.resolve();
},
};
const browserDialog = new BrowserDialog(fileSaverDialogSpy);
// act
await browserDialog.saveFile(expectedFileContents, expectedFileName, expectedFileType);
// assert
expect(actualSaveFileArgs)
.to
.deep
.equal([expectedFileContents, expectedFileName, expectedFileType]);
});
});
});

45
tests/unit/infrastructure/Dialog/Electron/ElectronFileDialogOperationsStub.ts Normal file
View File

@@ -0,0 +1,45 @@
import { ElectronFileDialogOperations } from '@/infrastructure/Dialog/Electron/NodeElectronSaveFileDialog';
import { StubWithObservableMethodCalls } from '@tests/unit/shared/Stubs/StubWithObservableMethodCalls';
export class ElectronFileDialogOperationsStub
extends StubWithObservableMethodCalls<ElectronFileDialogOperations>
implements ElectronFileDialogOperations {
private mimicUserCancel = false;
private userDownloadsPath = `[${ElectronFileDialogOperationsStub.name}] downloads path`;
private userSelectedFilePath = `${ElectronFileDialogOperationsStub.name} user selected file path`;
public withMimicUserCancel(isCancelled: boolean): this {
this.mimicUserCancel = isCancelled;
return this;
}
public withUserDownloadsPath(userDownloadsPath: string): this {
this.userDownloadsPath = userDownloadsPath;
return this;
}
public withUserSelectedFilePath(userSelectedFilePath: string): this {
this.userSelectedFilePath = userSelectedFilePath;
return this;
}
public getUserDownloadsPath(): string {
return this.userDownloadsPath;
}
public showSaveDialog(
options: Electron.SaveDialogOptions,
): Promise<Electron.SaveDialogReturnValue> {
this.registerMethodCall({
methodName: 'showSaveDialog',
args: [options],
});
const returnValue: Electron.SaveDialogReturnValue = {
canceled: this.mimicUserCancel,
filePath: this.userSelectedFilePath,
};
return Promise.resolve(returnValue);
}
}

268
tests/unit/infrastructure/Dialog/Electron/NodeElectronSaveFileDialog.spec.ts Normal file
View File

@@ -0,0 +1,268 @@
import { describe, it, expect } from 'vitest';
import { FileType } from '@/presentation/common/Dialog';
import { ElectronFileDialogOperations, NodeElectronSaveFileDialog, NodeFileOperations } from '@/infrastructure/Dialog/Electron/NodeElectronSaveFileDialog';
import { Logger } from '@/application/Common/Log/Logger';
import { LoggerStub } from '@tests/unit/shared/Stubs/LoggerStub';
import { expectExists } from '@tests/shared/Assertions/ExpectExists';
import { ElectronFileDialogOperationsStub } from './ElectronFileDialogOperationsStub';
import { NodeFileOperationsStub } from './NodeFileOperationsStub';
describe('NodeElectronSaveFileDialog', () => {
describe('shows dialog with correct options', () => {
it('correct title', async () => {
// arrange
const expectedFileName = 'expected-file-name';
const electronMock = new ElectronFileDialogOperationsStub();
const context = new SaveFileDialogTestSetup()
.withElectron(electronMock)
.withFileName(expectedFileName);
// act
await context.saveFile();
// assert
assertDialogOptionMatchesExpectedValue(expectedFileName, (opts) => opts.title, electronMock);
});
it('correct properties', async () => {
// arrange
const expectedProperties = [
'createDirectory',
'showOverwriteConfirmation',
];
const electronMock = new ElectronFileDialogOperationsStub();
const context = new SaveFileDialogTestSetup()
.withElectron(electronMock);
// act
await context.saveFile();
// assert
assertDialogOptionMatchesExpectedValue(
expectedProperties,
(opts) => opts.properties,
electronMock,
);
});
it('correct default path', async () => {
// arrange
const pathSegmentSeparator = '_{test-separator}_';
const expectedFileName = 'expected-file-name';
const expectedParentDirectory = 'expected-downloads-path';
const expectedFilePath = [
expectedParentDirectory,
expectedFileName,
].join(pathSegmentSeparator);
const electronMock = new ElectronFileDialogOperationsStub()
.withUserDownloadsPath(expectedParentDirectory);
const context = new SaveFileDialogTestSetup()
.withElectron(electronMock)
.withFileName(expectedFileName)
.withNode(new NodeFileOperationsStub().withPathSegmentSeparator(pathSegmentSeparator));
// act
await context.saveFile();
// assert
assertDialogOptionMatchesExpectedValue(
expectedFilePath,
(opts) => opts.defaultPath,
electronMock,
);
});
describe('correct filters', () => {
const defaultFilter: Electron.FileFilter = {
name: 'All Files',
extensions: ['*'],
};
const testScenarios: Record<FileType, Electron.FileFilter[]> = {
[FileType.BatchFile]: [
defaultFilter,
{
name: 'Batch Files',
extensions: ['bat', 'cmd'],
},
],
[FileType.ShellScript]: [
defaultFilter,
{
name: 'Shell Scripts',
extensions: ['sh', 'bash', 'zsh'],
},
],
};
Object.entries(testScenarios).forEach(([fileTypeKey, expectedFilters]) => {
const fileType = Number(fileTypeKey) as FileType;
it(`applies correct filters for ${FileType[fileType]}`, async () => {
// arrange
const electronMock = new ElectronFileDialogOperationsStub();
const context = new SaveFileDialogTestSetup()
.withFileType(fileType)
.withElectron(electronMock);
// act
await context.saveFile();
// assert
const sortFilters = (
filters: Electron.FileFilter[],
) => filters.sort((a, b) => a.name.localeCompare(b.name));
const expectedSortedFilters = sortFilters(expectedFilters);
assertDialogOptionMatchesExpectedValue(
expectedSortedFilters,
(opts) => sortFilters(opts.filters ?? []),
electronMock,
);
});
});
});
});
describe('saves the file when the dialog is not canceled', () => {
it('writes to the selected file path', async () => {
// arrange
const expectedFilePath = 'expected-file-path';
const isCancelled = false;
const electronMock = new ElectronFileDialogOperationsStub()
.withMimicUserCancel(isCancelled)
.withUserSelectedFilePath(expectedFilePath);
const nodeMock = new NodeFileOperationsStub();
const context = new SaveFileDialogTestSetup()
.withElectron(electronMock)
.withNode(nodeMock);
// act
await context.saveFile();
// assert
const saveFileCalls = nodeMock.callHistory.filter((c) => c.methodName === 'writeFile');
expect(saveFileCalls).to.have.lengthOf(1);
const [actualFilePath] = saveFileCalls[0].args;
expect(actualFilePath).to.equal(expectedFilePath);
});
it('writes the correct file contents', async () => {
// arrange
const expectedFileContents = 'expected-file-contents';
const isCancelled = false;
const electronMock = new ElectronFileDialogOperationsStub()
.withMimicUserCancel(isCancelled);
const nodeMock = new NodeFileOperationsStub();
const context = new SaveFileDialogTestSetup()
.withElectron(electronMock)
.withFileContents(expectedFileContents)
.withNode(nodeMock);
// act
await context.saveFile();
// assert
const saveFileCalls = nodeMock.callHistory.filter((c) => c.methodName === 'writeFile');
expect(saveFileCalls).to.have.lengthOf(1);
const [,actualFileContents] = saveFileCalls[0].args;
expect(actualFileContents).to.equal(expectedFileContents);
});
});
it('does not save file when dialog is canceled', async () => {
// arrange
const isCancelled = true;
const electronMock = new ElectronFileDialogOperationsStub()
.withMimicUserCancel(isCancelled);
const nodeMock = new NodeFileOperationsStub();
const context = new SaveFileDialogTestSetup()
.withElectron(electronMock)
.withNode(nodeMock);
// act
await context.saveFile();
// assert
const saveFileCall = nodeMock.callHistory.find((c) => c.methodName === 'writeFile');
expect(saveFileCall).to.equal(undefined);
});
describe('logging', () => {
it('logs an error if writing the file fails', async () => {
// arrange
const expectedErrorMessage = 'Injected write error';
const electronMock = new ElectronFileDialogOperationsStub().withMimicUserCancel(false);
const nodeMock = new NodeFileOperationsStub();
nodeMock.writeFile = () => Promise.reject(new Error(expectedErrorMessage));
const loggerStub = new LoggerStub();
const context = new SaveFileDialogTestSetup()
.withElectron(electronMock)
.withNode(nodeMock)
.withLogger(loggerStub);
// act
await context.saveFile();
// assert
const errorCalls = loggerStub.callHistory.filter((c) => c.methodName === 'error');
expect(errorCalls.length).to.equal(1);
const errorCall = errorCalls[0];
const [errorMessage] = errorCall.args;
expect(errorMessage).to.include(expectedErrorMessage);
});
});
});
class SaveFileDialogTestSetup {
private fileContents = `${SaveFileDialogTestSetup.name} file contents`;
private fileName = `${SaveFileDialogTestSetup.name} file name`;
private fileType = FileType.BatchFile;
private logger: Logger = new LoggerStub();
private electron: ElectronFileDialogOperations = new ElectronFileDialogOperationsStub();
private node: NodeFileOperations = new NodeFileOperationsStub();
public withElectron(electron: ElectronFileDialogOperations): this {
this.electron = electron;
return this;
}
public withNode(node: NodeFileOperations): this {
this.node = node;
return this;
}
public withLogger(logger: Logger): this {
this.logger = logger;
return this;
}
public withFileName(fileName: string): this {
this.fileName = fileName;
return this;
}
public withFileContents(fileContents: string): this {
this.fileContents = fileContents;
return this;
}
public withFileType(fileType: FileType): this {
this.fileType = fileType;
return this;
}
public saveFile() {
const dialog = new NodeElectronSaveFileDialog(this.logger, this.electron, this.node);
return dialog.saveFile(
this.fileContents,
this.fileName,
this.fileType,
);
}
}
function assertDialogOptionMatchesExpectedValue<T>(
expectedValue: T,
getActualOption: (opts: Electron.SaveDialogOptions) => T | undefined,
electronMock: ElectronFileDialogOperationsStub,
): void {
const showDialogCalls = electronMock.callHistory.filter((c) => c.methodName === 'showSaveDialog');
expect(showDialogCalls).to.have.lengthOf(1);
const showDialogCall = showDialogCalls[0];
expectExists(showDialogCall);
const [options] = showDialogCall.args;
expectExists(options);
const actualValue = getActualOption(options);
expect(actualValue).to.deep.equal(expectedValue);
}

29
tests/unit/infrastructure/Dialog/Electron/NodeFileOperationsStub.ts Normal file
View File

@@ -0,0 +1,29 @@
import { NodeFileOperations } from '@/infrastructure/Dialog/Electron/NodeElectronSaveFileDialog';
import { StubWithObservableMethodCalls } from '@tests/unit/shared/Stubs/StubWithObservableMethodCalls';
export class NodeFileOperationsStub
extends StubWithObservableMethodCalls<NodeFileOperations>
implements NodeFileOperations {
private pathSegmentSeparator = `[${NodeFileOperationsStub.name} path segment separator]`;
public join(...paths: string[]): string {
this.registerMethodCall({
methodName: 'join',
args: [...paths],
});
return paths.join(this.pathSegmentSeparator);
}
public writeFile(file: string, data: string): Promise<void> {
this.registerMethodCall({
methodName: 'writeFile',
args: [file, data],
});
return Promise.resolve();
}
public withPathSegmentSeparator(pathSegmentSeparator: string): this {
this.pathSegmentSeparator = pathSegmentSeparator;
return this;
}
}

61
tests/unit/infrastructure/RuntimeEnvironment/Browser/BrowserRuntimeEnvironment.spec.ts
View File

@@ -1,4 +1,3 @@
// eslint-disable-next-line max-classes-per-file
import { describe, it, expect } from 'vitest';
import { BrowserOsDetector } from '@/infrastructure/RuntimeEnvironment/Browser/BrowserOs/BrowserOsDetector';
import { OperatingSystem } from '@/domain/OperatingSystem';
@@ -42,31 +41,32 @@ describe('BrowserRuntimeEnvironment', () => {
expect(actualTouchSupport).to.equal(expectedTouchSupport);
});
});
describe('isDesktop', () => {
it('returns true when window property isDesktop is true', () => {
describe('isRunningAsDesktopApplication', () => {
it('returns true when window property `isRunningAsDesktopApplication` is true', () => {
// arrange
const desktopWindow = {
isDesktop: true,
const expectedValue = true;
const desktopWindow: Partial<Window> = {
isRunningAsDesktopApplication: true,
};
// act
const sut = new BrowserRuntimeEnvironmentBuilder()
.withWindow(desktopWindow)
.build();
// assert
expect(sut.isDesktop).to.equal(true);
expect(sut.isRunningAsDesktopApplication).to.equal(expectedValue);
});
it('returns false when window property isDesktop is false', () => {
it('returns false when window property `isRunningAsDesktopApplication` is undefined', () => {
// arrange
const expectedValue = false;
const browserWindow = {
isDesktop: false,
const browserWindow: Partial<Window> = {
isRunningAsDesktopApplication: undefined,
};
// act
const sut = new BrowserRuntimeEnvironmentBuilder()
.withWindow(browserWindow)
.build();
// assert
expect(sut.isDesktop).to.equal(expectedValue);
expect(sut.isRunningAsDesktopApplication).to.equal(expectedValue);
});
});
describe('os', () => {
@@ -112,47 +112,6 @@ describe('BrowserRuntimeEnvironment', () => {
// assert
expect(actual).to.equal(expected);
});
describe('desktop os', () => {
describe('returns from window property `os`', () => {
const testValues = [
OperatingSystem.macOS,
OperatingSystem.Windows,
OperatingSystem.Linux,
];
testValues.forEach((testValue) => {
it(`given ${OperatingSystem[testValue]}`, () => {
// arrange
const expectedOs = testValue;
const desktopWindowWithOs = {
isDesktop: true,
os: expectedOs,
};
// act
const sut = new BrowserRuntimeEnvironmentBuilder()
.withWindow(desktopWindowWithOs)
.build();
// assert
const actualOs = sut.os;
expect(actualOs).to.equal(expectedOs);
});
});
});
describe('returns undefined when window property `os` is absent', () => {
itEachAbsentObjectValue((absentValue) => {
// arrange
const expectedValue = undefined;
const windowWithAbsentOs = {
os: absentValue as never,
};
// act
const sut = new BrowserRuntimeEnvironmentBuilder()
.withWindow(windowWithAbsentOs)
.build();
// assert
expect(sut.os).to.equal(expectedValue);
});
});
});
});
describe('isNonProduction', () => {
[true, false].forEach((value) => {

4
tests/unit/infrastructure/RuntimeEnvironment/Node/NodeRuntimeEnvironment.spec.ts
View File

@@ -62,14 +62,14 @@ describe('NodeRuntimeEnvironment', () => {
expect(environment.os).to.equal(expectedOs);
});
});
describe('isDesktop', () => {
describe('isRunningAsDesktopApplication', () => {
it('is always true', () => {
// arrange
const expectedDesktopCondition = true;
// act
const environment = new NodeRuntimeEnvironment();
/// assert
expect(environment.isDesktop).to.equal(expectedDesktopCondition);
expect(environment.isRunningAsDesktopApplication).to.equal(expectedDesktopCondition);
});
});
describe('isNonProduction', () => {

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

@@ -1,73 +1,95 @@
import { describe, it, expect } from 'vitest';
import {
BrowserRuntimeEnvironmentFactory, NodeRuntimeEnvironmentFactory,
GlobalAccessor as GlobalPropertiesAccessor, determineAndCreateRuntimeEnvironment,
BrowserRuntimeEnvironmentFactory, GlobalPropertiesAccessor, NodeRuntimeEnvironmentFactory,
determineAndCreateRuntimeEnvironment,
} from '@/infrastructure/RuntimeEnvironment/RuntimeEnvironmentFactory';
import { RuntimeEnvironmentStub } from '@tests/unit/shared/Stubs/RuntimeEnvironmentStub';
describe('RuntimeEnvironmentFactory', () => {
describe('determineAndCreateRuntimeEnvironment', () => {
it('uses browser environment when window exists', () => {
// arrange
const expectedEnvironment = new RuntimeEnvironmentStub();
const context = new RuntimeEnvironmentFactoryTestSetup()
.withWindowAccessor(() => createWindowStub())
.withBrowserEnvironmentFactory(() => expectedEnvironment);
// act
const actualEnvironment = context.buildEnvironment();
// assert
expect(actualEnvironment).to.equal(expectedEnvironment);
describe('Node environment creation', () => {
it('selects Node environment if Electron main process detected', () => {
// arrange
const processStub = createProcessStub({
versions: {
electron: '28.1.3',
} as NodeJS.ProcessVersions,
});
const expectedEnvironment = new RuntimeEnvironmentStub();
const context = new RuntimeEnvironmentFactoryTestSetup()
.withGlobalProcess(processStub)
.withNodeEnvironmentFactory(() => expectedEnvironment);
// act
const actualEnvironment = context.buildEnvironment();
// assert
expect(actualEnvironment).to.equal(expectedEnvironment);
});
it('passes correct process to Node environment factory', () => {
// arrange
const expectedProcess = createProcessStub({
versions: {
electron: '28.1.3',
} as NodeJS.ProcessVersions,
});
let actualProcess: GlobalProcess;
const nodeEnvironmentFactoryMock: NodeRuntimeEnvironmentFactory = (providedProcess) => {
actualProcess = providedProcess;
return new RuntimeEnvironmentStub();
};
const context = new RuntimeEnvironmentFactoryTestSetup()
.withGlobalProcess(expectedProcess)
.withNodeEnvironmentFactory(nodeEnvironmentFactoryMock);
// act
context.buildEnvironment();
// assert
expect(actualProcess).to.equal(expectedProcess);
});
});
it('passes correct window to browser environment', () => {
// arrange
const expectedWindow = createWindowStub();
let actualWindow: Window | undefined;
const browserEnvironmentFactoryMock: BrowserRuntimeEnvironmentFactory = (providedWindow) => {
actualWindow = providedWindow;
return new RuntimeEnvironmentStub();
};
const context = new RuntimeEnvironmentFactoryTestSetup()
.withWindowAccessor(() => expectedWindow)
.withBrowserEnvironmentFactory(browserEnvironmentFactoryMock);
// act
context.buildEnvironment();
// assert
expect(actualWindow).to.equal(expectedWindow);
describe('browser environment creation', () => {
it('selects browser environment if Electron main process not detected', () => {
// arrange
const expectedEnvironment = new RuntimeEnvironmentStub();
const undefinedProcess: GlobalProcess = undefined;
const windowStub = createWindowStub();
const context = new RuntimeEnvironmentFactoryTestSetup()
.withGlobalProcess(undefinedProcess)
.withGlobalWindow(windowStub)
.withBrowserEnvironmentFactory(() => expectedEnvironment);
// act
const actualEnvironment = context.buildEnvironment();
// assert
expect(actualEnvironment).to.equal(expectedEnvironment);
});
it('passes correct window to browser environment factory', () => {
// arrange
const expectedWindow = createWindowStub({
isRunningAsDesktopApplication: undefined,
});
let actualWindow: GlobalWindow;
const browserEnvironmentFactoryMock
: BrowserRuntimeEnvironmentFactory = (providedWindow) => {
actualWindow = providedWindow;
return new RuntimeEnvironmentStub();
};
const undefinedProcess: GlobalProcess = undefined;
const context = new RuntimeEnvironmentFactoryTestSetup()
.withGlobalWindow(expectedWindow)
.withGlobalProcess(undefinedProcess)
.withBrowserEnvironmentFactory(browserEnvironmentFactoryMock);
// act
context.buildEnvironment();
// assert
expect(actualWindow).to.equal(expectedWindow);
});
});
it('uses node environment when window is absent', () => {
it('throws error when both window and process are undefined', () => {
// arrange
const expectedEnvironment = new RuntimeEnvironmentStub();
const undefinedWindow: GlobalWindow = undefined;
const undefinedProcess: GlobalProcess = undefined;
const expectedError = 'Unsupported runtime environment: The current context is neither a recognized browser nor a desktop environment.';
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);
.withGlobalProcess(undefinedProcess)
.withGlobalWindow(undefinedWindow);
// act
const act = () => context.buildEnvironment();
// assert
@@ -76,22 +98,22 @@ describe('RuntimeEnvironmentFactory', () => {
});
});
function createWindowStub(): Window {
return {} as Window;
function createWindowStub(partialWindowProperties?: Partial<Window>): Window {
return {
...partialWindowProperties,
} as Window;
}
function createProcessStub(): NodeJS.Process {
return {} as NodeJS.Process;
function createProcessStub(partialProcessProperties?: Partial<NodeJS.Process>): NodeJS.Process {
return {
...partialProcessProperties,
} as NodeJS.Process;
}
type WindowAccessor = GlobalPropertiesAccessor['getGlobalWindow'];
type ProcessAccessor = GlobalPropertiesAccessor['getGlobalProcess'];
export class RuntimeEnvironmentFactoryTestSetup {
private windowAccessor: WindowAccessor = () => undefined;
private globalWindow: GlobalWindow = createWindowStub();
private processAccessor: ProcessAccessor = () => undefined;
private globalProcess: GlobalProcess = createProcessStub();
private browserEnvironmentFactory
: BrowserRuntimeEnvironmentFactory = () => new RuntimeEnvironmentStub();
@@ -99,13 +121,13 @@ export class RuntimeEnvironmentFactoryTestSetup {
private nodeEnvironmentFactory
: NodeRuntimeEnvironmentFactory = () => new RuntimeEnvironmentStub();
public withWindowAccessor(windowAccessor: WindowAccessor): this {
this.windowAccessor = windowAccessor;
public withGlobalWindow(globalWindow: GlobalWindow): this {
this.globalWindow = globalWindow;
return this;
}
public withProcessAccessor(processAccessor: ProcessAccessor): this {
this.processAccessor = processAccessor;
public withGlobalProcess(globalProcess: GlobalProcess): this {
this.globalProcess = globalProcess;
return this;
}
@@ -126,11 +148,15 @@ export class RuntimeEnvironmentFactoryTestSetup {
public buildEnvironment(): ReturnType<typeof determineAndCreateRuntimeEnvironment> {
return determineAndCreateRuntimeEnvironment(
{
getGlobalProcess: this.processAccessor,
getGlobalWindow: this.windowAccessor,
window: this.globalWindow,
process: this.globalProcess,
},
this.browserEnvironmentFactory,
this.nodeEnvironmentFactory,
);
}
}
type GlobalWindow = GlobalPropertiesAccessor['window'];
type GlobalProcess = GlobalPropertiesAccessor['process'];

43
tests/unit/infrastructure/RuntimeEnvironment/WindowVariablesValidator.spec.ts
View File

@@ -5,6 +5,9 @@ import { OperatingSystem } from '@/domain/OperatingSystem';
import { getAbsentObjectTestCases, itEachAbsentObjectValue } from '@tests/unit/shared/TestCases/AbsentTests';
import { WindowVariablesStub } from '@tests/unit/shared/Stubs/WindowVariablesStub';
import { CodeRunnerStub } from '@tests/unit/shared/Stubs/CodeRunnerStub';
import { PropertyKeys } from '@/TypeHelpers';
import { LoggerStub } from '@tests/unit/shared/Stubs/LoggerStub';
import { DialogStub } from '@tests/unit/shared/Stubs/DialogStub';
describe('WindowVariablesValidator', () => {
describe('validateWindowVariables', () => {
@@ -24,20 +27,20 @@ describe('WindowVariablesValidator', () => {
it('throws an error with a description of all invalid properties', () => {
// arrange
const invalidOs = 'invalid' as unknown as OperatingSystem;
const invalidIsDesktop = 'not a boolean' as unknown as boolean;
const invalidIsRunningAsDesktopApplication = 'not a boolean' as never;
const expectedError = getExpectedError(
{
name: 'os',
object: invalidOs,
},
{
name: 'isDesktop',
object: invalidIsDesktop,
name: 'isRunningAsDesktopApplication',
object: invalidIsRunningAsDesktopApplication,
},
);
const input = new WindowVariablesStub()
.withOs(invalidOs)
.withIsDesktop(invalidIsDesktop);
.withIsRunningAsDesktopApplication(invalidIsRunningAsDesktopApplication);
// act
const act = () => validateWindowVariables(input);
// assert
@@ -82,7 +85,7 @@ describe('WindowVariablesValidator', () => {
it('does not throw for a missing os value', () => {
// arrange
const input = new WindowVariablesStub()
.withIsDesktop(true)
.withIsRunningAsDesktopApplication(true)
.withOs(undefined);
// act
const act = () => validateWindowVariables(input);
@@ -91,15 +94,24 @@ describe('WindowVariablesValidator', () => {
});
});
describe('`isDesktop` property', () => {
describe('`isRunningAsDesktopApplication` property', () => {
it('does not throw when true with valid services', () => {
// arrange
const validCodeRunner = new CodeRunnerStub();
const input = new WindowVariablesStub()
.withIsDesktop(true)
.withCodeRunner(validCodeRunner);
const windowVariables = new WindowVariablesStub();
const windowVariableConfigurators: Record< // Ensure types match for compile-time checking
PropertyKeys<Required<WindowVariables>>,
(stub: WindowVariablesStub) => WindowVariablesStub> = {
isRunningAsDesktopApplication: (s) => s.withIsRunningAsDesktopApplication(true),
codeRunner: (s) => s.withCodeRunner(new CodeRunnerStub()),
os: (s) => s.withOs(OperatingSystem.Windows),
log: (s) => s.withLog(new LoggerStub()),
dialog: (s) => s.withDialog(new DialogStub()),
};
Object
.values(windowVariableConfigurators)
.forEach((configure) => configure(windowVariables));
// act
const act = () => validateWindowVariables(input);
const act = () => validateWindowVariables(windowVariables);
// assert
expect(act).to.not.throw();
});
@@ -109,7 +121,7 @@ describe('WindowVariablesValidator', () => {
// arrange
const absentCodeRunner = absentValue;
const input = new WindowVariablesStub()
.withIsDesktop(false)
.withIsRunningAsDesktopApplication(undefined)
.withCodeRunner(absentCodeRunner);
// act
const act = () => validateWindowVariables(input);
@@ -150,7 +162,7 @@ function expectObjectOnDesktop<T>(key: keyof WindowVariables) {
});
const input: WindowVariables = {
...new WindowVariablesStub(),
isDesktop: isOnDesktop,
isRunningAsDesktopApplication: isOnDesktop,
[key]: invalidObject,
};
// act
@@ -159,14 +171,13 @@ function expectObjectOnDesktop<T>(key: keyof WindowVariables) {
expect(act).to.throw(expectedError);
});
});
describe('does not object type when not on desktop', () => {
describe('does not validate object type when not on desktop', () => {
itEachInvalidObjectValue((invalidObjectValue) => {
// arrange
const isOnDesktop = false;
const invalidObject = invalidObjectValue as T;
const input: WindowVariables = {
...new WindowVariablesStub(),
isDesktop: isOnDesktop,
isRunningAsDesktopApplication: undefined,
[key]: invalidObject,
};
// act

1
tests/unit/presentation/bootstrapping/DependencyProvider.spec.ts
View File

@@ -19,6 +19,7 @@ describe('DependencyProvider', () => {
useUserSelectionState: createTransientTests(),
useLogger: createTransientTests(),
useCodeRunner: createTransientTests(),
useDialog: createTransientTests(),
};
Object.entries(testCases).forEach(([key, runTests]) => {
const registeredKey = InjectionKeys[key].key;

2
tests/unit/presentation/components/Scripts/Slider/UseDragHandler.spec.ts
View File

@@ -245,7 +245,7 @@ function initializeDragHandlerWithMocks(mocks?: {
}
function createMockPointerEvent(...args: ConstructorArguments<typeof PointerEvent>): PointerEvent {
return new MouseEvent(...args) as PointerEvent; // JSDom does not support `PointerEvent` constructor, https://github.com/jsdom/jsdom/issues/2527
return new MouseEvent(...args) as PointerEvent; // jsdom does not support `PointerEvent` constructor, https://github.com/jsdom/jsdom/issues/2527
}
class DragDomModifierMock implements DragDomModifier {

88
tests/unit/presentation/components/Shared/Hooks/Dialog/ClientDialogFactory.spec.ts Normal file
View File

@@ -0,0 +1,88 @@
import { describe, it, expect } from 'vitest';
import { determineDialogBasedOnEnvironment, WindowDialogCreationFunction, BrowserDialogCreationFunction } from '@/presentation/components/Shared/Hooks/Dialog/ClientDialogFactory';
import { RuntimeEnvironment } from '@/infrastructure/RuntimeEnvironment/RuntimeEnvironment';
import { RuntimeEnvironmentStub } from '@tests/unit/shared/Stubs/RuntimeEnvironmentStub';
import { DialogStub } from '@tests/unit/shared/Stubs/DialogStub';
import { collectExceptionMessage } from '@tests/unit/shared/ExceptionCollector';
describe('ClientDialogFactory', () => {
describe('determineDialogBasedOnEnvironment', () => {
describe('non-desktop environment', () => {
it('returns browser dialog', () => {
// arrange
const expectedDialog = new DialogStub();
const context = new DialogCreationTestSetup()
.withEnvironment(new RuntimeEnvironmentStub().withIsRunningAsDesktopApplication(false))
.withBrowserDialogFactory(() => expectedDialog);
// act
const actualDialog = context.createDialogForTest();
// assert
expect(expectedDialog).to.equal(actualDialog);
});
});
describe('desktop environment', () => {
it('returns window-injected dialog', () => {
// arrange
const expectedDialog = new DialogStub();
const context = new DialogCreationTestSetup()
.withEnvironment(new RuntimeEnvironmentStub().withIsRunningAsDesktopApplication(true))
.withWindowInjectedDialogFactory(() => expectedDialog);
// act
const actualDialog = context.createDialogForTest();
// assert
expect(expectedDialog).to.equal(actualDialog);
});
it('throws error when window-injected dialog is unavailable', () => {
// arrange
const expectedError = 'The Dialog API could not be retrieved from the window object.';
const context = new DialogCreationTestSetup()
.withEnvironment(new RuntimeEnvironmentStub().withIsRunningAsDesktopApplication(true))
.withWindowInjectedDialogFactory(() => undefined);
// act
const act = () => context.createDialogForTest();
// assert
const actualError = collectExceptionMessage(act);
expect(actualError).to.include(expectedError);
});
});
});
});
class DialogCreationTestSetup {
private environment: RuntimeEnvironment = new RuntimeEnvironmentStub();
private browserDialogFactory: BrowserDialogCreationFunction = () => new DialogStub();
private windowInjectedDialogFactory: WindowDialogCreationFunction = () => new DialogStub();
public withEnvironment(environment: RuntimeEnvironment): this {
this.environment = environment;
return this;
}
public withBrowserDialogFactory(browserDialogFactory: BrowserDialogCreationFunction): this {
this.browserDialogFactory = browserDialogFactory;
return this;
}
public withWindowInjectedDialogFactory(
windowInjectedDialogFactory: WindowDialogCreationFunction,
): this {
this.windowInjectedDialogFactory = windowInjectedDialogFactory;
return this;
}
public createDialogForTest() {
return determineDialogBasedOnEnvironment(
this.environment,
this.windowInjectedDialogFactory,
this.browserDialogFactory,
);
}
}

19
tests/unit/presentation/components/Shared/Hooks/Dialog/UseDialog.spec.ts Normal file
View File

@@ -0,0 +1,19 @@
import { describe, it, expect } from 'vitest';
import { DialogFactory, useDialog } from '@/presentation/components/Shared/Hooks/Dialog/UseDialog';
import { DialogStub } from '@tests/unit/shared/Stubs/DialogStub';
describe('UseDialog', () => {
describe('useDialog', () => {
it('returns provided dialog instance', () => {
// arrange
const expectedDialog = new DialogStub();
const factoryMock: DialogFactory = () => expectedDialog;
// act
const { dialog } = useDialog(factoryMock);
// assert
expect(dialog).to.equal(expectedDialog);
});
});
});

12
tests/unit/presentation/bootstrapping/ClientLoggerFactory.spec.ts → tests/unit/presentation/components/Shared/Hooks/Log/ClientLoggerFactory.spec.ts
View File

@@ -1,11 +1,11 @@
// eslint-disable-next-line max-classes-per-file
import { describe, it } from 'vitest';
import { RuntimeEnvironment } from '@/infrastructure/RuntimeEnvironment/RuntimeEnvironment';
import { ClientLoggerFactory, LoggerCreationFunction, WindowAccessor } from '@/presentation/bootstrapping/ClientLoggerFactory';
import { Logger } from '@/application/Common/Log/Logger';
import { RuntimeEnvironmentStub } from '@tests/unit/shared/Stubs/RuntimeEnvironmentStub';
import { itIsSingleton } from '@tests/unit/shared/TestCases/SingletonTests';
import { LoggerStub } from '@tests/unit/shared/Stubs/LoggerStub';
import { ClientLoggerFactory, LoggerCreationFunction, WindowAccessor } from '@/presentation/components/Shared/Hooks/Log/ClientLoggerFactory';
describe('ClientLoggerFactory', () => {
describe('Current', () => {
@@ -29,7 +29,7 @@ describe('ClientLoggerFactory', () => {
build: (b, expectedLogger) => b
.withWindowInjectedLoggerFactory(() => expectedLogger)
.withEnvironment(new RuntimeEnvironmentStub()
.withIsDesktop(true)
.withIsRunningAsDesktopApplication(true)
.withIsNonProduction(false))
.withWindowAccessor(() => createWindowWithLogger())
.build(),
@@ -39,7 +39,7 @@ describe('ClientLoggerFactory', () => {
build: (b, expectedLogger) => b
.withWindowInjectedLoggerFactory(() => expectedLogger)
.withEnvironment(new RuntimeEnvironmentStub()
.withIsDesktop(true)
.withIsRunningAsDesktopApplication(true)
.withIsNonProduction(true))
.withWindowAccessor(() => createWindowWithLogger())
.build(),
@@ -49,7 +49,7 @@ describe('ClientLoggerFactory', () => {
build: (b, expectedLogger) => b
.withConsoleLoggerFactory(() => expectedLogger)
.withEnvironment(new RuntimeEnvironmentStub()
.withIsDesktop(false)
.withIsRunningAsDesktopApplication(false)
.withIsNonProduction(true))
.withWindowAccessor(() => createWindowWithLogger())
.build(),
@@ -59,7 +59,7 @@ describe('ClientLoggerFactory', () => {
build: (b, expectedLogger) => b
.withNoopLoggerFactory(() => expectedLogger)
.withEnvironment(new RuntimeEnvironmentStub()
.withIsDesktop(false)
.withIsRunningAsDesktopApplication(false)
.withIsNonProduction(false))
.withWindowAccessor(() => createWindowWithLogger())
.build(),
@@ -68,7 +68,7 @@ describe('ClientLoggerFactory', () => {
description: 'unit/integration tests environment',
build: (b, expectedLogger) => b
.withNoopLoggerFactory(() => expectedLogger)
.withEnvironment(new RuntimeEnvironmentStub().withIsDesktop(true))
.withEnvironment(new RuntimeEnvironmentStub().withIsRunningAsDesktopApplication(true))
.withWindowAccessor(() => createWindowWithLogger(null))
.build(),
},

11
tests/unit/presentation/components/Shared/Hooks/UseLogger.spec.ts → tests/unit/presentation/components/Shared/Hooks/Log/UseLogger.spec.ts
View File

@@ -1,16 +1,17 @@
import { describe, it, expect } from 'vitest';
import { useLogger } from '@/presentation/components/Shared/Hooks/UseLogger';
import { LoggerStub } from '@tests/unit/shared/Stubs/LoggerStub';
import { LoggerFactoryStub } from '@tests/unit/shared/Stubs/LoggerFactoryStub';
import { useLogger } from '@/presentation/components/Shared/Hooks/Log/UseLogger';
import { LoggerFactory } from '@/presentation/components/Shared/Hooks/Log/LoggerFactory';
describe('UseLogger', () => {
it('returns expected logger from factory', () => {
// arrange
const expectedLogger = new LoggerStub();
const factory = new LoggerFactoryStub()
.withLogger(expectedLogger);
const factoryMock: LoggerFactory = {
logger: expectedLogger,
};
// act
const { log: actualLogger } = useLogger(factory);
const { log: actualLogger } = useLogger(factoryMock);
// assert
expect(actualLogger).to.equal(expectedLogger);
});

48
tests/unit/presentation/electron/main/IpcRegistration.spec.ts
View File

@@ -1,10 +1,13 @@
import { describe, it, expect } from 'vitest';
import { CodeRunnerStub } from '@tests/unit/shared/Stubs/CodeRunnerStub';
import { IpcChannelDefinitions } from '@/presentation/electron/shared/IpcBridging/IpcChannelDefinitions';
import { CodeRunnerFactory, IpcRegistrar, registerAllIpcChannels } from '@/presentation/electron/main/IpcRegistration';
import { ChannelDefinitionKey, IpcChannelDefinitions } from '@/presentation/electron/shared/IpcBridging/IpcChannelDefinitions';
import {
CodeRunnerFactory, DialogFactory, IpcChannelRegistrar, registerAllIpcChannels,
} from '@/presentation/electron/main/IpcRegistration';
import { IpcChannel } from '@/presentation/electron/shared/IpcBridging/IpcChannel';
import { expectExists } from '@tests/shared/Assertions/ExpectExists';
import { collectExceptionMessage } from '@tests/unit/shared/ExceptionCollector';
import { DialogStub } from '@tests/unit/shared/Stubs/DialogStub';
describe('IpcRegistration', () => {
describe('registerAllIpcChannels', () => {
@@ -23,7 +26,7 @@ describe('IpcRegistration', () => {
});
});
describe('registers expected instances', () => {
const testScenarios: Record<keyof typeof IpcChannelDefinitions, {
const testScenarios: Record<ChannelDefinitionKey, {
buildContext: (context: IpcRegistrationTestSetup) => IpcRegistrationTestSetup,
expectedInstance: object,
}> = {
@@ -34,6 +37,13 @@ describe('IpcRegistration', () => {
expectedInstance,
};
})(),
Dialog: (() => {
const expectedInstance = new DialogStub();
return {
buildContext: (c) => c.withDialogFactory(() => expectedInstance),
expectedInstance,
};
})(),
};
Object.entries(testScenarios).forEach(([
key, { buildContext, expectedInstance },
@@ -46,7 +56,8 @@ describe('IpcRegistration', () => {
// act
context.run();
// assert
const actualInstance = getRegisteredInstance(IpcChannelDefinitions.CodeRunner);
const channel = IpcChannelDefinitions[key];
const actualInstance = getRegisteredInstance(channel);
expect(actualInstance).to.equal(expectedInstance);
});
});
@@ -54,7 +65,7 @@ describe('IpcRegistration', () => {
it('throws an error if registration fails', () => {
// arrange
const expectedError = 'registrar error';
const registrarMock: IpcRegistrar = () => {
const registrarMock: IpcChannelRegistrar = () => {
throw new Error(expectedError);
};
const context = new IpcRegistrationTestSetup()
@@ -70,9 +81,11 @@ describe('IpcRegistration', () => {
class IpcRegistrationTestSetup {
private codeRunnerFactory: CodeRunnerFactory = () => new CodeRunnerStub();
private registrar: IpcRegistrar = () => { /* NOOP */ };
private dialogFactory: DialogFactory = () => new DialogStub();
public withRegistrar(registrar: IpcRegistrar): this {
private registrar: IpcChannelRegistrar = () => { /* NOOP */ };
public withRegistrar(registrar: IpcChannelRegistrar): this {
this.registrar = registrar;
return this;
}
@@ -82,26 +95,37 @@ class IpcRegistrationTestSetup {
return this;
}
public withDialogFactory(dialogFactory: DialogFactory): this {
this.dialogFactory = dialogFactory;
return this;
}
public run() {
registerAllIpcChannels(
this.codeRunnerFactory,
this.dialogFactory,
this.registrar,
);
}
}
type DefinedIpcChannelTypes = {
[K in ChannelDefinitionKey]: (typeof IpcChannelDefinitions)[K]
}[ChannelDefinitionKey];
function createIpcRegistrarMock() {
const registeredChannels = new Array<Parameters<IpcRegistrar>>();
const registrarMock: IpcRegistrar = <T>(channel: IpcChannel<T>, obj: T) => {
const registeredChannels = new Array<Parameters<IpcChannelRegistrar>>();
const registrarMock: IpcChannelRegistrar = <T>(channel: IpcChannel<T>, obj: T) => {
registeredChannels.push([channel as IpcChannel<unknown>, obj]);
};
const isChannelRegistered = <T>(channel: IpcChannel<T>): boolean => {
const isChannelRegistered = (channel: DefinedIpcChannelTypes): boolean => {
return registeredChannels.some((i) => i[0] === channel);
};
const getRegisteredInstance = <T>(channel: IpcChannel<T>): unknown => {
const getRegisteredInstance = <T>(channel: IpcChannel<T>): T => {
const registration = registeredChannels.find((i) => i[0] === channel);
expectExists(registration);
return registration[1];
const [, registeredInstance] = registration;
return registeredInstance as T;
};
return {
registrarMock,

3
tests/unit/presentation/electron/preload/ContextBridging/RendererApiProvider.spec.ts
View File

@@ -16,7 +16,7 @@ describe('RendererApiProvider', () => {
readonly expectedValue: unknown;
}
const testScenarios: Record<PropertyKeys<Required<WindowVariables>>, WindowVariableTestCase> = {
isDesktop: {
isRunningAsDesktopApplication: {
description: 'returns true',
setupContext: (context) => context,
expectedValue: true,
@@ -34,6 +34,7 @@ describe('RendererApiProvider', () => {
instance: new LoggerStub(),
setupContext: (c, logger) => c.withLogger(logger),
}),
dialog: expectIpcConsumer(IpcChannelDefinitions.Dialog),
};
Object.entries(testScenarios).forEach((
[property, { description, setupContext, expectedValue }],

10
tests/unit/presentation/electron/shared/IpcChannelDefinitions.spec.ts
View File

@@ -1,10 +1,10 @@
import { describe, it, expect } from 'vitest';
import { IpcChannel } from '@/presentation/electron/shared/IpcBridging/IpcChannel';
import { IpcChannelDefinitions } from '@/presentation/electron/shared/IpcBridging/IpcChannelDefinitions';
import { ChannelDefinitionKey, IpcChannelDefinitions } from '@/presentation/electron/shared/IpcBridging/IpcChannelDefinitions';
describe('IpcChannelDefinitions', () => {
it('defines IPC channels correctly', () => {
const testScenarios: Record<keyof typeof IpcChannelDefinitions, {
const testScenarios: Record<ChannelDefinitionKey, {
readonly expectedNamespace: string;
readonly expectedAccessibleMembers: readonly string[];
}> = {
@@ -12,6 +12,10 @@ describe('IpcChannelDefinitions', () => {
expectedNamespace: 'code-run',
expectedAccessibleMembers: ['runCode'],
},
Dialog: {
expectedNamespace: 'dialogs',
expectedAccessibleMembers: ['saveFile'],
},
};
Object.entries(testScenarios).forEach((
[definitionKey, { expectedNamespace, expectedAccessibleMembers }],
@@ -49,7 +53,7 @@ describe('IpcChannelDefinitions', () => {
it('has unique accessible members within each channel', () => {
Object.values(IpcChannelDefinitions).forEach((channel) => {
// arrange
const { accessibleMembers: accessibleMembersOfChannel } = channel;
const accessibleMembersOfChannel = channel.accessibleMembers as string[];
// act
const repeatedAccessibleMembersInChannel = accessibleMembersOfChannel
.filter((item, index) => accessibleMembersOfChannel.indexOf(item) !== index);

42
tests/unit/presentation/electron/shared/IpcProxy.spec.ts
View File

@@ -215,19 +215,35 @@ describe('IpcProxy', () => {
expect(actualChannelNames).to.have.lengthOf(expectedChannelNames.length);
expect(actualChannelNames).to.have.members(expectedChannelNames);
});
it('throws error for non-function members', () => {
// arrange
const expectedError = 'Non-function members are not yet supported';
const propertyName = 'propertyKey';
const testObject = { [`${propertyName}`]: 123 };
const testIpcChannel: IpcChannel<typeof testObject> = {
namespace: 'testNamespace',
accessibleMembers: [propertyName] as never,
};
// act
const act = () => registerIpcChannel(testIpcChannel, testObject, mockIpcMain().ipcMainMock);
// assert
expect(act).to.throw(expectedError);
describe('validation', () => {
it('throws error for non-function members', () => {
// arrange
const expectedError = 'Non-function members are not yet supported';
const propertyName = 'propertyKey';
const testObject = { [`${propertyName}`]: 123 };
const testIpcChannel: IpcChannel<typeof testObject> = {
namespace: 'testNamespace',
accessibleMembers: [propertyName] as never,
};
// act
const act = () => registerIpcChannel(testIpcChannel, testObject, mockIpcMain().ipcMainMock);
// assert
expect(act).to.throw(expectedError);
});
it('throws error for undefined members', () => {
// arrange
const nonExistingFunctionName = 'nonExistingFunction';
const expectedError = `The function "${nonExistingFunctionName}" is not found on the target object.`;
const testObject = { };
const testIpcChannel: IpcChannel<typeof testObject> = {
namespace: 'testNamespace',
accessibleMembers: [nonExistingFunctionName] as never,
};
// act
const act = () => registerIpcChannel(testIpcChannel, testObject, mockIpcMain().ipcMainMock);
// assert
expect(act).to.throw(expectedError);
});
});
});
});

7
tests/unit/shared/Stubs/DialogStub.ts Normal file
View File

@@ -0,0 +1,7 @@
import { Dialog } from '@/presentation/common/Dialog';
export class DialogStub implements Dialog {
public saveFile(): Promise<void> {
return Promise.resolve();
}
}

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

@@ -1,12 +0,0 @@
import { Logger } from '@/application/Common/Log/Logger';
import { LoggerFactory } from '@/application/Common/Log/LoggerFactory';
import { LoggerStub } from './LoggerStub';
export class LoggerFactoryStub implements LoggerFactory {
public logger: Logger = new LoggerStub();
public withLogger(logger: Logger): this {
this.logger = logger;
return this;
}
}

6
tests/unit/shared/Stubs/RuntimeEnvironmentStub.ts
View File

@@ -4,7 +4,7 @@ import { OperatingSystem } from '@/domain/OperatingSystem';
export class RuntimeEnvironmentStub implements RuntimeEnvironment {
public isNonProduction = true;
public isDesktop = true;
public isRunningAsDesktopApplication = false;
public os: OperatingSystem | undefined = OperatingSystem.Windows;
@@ -13,8 +13,8 @@ export class RuntimeEnvironmentStub implements RuntimeEnvironment {
return this;
}
public withIsDesktop(isDesktop: boolean): this {
this.isDesktop = isDesktop;
public withIsRunningAsDesktopApplication(isRunningAsDesktopApplication: boolean): this {
this.isRunningAsDesktopApplication = isRunningAsDesktopApplication;
return this;
}

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

@@ -2,25 +2,34 @@ import { OperatingSystem } from '@/domain/OperatingSystem';
import { Logger } from '@/application/Common/Log/Logger';
import { WindowVariables } from '@/infrastructure/WindowVariables/WindowVariables';
import { CodeRunner } from '@/application/CodeRunner/CodeRunner';
import { Dialog } from '@/presentation/common/Dialog';
import { LoggerStub } from './LoggerStub';
import { CodeRunnerStub } from './CodeRunnerStub';
import { DialogStub } from './DialogStub';
export class WindowVariablesStub implements WindowVariables {
public codeRunner?: CodeRunner = new CodeRunnerStub();
public isDesktop = false;
public isRunningAsDesktopApplication: true | undefined = true;
public os?: OperatingSystem = OperatingSystem.BlackBerryOS;
public log: Logger = new LoggerStub();
public log?: Logger = new LoggerStub();
public dialog?: Dialog = new DialogStub();
public withLog(log: Logger): this {
this.log = log;
return this;
}
public withIsDesktop(value: boolean): this {
this.isDesktop = value;
public withDialog(dialog: Dialog): this {
this.dialog = dialog;
return this;
}
public withIsRunningAsDesktopApplication(isRunningAsDesktopApplication: true | undefined): this {
this.isRunningAsDesktopApplication = isRunningAsDesktopApplication;
return this;
}