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

Centralize log file and refactor desktop logging

Browse Source 
- Migrate to `electron-log` v5.X.X, centralizing log files to adhere to
  best-practices.
- Add critical event logging in the log file.
- Replace `ElectronLog` type with `LogFunctions` for better abstraction.
- Unify log handling in `desktop-runtime-error` by removing
  `renderer.log` due to `electron-log` v5 changes.
- Update and extend logger interfaces, removing 'I' prefix and adding
  common log levels to abstract `electron-log` completely.
- Move logger interfaces to the application layer as it's cross-cutting
  concern, meanwhile keeping the implementations in the infrastructure
  layer.
- Introduce `useLogger` hook for easier logging in Vue components.
- Simplify `WindowVariables` by removing nullable properties.
- Improve documentation to clearly differentiate between desktop and web
  versions, outlining specific features of each.
This commit is contained in:
undergroundwires
2023-12-02 11:50:25 +01:00
parent 8f5d7ed3cf
commit 08dbfead7c
40 changed files with 347 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
tests/unit/infrastructure/Log/ConsoleLogger.spec.ts
View File

@@ -32,21 +32,6 @@ describe('ConsoleLogger', () => {
expect(consoleMock.callHistory[0].args).to.deep.equal(expectedParams);
});
});
describe('throws if log function is missing', () => {
itEachLoggingMethod((functionName, testParameters) => {
// arrange
const expectedError = `missing "${functionName}" function`;
const consoleMock = {} as Partial<Console>;
consoleMock[functionName] = undefined;
const logger = new ConsoleLogger(consoleMock);
// act
const act = () => logger[functionName](...testParameters);
// assert
expect(act).to.throw(expectedError);
});
});
});
class MockConsole
@@ -58,4 +43,25 @@ class MockConsole
args,
});
}
public warn(...args: unknown[]) {
this.registerMethodCall({
methodName: 'warn',
args,
});
}
public debug(...args: unknown[]) {
this.registerMethodCall({
methodName: 'debug',
args,
});
}
public error(...args: unknown[]) {
this.registerMethodCall({
methodName: 'error',
args,
});
}
}

79
tests/unit/infrastructure/Log/ElectronLogger.spec.ts
View File

