standard-log 6.3.1 → 7.0.2

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()
+    })
   })
 })

package/src/memory/MemoryLogReporter.spec.ts

@@ -1,98 +1,114 @@
 import a from 'assertron'
 import { config, createMemoryLogReporter, logLevels, ProhibitedDuringProduction } from '..'
+import { configForTest } from '../configForTest'
+import { getLogger } from '../getLogger'
 import { store } from '../store'
 
-beforeEach(() => {
-  store.reset()
-  config({ mode: 'test' })
-})
-test('log entries are saved in the `logs` property', () => {
-  const reporter = createMemoryLogReporter()
-  const entry = { id: 'log', level: 1, args: ['some messages'], timestamp: new Date() }
-  reporter.write(entry)
-  expect(reporter.logs).toEqual([entry])
-})
-
-test('can override id', () => {
-  const reporter = createMemoryLogReporter({ id: 'custom-id-mem' })
-  expect(reporter.id).toBe('custom-id-mem')
-})
-
-test('can filter', () => {
-  const reporter = createMemoryLogReporter({ filter(entry) { return entry.id !== 'secret' } })
-  reporter.write({ id: 'ok', level: 1, args: ['some messages'], timestamp: new Date() })
-  reporter.write({ id: 'secret', level: 1, args: ['some messages'], timestamp: new Date() })
-  expect(reporter.logs.length).toBe(1)
-})
+describe('production checks', () => {
+  beforeEach(() => store.reset())
+  test('set formatter in production mode throws', () => {
+    config({ mode: 'production' })
+    const reporter = createMemoryLogReporter()
 
-test('can change filter', () => {
-  const reporter = createMemoryLogReporter()
-  const filter = reporter.filter
-  reporter.filter = entry => entry.id !== 'secret'
-  expect(reporter.filter).not.toEqual(filter)
-})
+    a.throws(() => { reporter.formatter = e => e }, ProhibitedDuringProduction)
+  })
 
-test('set filter in production mode throws', () => {
-  config({ mode: 'production' })
-  const reporter = createMemoryLogReporter()
-  a.throws(() => { reporter.filter = () => true }, ProhibitedDuringProduction)
-})
+  test('set filter in production mode throws', () => {
+    config({ mode: 'production' })
+    const reporter = createMemoryLogReporter()
+    a.throws(() => { reporter.filter = () => true }, ProhibitedDuringProduction)
+  })
 
-test('formatter can be used to pre-process the log', () => {
-  const reporter = createMemoryLogReporter({
-    formatter: (entry) => ({
-      ...entry,
-      args: entry.args.map(arg => arg === 'secret' ? '<censored>' : arg)
+  describe('getLogMessageWithLevel()', () => {
+    test('the production log is omitted', () => {
+      const { reporter } = configForTest()
+      config({ mode: 'production' })
+      getLogger('test').warn('some test warnings')
+      expect(reporter.getLogMessageWithLevel()).toEqual(`(WARN) some test warnings`)
     })
   })
-
-  const entry = { id: 'log', level: 1, args: ['a', 'secret', 'b'], timestamp: new Date() }
-  reporter.write(entry)
-
-  expect(reporter.logs[0].args[1]).toBe('<censored>')
 })
 
-test('can change formatter', () => {
-  const reporter = createMemoryLogReporter()
-  const formatter = reporter.formatter
-  reporter.formatter = e => ({ ...e, args: e.args.reverse() })
-  expect(reporter.formatter).not.toEqual(formatter)
-})
+describe('unit tests', () => {
+  beforeEach(() => {
+    store.reset()
+    config({ mode: 'test' })
+  })
+  test('log entries are saved in the `logs` property', () => {
+    const reporter = createMemoryLogReporter()
+    const entry = { id: 'log', level: 1, args: ['some messages'], timestamp: new Date() }
+    reporter.write(entry)
+    expect(reporter.logs).toEqual([entry])
+  })
 
-test('set formatter in production mode throws', () => {
-  config({ mode: 'production' })
-  const reporter = createMemoryLogReporter()
+  test('can override id', () => {
+    const reporter = createMemoryLogReporter({ id: 'custom-id-mem' })
+    expect(reporter.id).toBe('custom-id-mem')
+  })
 
-  a.throws(() => { reporter.formatter = e => e }, ProhibitedDuringProduction)
-})
+  test('can filter', () => {
+    const reporter = createMemoryLogReporter({ filter(entry) { return entry.id !== 'secret' } })
+    reporter.write({ id: 'ok', level: 1, args: ['some messages'], timestamp: new Date() })
+    reporter.write({ id: 'secret', level: 1, args: ['some messages'], timestamp: new Date() })
+    expect(reporter.logs.length).toBe(1)
+  })
 
-describe('getLogMessages()', () => {
-  test('empty logs returns empty string', () => {
+  test('can change filter', () => {
     const reporter = createMemoryLogReporter()
-
-    expect(reporter.getLogMessage()).toEqual('')
+    const filter = reporter.filter
+    reporter.filter = entry => entry.id !== 'secret'
+    expect(reporter.filter).not.toEqual(filter)
   })
 
-  test('print args', () => {
-    const reporter = createMemoryLogReporter()
-    const entry = { id: 'log', level: 1, args: ['miku', 'is', 'singing'], timestamp: new Date() }
+  test('formatter can be used to pre-process the log', () => {
+    const reporter = createMemoryLogReporter({
+      formatter: (entry) => ({
+        ...entry,
+        args: entry.args.map(arg => arg === 'secret' ? '<censored>' : arg)
+      })
+    })
+
+    const entry = { id: 'log', level: 1, args: ['a', 'secret', 'b'], timestamp: new Date() }
     reporter.write(entry)
-    expect(reporter.getLogMessage()).toEqual('miku is singing')
+
+    expect(reporter.logs[0].args[1]).toBe('<censored>')
   })
 
-  test('print object arg', () => {
+  test('can change formatter', () => {
     const reporter = createMemoryLogReporter()
-    const entry = { id: 'log', level: 1, args: [{ 'miku': 'sing' }], timestamp: new Date() }
-    reporter.write(entry)
-    expect(reporter.getLogMessage()).toEqual("{ miku: 'sing' }")
+    const formatter = reporter.formatter
+    reporter.formatter = e => ({ ...e, args: e.args.reverse() })
+    expect(reporter.formatter).not.toEqual(formatter)
   })
-})
 
-describe('getLogMessageWithLevel', () => {
-  test('print with level', () => {
-    const reporter = createMemoryLogReporter()
-    reporter.write({ id: 'log', level: logLevels.info, args: ['msg 1'], timestamp: new Date() })
-    reporter.write({ id: 'log', level: logLevels.warn, args: ['msg 2'], timestamp: new Date() })
-    expect(reporter.getLogMessageWithLevel()).toEqual(`(INFO) msg 1\n(WARN) msg 2`)
+  describe('getLogMessages()', () => {
+    test('empty logs returns empty string', () => {
+      const reporter = createMemoryLogReporter()
+
+      expect(reporter.getLogMessage()).toEqual('')
+    })
+
+    test('print args', () => {
+      const reporter = createMemoryLogReporter()
+      const entry = { id: 'log', level: 1, args: ['miku', 'is', 'singing'], timestamp: new Date() }
+      reporter.write(entry)
+      expect(reporter.getLogMessage()).toEqual('miku is singing')
+    })
+
+    test('print object arg', () => {
+      const reporter = createMemoryLogReporter()
+      const entry = { id: 'log', level: 1, args: [{ 'miku': 'sing' }], timestamp: new Date() }
+      reporter.write(entry)
+      expect(reporter.getLogMessage()).toEqual("{ miku: 'sing' }")
+    })
+  })
+
+  describe('getLogMessageWithLevel', () => {
+    test('print with level', () => {
+      const reporter = createMemoryLogReporter()
+      reporter.write({ id: 'log', level: logLevels.info, args: ['msg 1'], timestamp: new Date() })
+      reporter.write({ id: 'log', level: logLevels.warn, args: ['msg 2'], timestamp: new Date() })
+      expect(reporter.getLogMessageWithLevel()).toEqual(`(INFO) msg 1\n(WARN) msg 2`)
+    })
   })
 })

package/src/memory/MemoryLogReporter.ts

@@ -28,6 +28,10 @@ export function toMessageWithLevel(logs: LogEntry[]) {
   return logs.map(toInspectLogEntry)
     .map(log => `${formatLogLevel(log.level)} ${log.args.join(' ')}`)
     .join('\n')
+    // if it has more than this log,
+    // we assume it is running under tests,
+    // and remove this log to simplify testing.
+    .replace(/^\(WARN\) already configured for test, ignoring config\(\) call\n/, '')
 }