logger factory tests

Author: raju-opti

lib/logging/logger_factory.spec.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+vi.mock('./logger', async (importOriginal) => {
+  const actual = await importOriginal()
+
+  const MockLogger = vi.fn();
+  const MockConsoleLogHandler = vi.fn();
+
+  return { ...actual as any, OptimizelyLogger: MockLogger, ConsoleLogHandler: MockConsoleLogHandler };
+});
+
+import { OptimizelyLogger, ConsoleLogHandler, LogLevel } from './logger';
+import { createLogger, extractLogger, InfoLog } from './logger_factory';
+import { errorResolver, infoResolver } from '../message/message_resolver';
+
+describe('create', () => {
+  const MockedOptimizelyLogger = vi.mocked(OptimizelyLogger);
+  const MockedConsoleLogHandler = vi.mocked(ConsoleLogHandler);
+
+  beforeEach(() => {
+    MockedConsoleLogHandler.mockClear();
+    MockedOptimizelyLogger.mockClear();
+  });
+
+  it('should use the passed in options and a default name Optimizely', () => {
+    const mockLogHandler = { log: vi.fn() };
+
+    const logger = extractLogger(createLogger({
+      level: InfoLog,
+      logHandler: mockLogHandler,
+    }));
+
+    expect(logger).toBe(MockedOptimizelyLogger.mock.instances[0]);
+    const { name, level, infoMsgResolver, errorMsgResolver, logHandler } = MockedOptimizelyLogger.mock.calls[0][0];
+    expect(name).toBe('Optimizely');
+    expect(level).toBe(LogLevel.Info);
+    expect(infoMsgResolver).toBe(infoResolver);
+    expect(errorMsgResolver).toBe(errorResolver);
+    expect(logHandler).toBe(mockLogHandler);
+  });
+
+  it('should use a ConsoleLogHandler if no logHandler is provided', () => {
+    const logger = extractLogger(createLogger({
+      level: InfoLog,
+    }));
+
+    expect(logger).toBe(MockedOptimizelyLogger.mock.instances[0]);
+    const { logHandler } = MockedOptimizelyLogger.mock.calls[0][0];
+    expect(logHandler).toBe(MockedConsoleLogHandler.mock.instances[0]);
+  });
+});

lib/logging/logger_factory.ts

@@ -1,20 +1,87 @@
-// import { LogLevel, LogResolver } from './logger';
+import { ConsoleLogHandler, LogHandler, LogLevel, OptimizelyLogger } from './logger';
+import { errorResolver, infoResolver, MessageResolver } from '../message/message_resolver';
 
-// type LevelPreset = {
-//   level: LogLevel;
-//   resolver?: LogResolver;
-// }
+type LevelPreset = {
+  level: LogLevel,
+  infoResolver?: MessageResolver,
+  errorResolver: MessageResolver,
+}
 
-// const levelPresetSymbol = Symbol('levelPreset');
+const debugPreset: LevelPreset = {
+  level: LogLevel.Debug,
+  infoResolver,
+  errorResolver,
+};
 
-// export type OpaqueLevelPreset = {
-//   [levelPresetSymbol]: unknown;
-// };
+const infoPreset: LevelPreset = {
+  level: LogLevel.Info,
+  infoResolver,
+  errorResolver,
+}
 
-// const Info: LevelPreset = {
-//   level: LogLevel.Info,
-// };
+const warnPreset: LevelPreset = {
+  level: LogLevel.Warn,
+  errorResolver,
+}
 
-// export const InfoLog: OpaqueLevelPreset = {
-//   [levelPresetSymbol]: Info,
-// };
+const errorPreset: LevelPreset = {
+  level: LogLevel.Error,
+  errorResolver,
+}
+
+const levelPresetSymbol = Symbol();
+
+export type OpaqueLevelPreset = {
+  [levelPresetSymbol]: unknown;
+};
+
+export const DebugLog: OpaqueLevelPreset = {
+  [levelPresetSymbol]: debugPreset,
+};
+
+export const InfoLog: OpaqueLevelPreset = {
+  [levelPresetSymbol]: infoPreset,
+};
+
+export const WarnLog: OpaqueLevelPreset = {
+  [levelPresetSymbol]: warnPreset,
+};
+
+export const ErrorLog: OpaqueLevelPreset = {
+  [levelPresetSymbol]: errorPreset,
+};
+
+export const extractLevelPreset = (preset: OpaqueLevelPreset): LevelPreset => {
+  return preset[levelPresetSymbol] as LevelPreset;
+}
+
+const loggerSymbol = Symbol();
+
+export type OpaqueLogger = {
+  [loggerSymbol]: unknown;
+};
+
+export type LoggerConfig = {
+  level: OpaqueLevelPreset,
+  logHandler?: LogHandler,
+};
+
+export const createLogger = (config: LoggerConfig): OpaqueLogger => {
+  const { level, infoResolver, errorResolver } = extractLevelPreset(config.level);
+  
+  const loggerName = 'Optimizely';
+
+  return {
+    [loggerSymbol]: new OptimizelyLogger({
+      name: loggerName,
+      level,
+      infoMsgResolver: infoResolver,
+      errorMsgResolver: errorResolver,
+      logHandler: config.logHandler || new ConsoleLogHandler(),
+    }),
+  };
+};
+
+export const extractLogger = (logger: OpaqueLogger): OptimizelyLogger => {
+  return logger[loggerSymbol] as OptimizelyLogger;
+}

vitest.config.mts

@@ -20,7 +20,7 @@ export default defineConfig({
   test: {
     onConsoleLog: () => true,
     environment: 'happy-dom',
-    include: ['**/logger.spec.ts'],
+    include: ['**/logger_factory.spec.ts'],
     typecheck: {
       tsconfig: 'tsconfig.spec.json',
     },