standard-log 6.2.6 → 7.0.0

package/src/console/createConsoleLogReporter.spec.ts

@@ -1,177 +1,185 @@
-import a from 'assertron';
-import { addCustomLogLevel, clearCustomLogLevel, ConsoleLogFormatter, createConsoleLogReporter, LogFilter, logLevels, plainLogFormatter } from '..';
-import { config } from '../config';
-import { ProhibitedDuringProduction } from '../errors';
-import { store } from '../store';
-
-beforeEach(() => {
-  store.reset()
-  config({ mode: 'test' })
-})
+import a from 'assertron'
+import {
+  addCustomLogLevel, clearCustomLogLevel, config, configForTest,
+  ConsoleLogFormatter, createConsoleLogReporter,
+  LogFilter, logLevels, plainLogFormatter, ProhibitedDuringProduction
+} from '..'
+import { store } from '../store'
 
-describe('rendering tests', () => {
-  test('plain rendering', () => {
-    const reporter = createConsoleLogReporter({ formatter: plainLogFormatter });
-    ['emergency', 'info', 'warn', 'debug'].forEach(level => {
-      reporter.write({ id: 'plain', level: (logLevels as any)[level], args: ['hello', 'world'], timestamp: new Date() })
-    })
-  })
-})
+describe('production checks', () => {
+  beforeEach(() => store.reset())
 
-describe('id', () => {
-  test('default is "console"', () => {
+  test('set filter during production mode throws', () => {
+    config({ mode: 'production' })
     const reporter = createConsoleLogReporter()
-    expect(reporter.id).toBe('console')
+    a.throws(() => { reporter.filter = () => true }, ProhibitedDuringProduction)
   })
-  test('can be overridden', () => {
-    const reporter = createConsoleLogReporter({ id: 'neo-console' })
-    expect(reporter.id).toBe('neo-console')
+
+  const idFormatter: ConsoleLogFormatter = (entry) => [entry.id]
+  test('set formatter during production mode throws', () => {
+    config({ mode: 'production' })
+    const reporter = createConsoleLogReporter()
+    a.throws(() => reporter.formatter = idFormatter, ProhibitedDuringProduction)
   })
 })
 
-describe('log level', () => {
-  test('error, alert, critical and emergency logs are written to console.error', () => {
-    const id = 'log'
-    const reporter = createConsoleLogReporter()
-    const fakeConsole = reporter.console = createFakeConsole();
 
-    reporter.write({ id, level: logLevels.emergency, args: ['emergency'], timestamp: new Date() })
-    reporter.write({ id, level: logLevels.critical, args: ['critical'], timestamp: new Date() })
-    reporter.write({ id, level: logLevels.alert, args: ['alert'], timestamp: new Date() })
-    reporter.write({ id, level: logLevels.error, args: ['error'], timestamp: new Date() })
+describe('unit tests', () => {
+  beforeEach(() => configForTest())
 
-    expect(fakeConsole.errors.length).toBe(4)
+  describe('rendering tests', () => {
+    test('plain rendering', () => {
+      const reporter = createConsoleLogReporter({ formatter: plainLogFormatter });
+      ['emergency', 'info', 'warn', 'debug'].forEach(level => {
+        reporter.write({ id: 'plain', level: (logLevels as any)[level], args: ['hello', 'world'], timestamp: new Date() })
+      })
+    })
   })
 
-  test('warn logs are written to console.warn', () => {
-    const id = 'log'
-    const reporter = createConsoleLogReporter()
-
-    const fakeConsole = reporter.console = createFakeConsole();
+  describe('id', () => {
+    test('default is "console"', () => {
+      const reporter = createConsoleLogReporter()
+      expect(reporter.id).toBe('console')
+    })
+    test('can be overridden', () => {
+      const reporter = createConsoleLogReporter({ id: 'neo-console' })
+      expect(reporter.id).toBe('neo-console')
+    })
+  })
 
-    reporter.write({ id, level: logLevels.warn, args: ['warn'], timestamp: new Date() })
+  describe('log level', () => {
+    test('error, alert, critical and emergency logs are written to console.error', () => {
+      const id = 'log'
+      const reporter = createConsoleLogReporter()
+      const fakeConsole = reporter.console = createFakeConsole()
 
-    expect(fakeConsole.warns.length).toBe(1)
-  })
+      reporter.write({ id, level: logLevels.emergency, args: ['emergency'], timestamp: new Date() })
+      reporter.write({ id, level: logLevels.critical, args: ['critical'], timestamp: new Date() })
+      reporter.write({ id, level: logLevels.alert, args: ['alert'], timestamp: new Date() })
+      reporter.write({ id, level: logLevels.error, args: ['error'], timestamp: new Date() })
 
-  test('notice and info logs are written to console.info', () => {
-    const id = 'log'
-    const reporter = createConsoleLogReporter()
+      expect(fakeConsole.errors.length).toBe(4)
+    })
 
-    const fakeConsole = reporter.console = createFakeConsole();
+    test('warn logs are written to console.warn', () => {
+      const id = 'log'
+      const reporter = createConsoleLogReporter()
 
-    reporter.write({ id, level: logLevels.notice, args: ['notice'], timestamp: new Date() })
-    reporter.write({ id, level: logLevels.info, args: ['info'], timestamp: new Date() })
+      const fakeConsole = reporter.console = createFakeConsole()
 
-    expect(fakeConsole.infos.length).toBe(2)
-  })
+      reporter.write({ id, level: logLevels.warn, args: ['warn'], timestamp: new Date() })
 
+      expect(fakeConsole.warns.length).toBe(1)
+    })
 
-  test('debug, trace, and planck logs are written to console.debug', () => {
-    const id = 'log'
-    const reporter = createConsoleLogReporter()
-    const fakeConsole = reporter.console = createFakeConsole();
+    test('notice and info logs are written to console.info', () => {
+      const id = 'log'
+      const reporter = createConsoleLogReporter()
 
-    reporter.write({ id, level: logLevels.debug, args: ['debug'], timestamp: new Date() })
-    reporter.write({ id, level: logLevels.trace, args: ['trace'], timestamp: new Date() })
-    reporter.write({ id, level: logLevels.planck, args: ['planck'], timestamp: new Date() })
+      const fakeConsole = reporter.console = createFakeConsole()
 
-    expect(fakeConsole.debugs.length).toBe(3)
-  })
-})
+      reporter.write({ id, level: logLevels.notice, args: ['notice'], timestamp: new Date() })
+      reporter.write({ id, level: logLevels.info, args: ['info'], timestamp: new Date() })
 
-describe('custom logs', () => {
-  afterEach(() => clearCustomLogLevel())
+      expect(fakeConsole.infos.length).toBe(2)
+    })
 
-  test('are written according to their log level value', () => {
-    addCustomLogLevel('high', 50)
-    addCustomLogLevel('important', 450)
-    addCustomLogLevel('interest', 650)
-    addCustomLogLevel('silly', 1000)
 
-    const id = 'log'
-    const reporter = createConsoleLogReporter()
-    const fakeConsole = reporter.console = createFakeConsole();
+    test('debug, trace, and planck logs are written to console.debug', () => {
+      const id = 'log'
+      const reporter = createConsoleLogReporter()
+      const fakeConsole = reporter.console = createFakeConsole()
 
-    reporter.write({ id, level: 50, args: ['a'], timestamp: new Date() })
-    reporter.write({ id, level: 450, args: ['b'], timestamp: new Date() })
-    reporter.write({ id, level: 650, args: ['c'], timestamp: new Date() })
-    reporter.write({ id, level: 1000, args: ['d'], timestamp: new Date() })
+      reporter.write({ id, level: logLevels.debug, args: ['debug'], timestamp: new Date() })
+      reporter.write({ id, level: logLevels.trace, args: ['trace'], timestamp: new Date() })
+      reporter.write({ id, level: logLevels.planck, args: ['planck'], timestamp: new Date() })
 
-    expect(fakeConsole.errors.length).toBe(1)
-    expect(fakeConsole.warns.length).toBe(1)
-    expect(fakeConsole.infos.length).toBe(1)
-    expect(fakeConsole.debugs.length).toBe(1)
+      expect(fakeConsole.debugs.length).toBe(3)
+    })
   })
-})
 
-const idFormatter: ConsoleLogFormatter = (entry) => [entry.id]
+  describe('custom logs', () => {
+    afterEach(() => clearCustomLogLevel())
 
-describe('formatter', () => {
-  test('use specific formatter', () => {
-    const id = 'id-only'
-    const reporter = createConsoleLogReporter({ formatter: idFormatter })
-    const fakeConsole = reporter.console = createFakeConsole();
+    test('are written according to their log level value', () => {
+      addCustomLogLevel('high', 50)
+      addCustomLogLevel('important', 450)
+      addCustomLogLevel('interest', 650)
+      addCustomLogLevel('silly', 1000)
 
-    reporter.write({ id, level: logLevels.emergency, args: ['emergency'], timestamp: new Date() })
+      const id = 'log'
+      const reporter = createConsoleLogReporter()
+      const fakeConsole = reporter.console = createFakeConsole()
 
-    expect(fakeConsole.errors).toEqual([['id-only']])
-  })
+      reporter.write({ id, level: 50, args: ['a'], timestamp: new Date() })
+      reporter.write({ id, level: 450, args: ['b'], timestamp: new Date() })
+      reporter.write({ id, level: 650, args: ['c'], timestamp: new Date() })
+      reporter.write({ id, level: 1000, args: ['d'], timestamp: new Date() })
 
-  test('formatter can be changed afterward', () => {
-    const reporter = createConsoleLogReporter()
-    const formatter = reporter.formatter
-    reporter.formatter = idFormatter
-    expect(reporter.formatter).not.toEqual(formatter)
+      expect(fakeConsole.errors.length).toBe(1)
+      expect(fakeConsole.warns.length).toBe(1)
+      expect(fakeConsole.infos.length).toBe(1)
+      expect(fakeConsole.debugs.length).toBe(1)
+    })
   })
 
-  test('set formatter during production mode throws', () => {
-    config({ mode: 'production' })
-    const reporter = createConsoleLogReporter()
-    a.throws(() => reporter.formatter = idFormatter, ProhibitedDuringProduction)
-  })
-})
+  const idFormatter: ConsoleLogFormatter = (entry) => [entry.id]
 
-describe('filter', () => {
-  const filter: LogFilter = (entry) => entry.id !== 'secret'
-  test('use specific filter', () => {
-    const reporter = createConsoleLogReporter({ formatter: idFormatter, filter })
-    const fakeConsole = reporter.console = createFakeConsole();
+  describe('formatter', () => {
+    test('use specific formatter', () => {
+      const id = 'id-only'
+      const reporter = createConsoleLogReporter({ formatter: idFormatter })
+      const fakeConsole = reporter.console = createFakeConsole()
 
-    reporter.write({ id: 'normal', level: logLevels.emergency, args: ['emergency'], timestamp: new Date() })
-    reporter.write({ id: 'secret', level: logLevels.emergency, args: ['emergency'], timestamp: new Date() })
+      reporter.write({ id, level: logLevels.emergency, args: ['emergency'], timestamp: new Date() })
 
-    expect(fakeConsole.errors).toEqual([['normal']])
-  })
+      expect(fakeConsole.errors).toEqual([['id-only']])
+    })
 
-  test('can change filter', () => {
-    const reporter = createConsoleLogReporter()
-    const filter = reporter.filter
-    reporter.filter = entry => entry.id !== 'secret'
-    expect(reporter.filter).not.toEqual(filter)
+    test('formatter can be changed afterward', () => {
+      const reporter = createConsoleLogReporter()
+      const formatter = reporter.formatter
+      reporter.formatter = idFormatter
+      expect(reporter.formatter).not.toEqual(formatter)
+    })
   })
 
-  test('set filter during production mode throws', () => {
-    config({ mode: 'production' })
-    const reporter = createConsoleLogReporter()
-    a.throws(() => { reporter.filter = () => true }, ProhibitedDuringProduction)
+  describe('filter', () => {
+    const filter: LogFilter = (entry) => entry.id !== 'secret'
+    test('use specific filter', () => {
+      const reporter = createConsoleLogReporter({ formatter: idFormatter, filter })
+      const fakeConsole = reporter.console = createFakeConsole()
+
+      reporter.write({ id: 'normal', level: logLevels.emergency, args: ['emergency'], timestamp: new Date() })
+      reporter.write({ id: 'secret', level: logLevels.emergency, args: ['emergency'], timestamp: new Date() })
+
+      expect(fakeConsole.errors).toEqual([['normal']])
+    })
+
+    test('can change filter', () => {
+      const reporter = createConsoleLogReporter()
+      const filter = reporter.filter
+      reporter.filter = entry => entry.id !== 'secret'
+      expect(reporter.filter).not.toEqual(filter)
+    })
   })
-})
 
-test('write log entry with multiple arguments', () => {
-  const id = 'log'
-  const reporter = createConsoleLogReporter({ formatter: plainLogFormatter })
-  const fakeConsole = reporter.console = createFakeConsole();
+  test('write log entry with multiple arguments', () => {
+    const id = 'log'
+    const reporter = createConsoleLogReporter({ formatter: plainLogFormatter })
+    const fakeConsole = reporter.console = createFakeConsole()
 
-  const entry = { id, level: logLevels.info, args: ['a', 'b', 'c'], timestamp: new Date() }
+    const entry = { id, level: logLevels.info, args: ['a', 'b', 'c'], timestamp: new Date() }
 
-  reporter.write(entry)
+    reporter.write(entry)
 
-  expect(fakeConsole.infos).toEqual([
-    [entry.timestamp.toISOString(), 'log', '(INFO)', 'a', 'b', 'c']
-  ])
+    expect(fakeConsole.infos).toEqual([
+      [entry.timestamp.toISOString(), 'log', '(INFO)', 'a', 'b', 'c']
+    ])
+  })
 })
 
+
 function createFakeConsole() {
   const errors: any[] = []
   const infos: any[] = []

package/src/getLogger.spec.ts

@@ -380,7 +380,7 @@ test('auto configure', async () => {
   expect(store.value.configured).toBeFalsy()
   const log = getLogger('auto config')
 
-  log.error('config is called automatically as expected')
+  log.info('config is called automatically as expected')
 
   await delay(10)
   expect(store.value.configured).toBeTruthy()

package/src/logReporter.spec.ts

@@ -1,88 +1,99 @@
-import a from 'assertron';
-import { addLogReporter, clearLogReporters, config, createMemoryLogReporter, getLogReporter, ProhibitedDuringProduction } from '.';
-import { store } from './store';
-import { createConsoleLogReporter } from './console';
-import { LogFilter } from './types';
-import { logLevels } from './logLevel';
-import { getConsoleReporter, hasConsoleReporter } from './logReporter';
+import a from 'assertron'
+import {
+  addLogReporter, clearLogReporters, config,
+  createConsoleLogReporter, createMemoryLogReporter,
+  getConsoleReporter, getLogReporter, hasConsoleReporter,
+  LogFilter, logLevels, ProhibitedDuringProduction
+} from '.'
+import { store } from './store'
 
-beforeEach(() => {
-  store.reset()
-  config({ mode: 'test' })
-})
+describe('production checks', () => {
+  beforeEach(() => store.reset())
 
-describe('addLogReporter()', () => {
-  test('throws in production mode', () => {
-    config({ mode: 'production' })
-    const reporter = createMemoryLogReporter()
-    a.throws(() => addLogReporter(reporter), ProhibitedDuringProduction)
+  describe('addLogReporter()', () => {
+    test('throws in production mode', () => {
+      config({ mode: 'production' })
+      const reporter = createMemoryLogReporter()
+      a.throws(() => addLogReporter(reporter), ProhibitedDuringProduction)
+    })
   })
 
-  test('adds log reporter', () => {
-    const count = store.value.reporters.length
-    const reporter = createMemoryLogReporter()
-    addLogReporter(reporter)
+  describe('clearLogReporters()', () => {
+    test('throws in production mode', () => {
+      config({ mode: 'production' })
+      a.throws(() => clearLogReporters(), ProhibitedDuringProduction)
+    })
+  })
+})
 
-    expect(store.value.reporters.length).toBe(count + 1)
+describe('unit tests', () => {
+  beforeEach(() => {
+    store.reset()
+    config({ mode: 'test' })
   })
 
-  describe('add another console reporter', () => {
-    test('will not replace existing one', () => {
-      expect(getLogReporter('console')).toBeDefined()
-      addLogReporter(createConsoleLogReporter({ id: 'c2' }))
-      expect(getLogReporter('c2')).toBeUndefined()
-      expect(getLogReporter('console')).toBeDefined()
-    })
+  describe('addLogReporter()', () => {
+    test('adds log reporter', () => {
+      const count = store.value.reporters.length
+      const reporter = createMemoryLogReporter()
+      addLogReporter(reporter)
 
-    test('will carry over existing filter', () => {
-      const filter: LogFilter = entry => entry.level < logLevels.alert
-      addLogReporter(createConsoleLogReporter({ id: 'c2', filter }))
-      addLogReporter(createConsoleLogReporter({ id: 'c3' }))
-      const c3 = getConsoleReporter()!
-      expect(c3.filter).toBe(filter)
+      expect(store.value.reporters.length).toBe(count + 1)
     })
 
-    test('will combine existing filter and new filter', () => {
-      addLogReporter(createConsoleLogReporter({ id: 'c2', filter: entry => entry.level > logLevels.critical }))
-      addLogReporter(createConsoleLogReporter({ id: 'c3', filter: entry => entry.level < logLevels.error }))
-      const c2 = getConsoleReporter()!
-      expect(c2.filter!({ level: logLevels.info } as any)).toBe(false)
-      expect(c2.filter!({ level: logLevels.alert } as any)).toBe(false)
-    })
-  })
-})
+    describe('add another console reporter', () => {
+      test('will not replace existing one', () => {
+        expect(getLogReporter('console')).toBeDefined()
+        addLogReporter(createConsoleLogReporter({ id: 'c2' }))
+        expect(getLogReporter('c2')).toBeUndefined()
+        expect(getLogReporter('console')).toBeDefined()
+      })
 
-describe('getLogReporter()', () => {
-  test('get log reporter by id', () => {
-    expect(getLogReporter('console')).toBeDefined()
-  })
+      test('will carry over existing filter', () => {
+        const filter: LogFilter = entry => entry.level < logLevels.alert
+        addLogReporter(createConsoleLogReporter({ id: 'c2', filter }))
+        addLogReporter(createConsoleLogReporter({ id: 'c3' }))
+        const c3 = getConsoleReporter()!
+        expect(c3.filter).toBe(filter)
+      })
 
-  test('get log reporter with unknown id gets undefined', () => {
-    expect(getLogReporter('blah')).toBeUndefined()
+      test('will combine existing filter and new filter', () => {
+        addLogReporter(createConsoleLogReporter({ id: 'c2', filter: entry => entry.level > logLevels.critical }))
+        addLogReporter(createConsoleLogReporter({ id: 'c3', filter: entry => entry.level < logLevels.error }))
+        const c2 = getConsoleReporter()!
+        expect(c2.filter!({ level: logLevels.info } as any)).toBe(false)
+        expect(c2.filter!({ level: logLevels.alert } as any)).toBe(false)
+      })
+    })
   })
-})
 
-describe('clearLogReporters()', () => {
-  test('throws in production mode', () => {
-    config({ mode: 'production' })
-    a.throws(() => clearLogReporters(), ProhibitedDuringProduction)
+  describe('getLogReporter()', () => {
+    test('get log reporter by id', () => {
+      expect(getLogReporter('console')).toBeDefined()
+    })
+
+    test('get log reporter with unknown id gets undefined', () => {
+      expect(getLogReporter('blah')).toBeUndefined()
+    })
   })
 
-  test('removes all reporters', () => {
-    clearLogReporters()
+  describe('clearLogReporters()', () => {
+    test('removes all reporters', () => {
+      clearLogReporters()
 
-    expect(store.value.reporters.length).toBe(0)
+      expect(store.value.reporters.length).toBe(0)
+    })
   })
-})
 
-describe('hasConsoleReporter()', () => {
-  test('returns true if there is a console reporter', () => {
-    expect(hasConsoleReporter()).toBeTruthy()
-  })
-  test('returns false if there is no console reporter', () => {
-    clearLogReporters()
-    expect(hasConsoleReporter()).toBeFalsy()
-    addLogReporter(createMemoryLogReporter())
-    expect(hasConsoleReporter()).toBeFalsy()
+  describe('hasConsoleReporter()', () => {
+    test('returns true if there is a console reporter', () => {
+      expect(hasConsoleReporter()).toBeTruthy()
+    })
+    test('returns false if there is no console reporter', () => {
+      clearLogReporters()
+      expect(hasConsoleReporter()).toBeFalsy()
+      addLogReporter(createMemoryLogReporter())
+      expect(hasConsoleReporter()).toBeFalsy()
+    })
   })
 })