@@ -1,42 +1,15 @@
import { describe, expect } from 'vitest';
import { ElectronLog } from 'electron-log';
import { StubWithObservableMethodCalls } from '@tests/unit/shared/Stubs/StubWithObservableMethodCalls';
import { createElectronLogger } from '@/infrastructure/Log/ElectronLogger';
import { itEachAbsentObjectValue } from '@tests/unit/shared/TestCases/AbsentTests';
import { itEachLoggingMethod } from './LoggerTestRunner';
import type { LogFunctions } from 'electron-log';
describe('ElectronLogger', () => {
describe('throws if logger is missing', () => {
itEachAbsentObjectValue((absentValue) => {
// arrange
const expectedError = 'missing logger';
const electronLog = absentValue as never;
// act
const act = () => createElectronLogger(electronLog);
// assert
expect(act).to.throw(expectedError);
}, { excludeUndefined: true });
});
describe('throws if log function is missing', () => {
itEachLoggingMethod((functionName, testParameters) => {
// arrange
const expectedError = `missing "${functionName}" function`;
const electronLogMock = {} as Partial<ElectronLog>;
electronLogMock[functionName] = undefined;
const logger = createElectronLogger(electronLogMock);
// act
const act = () => logger[functionName](...testParameters);
// assert
expect(act).to.throw(expectedError);
});
});
describe('methods log the provided params', () => {
itEachLoggingMethod((functionName, testParameters) => {
// arrange
const expectedParams = testParameters;
const electronLogMock = new MockElectronLog();
const electronLogMock = new ElectronLogStub();
const logger = createElectronLogger(electronLogMock);
// act
@@ -50,9 +23,51 @@ describe('ElectronLogger', () => {
});
});
class MockElectronLog
extends StubWithObservableMethodCalls<ElectronLog>
implements Partial<ElectronLog> {
class ElectronLogStub
extends StubWithObservableMethodCalls<LogFunctions>
implements LogFunctions {
public error(...args: unknown[]) {
this.registerMethodCall({
methodName: 'error',
args,
});
}
public warn(...args: unknown[]) {
this.registerMethodCall({
methodName: 'warn',
args,
});
}
public verbose(...args: unknown[]): void {
this.registerMethodCall({
methodName: 'verbose',
args,
});
}
public debug(...args: unknown[]) {
this.registerMethodCall({
methodName: 'debug',
args,
});
}
public silly(...args: unknown[]) {
this.registerMethodCall({
methodName: 'silly',
args,
});
}
public log(...args: unknown[]) {
this.registerMethodCall({
methodName: 'log',
args,
});
}
public info(...args: unknown[]) {
this.registerMethodCall({
methodName: 'info',

28
tests/unit/infrastructure/Log/LoggerTestRunner.ts
View File

@@ -1,23 +1,25 @@
import { it } from 'vitest';
import { FunctionKeys } from '@/TypeHelpers';
import { ILogger } from '@/infrastructure/Log/ILogger';
type TestParameters = [string, number, { some: string }];
import { Logger } from '@/application/Common/Log/Logger';
export function itEachLoggingMethod(
handler: (
functionName: keyof ILogger,
testParameters: TestParameters,
functionName: keyof Logger,
testParameters: readonly unknown[]
) => void,
) {
const testParameters: TestParameters = ['test', 123, { some: 'object' }];
const loggerMethods: Array<FunctionKeys<ILogger>> = [
'info',
];
loggerMethods
.forEach((functionKey) => {
const testScenarios: {
readonly [FunctionName in keyof Logger]: Parameters<Logger[FunctionName]>;
} = {
info: ['single-string'],
warn: ['with number', 123],
debug: ['with simple object', { some: 'object' }],
error: ['with error object', new Error('error')],
};
Object.entries(testScenarios)
.forEach(([functionKey, testParameters]) => {
it(functionKey, () => {
handler(functionKey, testParameters);
handler(functionKey as keyof Logger, testParameters);
});
});
}

4
tests/unit/infrastructure/Log/NoopLogger.spec.ts
View File

@@ -1,6 +1,6 @@
import { describe, expect } from 'vitest';
import { NoopLogger } from '@/infrastructure/Log/NoopLogger';
import { ILogger } from '@/infrastructure/Log/ILogger';
import { Logger } from '@/application/Common/Log/Logger';
import { itEachLoggingMethod } from './LoggerTestRunner';
describe('NoopLogger', () => {
@@ -8,7 +8,7 @@ describe('NoopLogger', () => {
itEachLoggingMethod((functionName, testParameters) => {
// arrange
const randomParams = testParameters;
const logger: ILogger = new NoopLogger();
const logger: Logger = new NoopLogger();
// act
const act = () => logger[functionName](...randomParams);

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

@@ -177,10 +177,11 @@ function expectObjectOnDesktop<T>(key: keyof WindowVariables) {
describe('does not object type when not on desktop', () => {
itEachInvalidObjectValue((invalidObjectValue) => {
// arrange
const isOnDesktop = false;
const invalidObject = invalidObjectValue as T;
const input: WindowVariables = {
...new WindowVariablesStub(),
isDesktop: undefined,
isDesktop: isOnDesktop,
[key]: invalidObject,
};
// act

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

@@ -3,7 +3,7 @@ import {
} from 'vitest';
import { IRuntimeEnvironment } from '@/infrastructure/RuntimeEnvironment/IRuntimeEnvironment';
import { ClientLoggerFactory } from '@/presentation/bootstrapping/ClientLoggerFactory';
import { ILogger } from '@/infrastructure/Log/ILogger';
import { Logger } from '@/application/Common/Log/Logger';
import { WindowInjectedLogger } from '@/infrastructure/Log/WindowInjectedLogger';
import { ConsoleLogger } from '@/infrastructure/Log/ConsoleLogger';
import { NoopLogger } from '@/infrastructure/Log/NoopLogger';
@@ -29,7 +29,7 @@ describe('ClientLoggerFactory', () => {
});
const testCases: Array<{
readonly description: string,
readonly expectedType: Constructible<ILogger>,
readonly expectedType: Constructible<Logger>,
readonly environment: IRuntimeEnvironment,
}> = [
{

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

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

17
tests/unit/presentation/components/Shared/Hooks/UseLogger.spec.ts Normal file
View File

@@ -0,0 +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';
describe('UseLogger', () => {
it('returns expected logger from factory', () => {
// arrange
const expectedLogger = new LoggerStub();
const factory = new LoggerFactoryStub()
.withLogger(expectedLogger);
// act
const { log: actualLogger } = useLogger(factory);
// assert
expect(actualLogger).to.equal(expectedLogger);
});
});

6
tests/unit/presentation/electron/preload/WindowVariablesProvider.spec.ts
View File

@@ -3,7 +3,7 @@ import { provideWindowVariables } from '@/presentation/electron/preload/WindowVa
import { SystemOperationsStub } from '@tests/unit/shared/Stubs/SystemOperationsStub';
import { OperatingSystem } from '@/domain/OperatingSystem';
import { ISystemOperations } from '@/infrastructure/SystemOperations/ISystemOperations';
import { ILogger } from '@/infrastructure/Log/ILogger';
import { Logger } from '@/application/Common/Log/Logger';
import { LoggerStub } from '@tests/unit/shared/Stubs/LoggerStub';
describe('WindowVariablesProvider', () => {
@@ -55,7 +55,7 @@ class TestContext {
private os: OperatingSystem = OperatingSystem.Android;
private log: ILogger = new LoggerStub();
private log: Logger = new LoggerStub();
public withSystem(system: ISystemOperations): this {
this.system = system;
@@ -67,7 +67,7 @@ class TestContext {
return this;
}
public withLogger(log: ILogger): this {
public withLogger(log: Logger): this {
this.log = log;
return this;
}

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

@@ -0,0 +1,12 @@
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;
}
}

26
tests/unit/shared/Stubs/LoggerStub.ts
View File

@@ -1,12 +1,32 @@
import { ILogger } from '@/infrastructure/Log/ILogger';
import { Logger } from '@/application/Common/Log/Logger';
import { StubWithObservableMethodCalls } from './StubWithObservableMethodCalls';
export class LoggerStub extends StubWithObservableMethodCalls<ILogger> implements ILogger {
export class LoggerStub extends StubWithObservableMethodCalls<Logger> implements Logger {
public warn(...params: unknown[]): void {
this.registerMethodCall({
methodName: 'warn',
args: params,
});
}
public error(...params: unknown[]): void {
this.registerMethodCall({
methodName: 'error',
args: params,
});
}
public debug(...params: unknown[]): void {
this.registerMethodCall({
methodName: 'debug',
args: params,
});
}
public info(...params: unknown[]): void {
this.registerMethodCall({
methodName: 'info',
args: params,
});
console.log(...params);
}
}

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

@@ -1,5 +1,5 @@
import { OperatingSystem } from '@/domain/OperatingSystem';
import { ILogger } from '@/infrastructure/Log/ILogger';
import { Logger } from '@/application/Common/Log/Logger';
import { ISystemOperations } from '@/infrastructure/SystemOperations/ISystemOperations';
import { WindowVariables } from '@/infrastructure/WindowVariables/WindowVariables';
import { SystemOperationsStub } from './SystemOperationsStub';
@@ -8,18 +8,18 @@ import { LoggerStub } from './LoggerStub';
export class WindowVariablesStub implements WindowVariables {
public system?: ISystemOperations = new SystemOperationsStub();
public isDesktop? = false;
public isDesktop = false;
public os?: OperatingSystem = OperatingSystem.BlackBerryOS;
public log?: ILogger = new LoggerStub();
public log: Logger = new LoggerStub();
public withLog(log?: ILogger): this {
public withLog(log: Logger): this {
this.log = log;
return this;
}
public withIsDesktop(value?: boolean): this {
public withIsDesktop(value: boolean): this {
this.isDesktop = value;
return this;
}