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
@@ -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
126
tests/unit/infrastructure/Dialog/Browser/FileSaverDialog.spec.ts
Normal 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,
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -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]);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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) => {
|
||||
|
||||
@@ -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', () => {
|
||||
|
||||
@@ -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'];
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user