test: improve coverage

Author: khmm12

src/colorful-logger.test.ts

@@ -2,6 +2,7 @@ import assert from 'node:assert/strict'
 import test from 'node:test'
 import { createQueryEndEvent, createQueryErrorEvent } from '../test/helpers/events.ts'
 import { colorfulLogger } from './colorful-logger.ts'
+import type { QueryFormatterInput } from './types.ts'
 
 test('colorfulLogger writes successful queries', () => {
   const calls: string[] = []
@@ -36,3 +37,42 @@ test('colorfulLogger writes failed queries', () => {
   assert.equal(calls[0]?.includes('\u001B[35m'), true)
   assert.equal(calls[0]?.includes('\u001B[31m'), true)
 })
+
+test('colorfulLogger supports custom formatters', () => {
+  const calls: string[] = []
+  const logger = colorfulLogger({
+    formatter(event) {
+      return `${event.sql} -- custom`
+    },
+    write(message) {
+      calls.push(message)
+    },
+  })
+
+  logger.onEnd?.(createQueryEndEvent())
+
+  assert.equal(calls.length, 1)
+  assert.match(calls[0], /select \? -- custom/)
+})
+
+test('colorfulLogger warns when bindings and formatter are provided together', () => {
+  const warnings: unknown[][] = []
+  const originalWarn = console.warn
+
+  console.warn = (...args: unknown[]) => {
+    warnings.push(args)
+  }
+
+  try {
+    colorfulLogger({
+      bindings: false,
+      formatter(event: QueryFormatterInput) {
+        return event.sql
+      },
+    } as unknown as Parameters<typeof colorfulLogger>[0])
+  } finally {
+    console.warn = originalWarn
+  }
+
+  assert.deepEqual(warnings, [['knex-tiny-logger: "bindings" is ignored when "formatter" is provided.']])
+})

src/formatter.test.ts

@@ -30,6 +30,58 @@ test('defaultQueryFormatter formats bindings through knex raw queries', () => {
   )
 })
 
+test('defaultQueryFormatter returns raw SQL when bindings are empty', () => {
+  const formatter = defaultQueryFormatter()
+  const knex = createFakeKnex()
+
+  assert.equal(
+    formatter({
+      knex,
+      sql: 'select 1',
+      bindings: null,
+    }),
+    'select 1',
+  )
+  assert.equal(
+    formatter({
+      knex,
+      sql: 'select 1',
+      bindings: [],
+    }),
+    'select 1',
+  )
+  assert.equal(
+    formatter({
+      knex,
+      sql: 'select 1',
+      bindings: {},
+    }),
+    'select 1',
+  )
+})
+
+test('defaultQueryFormatter formats named and scalar bindings', () => {
+  const formatter = defaultQueryFormatter()
+  const knex = createFakeKnex()
+
+  assert.equal(
+    formatter({
+      knex,
+      sql: 'select :id',
+      bindings: { id: 1 },
+    }),
+    'select :id -- {"id":1}',
+  )
+  assert.equal(
+    formatter({
+      knex,
+      sql: 'select ?',
+      bindings: 1,
+    }),
+    'select ? -- 1',
+  )
+})
+
 test('defaultQueryFormatter falls back to raw SQL when formatting fails', () => {
   const formatter = defaultQueryFormatter()
 

src/tracer.test.ts

@@ -1,5 +1,7 @@
 import assert from 'node:assert/strict'
+import { EventEmitter } from 'node:events'
 import test from 'node:test'
+import type { Knex } from 'knex'
 import { createFakeKnex } from '../test/helpers/fake-knex.ts'
 import { createTracer } from './tracer.ts'
 import type { QueryStartEvent, TracerQueryEndEvent, TracerQueryErrorEvent } from './types.ts'
@@ -104,3 +106,82 @@ test('createTracer ignores tracer errors by default', () => {
     knex.emit('query-response', [], { __knexQueryUid: 'query-1' })
   })
 })
+
+test('createTracer supports queries without knex ids', () => {
+  const knex = createFakeKnex()
+  const query = { sql: 'select ?', bindings: [1] }
+  const startEvents: QueryStartEvent[] = []
+  const endEvents: TracerQueryEndEvent[] = []
+
+  createTracer(knex, {
+    onStart(event) {
+      startEvents.push(event)
+    },
+    onEnd(event) {
+      endEvents.push(event)
+    },
+  })
+
+  knex.emit('query', query)
+  knex.emit('query-response', [], query)
+
+  assert.equal(startEvents.length, 1)
+  assert.equal(startEvents[0].queryId, 'anonymous:1')
+  assert.equal(endEvents.length, 1)
+  assert.equal(endEvents[0].queryId, 'anonymous:1')
+})
+
+test('createTracer normalizes non-object query payloads', () => {
+  const knex = createFakeKnex()
+  const startEvents: QueryStartEvent[] = []
+
+  createTracer(knex, {
+    onStart(event) {
+      startEvents.push(event)
+    },
+  })
+
+  knex.emit('query', 'select 1')
+
+  assert.equal(startEvents.length, 1)
+  assert.equal(startEvents[0].queryId, 'anonymous:1')
+  assert.equal(startEvents[0].sql, '')
+})
+
+test('createTracer swallows tracer error handler failures', () => {
+  const knex = createFakeKnex()
+
+  createTracer(knex, {
+    onEnd() {
+      throw new Error('logger failed')
+    },
+    onTracerError() {
+      throw new Error('tracer failed')
+    },
+  })
+
+  assert.doesNotThrow(() => {
+    knex.emit('query', { __knexQueryUid: 'query-1', sql: 'select 1' })
+    knex.emit('query-response', [], { __knexQueryUid: 'query-1' })
+  })
+})
+
+test('createTracer disposes with removeListener when off is unavailable', () => {
+  const emitter = new EventEmitter()
+  const knex = {
+    emit: emitter.emit.bind(emitter),
+    on: emitter.on.bind(emitter),
+    removeListener: emitter.removeListener.bind(emitter),
+  } as unknown as Knex & Pick<EventEmitter, 'emit'>
+  const startEvents: QueryStartEvent[] = []
+  const tracer = createTracer(knex, {
+    onStart(event) {
+      startEvents.push(event)
+    },
+  })
+
+  tracer.dispose()
+  knex.emit('query', { __knexQueryUid: 'query-1', sql: 'select 1' })
+
+  assert.equal(startEvents.length, 0)
+})

test/integration/knex-tiny-logger.test.ts

@@ -113,6 +113,43 @@ test('knexTinyLogger reports logger errors', () => {
   assert.deepEqual(loggerErrors, [loggerError])
 })
 
+test('knexTinyLogger wires start, error, and logger error fallback hooks', () => {
+  const knex = createFakeKnex()
+  const loggerError = new Error('logger failed')
+  const handlerError = new Error('handler failed')
+  const startEvents: unknown[] = []
+  const consoleErrors: unknown[][] = []
+  const originalError = console.error
+
+  console.error = (...args: unknown[]) => {
+    consoleErrors.push(args)
+  }
+
+  try {
+    knexTinyLogger(knex, {
+      logger: {
+        onStart(event) {
+          startEvents.push(event)
+        },
+        onError() {
+          throw loggerError
+        },
+      },
+      onLoggerError() {
+        throw handlerError
+      },
+    })
+
+    knex.emit('query', { __knexQueryUid: 'query-1', sql: 'select broken' })
+    knex.emit('query-error', new Error('query failed'), { __knexQueryUid: 'query-1' })
+  } finally {
+    console.error = originalError
+  }
+
+  assert.equal(startEvents.length, 1)
+  assert.deepEqual(consoleErrors, [[handlerError]])
+})
+
 test('createTracer receives real knex query responses', async () => {
   const knex = createKnex({
     client: 'sqlite3',