bajo 2.17.0 → 2.19.0

package/test/log.test.js

@@ -0,0 +1,119 @@
+/* global describe, it, beforeEach, afterEach */
+
+import os from 'node:os'
+import path from 'node:path'
+import { expect } from 'chai'
+import fs from 'fs-extra'
+import dayjs from 'dayjs'
+
+import Log from '../class/log.js'
+
+const createTempRoot = () => fs.mkdtempSync(path.join(os.tmpdir(), 'bajo-log-test-'))
+
+describe('Log', () => {
+  let root
+  let app
+  let log
+
+  beforeEach(() => {
+    root = createTempRoot()
+    app = {
+      runAt: new Date(),
+      t: (prefix, text, ...args) => `${prefix}:${text}:${args.join('|')}`,
+      lib: {
+        fs,
+        dayjs,
+        _: {
+          isEmpty: (v) => v == null || v === '' || (typeof v === 'object' && Object.keys(v).length === 0),
+          merge: (a, b) => Object.assign(a, b),
+          without: (arr, item) => arr.filter(i => i !== item)
+        }
+      },
+      bajo: {
+        dir: { data: root },
+        config: {
+          env: 'dev',
+          log: {
+            level: 'trace',
+            save: false,
+            pretty: false,
+            useUtc: false,
+            timeTaken: false,
+            dateFormat: 'YYYY-MM-DD',
+            rotation: { cycle: 'none', byPlugin: false }
+          }
+        },
+        isLogInRange: () => true
+      }
+    }
+  })
+
+  afterEach(() => {
+    if (root) fs.rmSync(root, { recursive: true, force: true })
+  })
+
+  it('formats and prints messages in dev mode', () => {
+    const originalLog = console.log
+    const lines = []
+    console.log = (line) => lines.push(line)
+    log = new Log(app)
+
+    try {
+      log.info('main', 'hello %s', 'x')
+    } finally {
+      console.log = originalLog
+    }
+
+    expect(lines.length).to.equal(1)
+    expect(lines[0]).to.include('[INFO]')
+    expect(lines[0]).to.include('[main]')
+    expect(lines[0]).to.include('main:hello %s:x')
+  })
+
+  it('returns error message fallback by code/statusCode', () => {
+    log = new Log(app)
+
+    expect(log.getErrorMessage(new Error('x'))).to.equal('x')
+    expect(log.getErrorMessage({ message: '', code: 'E1' })).to.equal('E1')
+    expect(log.getErrorMessage({ message: '', statusCode: 404 })).to.equal(404)
+  })
+
+  it('builds rotation patterns and saves file', () => {
+    app.bajo.config.log.save = true
+    log = new Log(app)
+    app.bajo.config.log.rotation.cycle = 'daily'
+
+    const pattern = log.getRotationPattern()
+    log.save('\u001b[31mhello\u001b[0m', 'x')
+
+    expect(pattern).to.be.a('string')
+    expect(fs.existsSync(path.join(root, 'log', `bajo.${pattern}.log`))).to.equal(true)
+  })
+
+  it('supports prod json output', () => {
+    app.bajo.config.env = 'prod'
+    log = new Log(app)
+    const originalLog = console.log
+    const lines = []
+    console.log = (line) => lines.push(line)
+
+    try {
+      log.warn('core', { id: 1 }, 'hi')
+    } finally {
+      console.log = originalLog
+    }
+
+    const payload = JSON.parse(lines[0])
+    expect(payload.prefix).to.equal('core')
+    expect(payload.level).to.be.a('number')
+    expect(payload).to.have.property('data')
+  })
+
+  it('disposes app reference', async () => {
+    log = new Log(app)
+
+    await log.dispose()
+
+    expect(log.app).to.equal(null)
+  })
+})

package/test/plugin.test.js

@@ -0,0 +1,116 @@
+/* global describe, it, beforeEach */
+
+import os from 'node:os'
+import path from 'node:path'
+import { expect } from 'chai'
+import fs from 'fs-extra'
+import lodash from 'lodash'
+
+import Plugin from '../class/plugin.js'
+
+const createTempRoot = () => fs.mkdtempSync(path.join(os.tmpdir(), 'bajo-plugin-test-'))
+
+describe('Plugin', () => {
+  let app
+
+  beforeEach(() => {
+    const calls = []
+    app = {
+      lib: {
+        _: lodash,
+        fs
+      },
+      log: {
+        trace: (...args) => calls.push(['trace', ...args]),
+        debug: (...args) => calls.push(['debug', ...args]),
+        info: (...args) => calls.push(['info', ...args]),
+        warn: (...args) => calls.push(['warn', ...args]),
+        error: (...args) => calls.push(['error', ...args]),
+        fatal: (...args) => calls.push(['fatal', ...args]),
+        silent: (...args) => calls.push(['silent', ...args])
+      },
+      t: (ns, text, ...params) => `${ns}:${text}:${params.join('|')}`,
+      te: (ns, text) => `${ns}:${text}`,
+      dump: (...args) => calls.push(['dump', ...args]),
+      _calls: calls
+    }
+  })
+
+  it('initializes namespace and prefixed log shortcuts', () => {
+    const plugin = new Plugin('my-plugin', app)
+
+    plugin.log.info('hello')
+
+    expect(plugin.ns).to.equal('myPlugin')
+    expect(app._calls[0]).to.deep.equal(['info', 'myPlugin', 'hello'])
+  })
+
+  it('reads package info and selected keys', async () => {
+    const root = createTempRoot()
+    const pkgDir = path.join(root, 'plugin')
+    await fs.ensureDir(pkgDir)
+    await fs.writeJson(path.join(pkgDir, 'package.json'), {
+      name: 'my-plugin',
+      version: '1.2.3',
+      private: true
+    })
+    const plugin = new Plugin('my-plugin', app)
+    plugin.dir = { pkg: pkgDir }
+
+    expect(plugin.getPkgInfo()).to.deep.equal({
+      name: 'my-plugin',
+      version: '1.2.3'
+    })
+    expect(plugin.getPkgInfo(pkgDir, [])).to.include({ private: true })
+  })
+
+  it('returns config value with clone and omit support', () => {
+    const plugin = new Plugin('my-plugin', app)
+    plugin.config = { a: { b: 1, c: 2 } }
+
+    const val = plugin.getConfig('a', { omit: ['c'] })
+    val.b = 99
+
+    expect(val).to.deep.equal({ b: 99 })
+    expect(plugin.config.a.b).to.equal(1)
+    expect(plugin.getConfig('missing', { defValue: { x: 1 } })).to.deep.equal({ x: 1 })
+    expect(plugin.getConfig('a', { noClone: true })).to.equal(plugin.config.a)
+  })
+
+  it('returns native Error when print is unavailable', () => {
+    const plugin = new Plugin('my-plugin', app)
+
+    const err = plugin.error('plain error')
+    const fatalErr = plugin.fatal('fatal error')
+
+    expect(err).to.be.instanceOf(Error)
+    expect(err.message).to.equal('plain error')
+    expect(fatalErr).to.be.instanceOf(Error)
+  })
+
+  it('delegates translation and dump to app', () => {
+    const plugin = new Plugin('my-plugin', app)
+
+    expect(plugin.t('hello', 'x')).to.equal('myPlugin:hello:x')
+    expect(plugin.te('hello')).to.equal('myPlugin:hello')
+    plugin.dump(1, 2)
+
+    expect(app._calls[0]).to.deep.equal(['dump', 1, 2])
+  })
+
+  it('binds methods and disposes references', async () => {
+    const plugin = new Plugin('my-plugin', app)
+    plugin.value = 42
+    plugin.read = function () {
+      return this.value
+    }
+
+    plugin.selfBind('read')
+    const reader = plugin.read
+    await plugin.dispose()
+
+    expect(reader()).to.equal(42)
+    expect(plugin.app).to.equal(null)
+    expect(plugin.config).to.equal(null)
+  })
+})

package/test/print.test.js

@@ -0,0 +1,100 @@
+/* global describe, it, beforeEach */
+
+import { expect } from 'chai'
+import dayjs from 'dayjs'
+
+import Print from '../class/print.js'
+
+describe('Print', () => {
+  let plugin
+  let print
+
+  beforeEach(() => {
+    plugin = {
+      app: {
+        applet: false,
+        exit: () => {},
+        lib: { dayjs },
+        bajo: {
+          config: {
+            silent: false,
+            counter: false,
+            datetime: false
+          }
+        }
+      },
+      t: (text, ...args) => `${text}:${args.join('|')}`
+    }
+    print = new Print(plugin)
+    print.ora = {
+      text: '',
+      startCalled: false,
+      stopCalled: false,
+      start () { this.startCalled = true },
+      stop () { this.stopCalled = true },
+      succeedCalled: false,
+      succeed () { this.succeedCalled = true },
+      failCalled: false,
+      fail () { this.failCalled = true },
+      warnCalled: false,
+      warn () { this.warnCalled = true },
+      infoCalled: false,
+      info () { this.infoCalled = true },
+      clearCalled: false,
+      clear () { this.clearCalled = true },
+      renderCalled: false,
+      render () { this.renderCalled = true }
+    }
+  })
+
+  it('builds translated text with optional prefixes', () => {
+    print.options.showCounter = true
+
+    const text = print.buildText('hello')
+
+    expect(text).to.include('hello:')
+    expect(text).to.match(/\[\d\d:/)
+  })
+
+  it('starts and stops spinner', () => {
+    print.start('start')
+    print.stop()
+
+    expect(print.ora.startCalled).to.equal(true)
+    expect(print.ora.stopCalled).to.equal(true)
+  })
+
+  it('uses succeed/fail/warn/info/clear/render chainable methods', () => {
+    expect(print.succeed('ok')).to.equal(print)
+    expect(print.fail('x')).to.equal(print)
+    expect(print.warn('w')).to.equal(print)
+    expect(print.info('i')).to.equal(print)
+    expect(print.clear()).to.equal(print)
+    expect(print.render()).to.equal(print)
+
+    expect(print.ora.succeedCalled).to.equal(true)
+    expect(print.ora.failCalled).to.equal(true)
+    expect(print.ora.warnCalled).to.equal(true)
+    expect(print.ora.infoCalled).to.equal(true)
+    expect(print.ora.clearCalled).to.equal(true)
+    expect(print.ora.renderCalled).to.equal(true)
+  })
+
+  it('fails and exits on fatal', () => {
+    let exited = false
+    plugin.app.exit = () => { exited = true }
+
+    print.fatal('boom')
+
+    expect(print.ora.failCalled).to.equal(true)
+    expect(exited).to.equal(true)
+  })
+
+  it('creates a new spinner sharing start time', () => {
+    const spin = print.spinner()
+
+    expect(spin).to.be.instanceOf(Print)
+    expect(spin).to.not.equal(print)
+    expect(spin.startTime.valueOf()).to.equal(print.startTime.valueOf())
+  })
+})

package/test/tools.test.js

@@ -0,0 +1,38 @@
+/* global describe, it */
+
+import { expect } from 'chai'
+
+import Tools from '../class/tools.js'
+
+describe('Tools', () => {
+  it('stores plugin and app references', () => {
+    const plugin = { app: { name: 'app' } }
+    const tools = new Tools(plugin)
+
+    expect(tools.plugin).to.equal(plugin)
+    expect(tools.app).to.equal(plugin.app)
+  })
+
+  it('binds methods to self', () => {
+    const plugin = { app: {} }
+    const tools = new Tools(plugin)
+    tools.value = 7
+    tools.read = function () {
+      return this.value
+    }
+
+    tools.selfBind(['read'])
+    const rebound = tools.read
+
+    expect(rebound()).to.equal(7)
+  })
+
+  it('disposes references', async () => {
+    const tools = new Tools({ app: {} })
+
+    await tools.dispose()
+
+    expect(tools.app).to.equal(null)
+    expect(tools.plugin).to.equal(null)
+  })
+})

package/wiki/CHANGES.md

@@ -1,5 +1,15 @@
 # Changes
 
+## 2026-06-26
+
+- [2.19.0] Documentation overhaul
+- [2.19.0] Make much needed tests
+
+## 2026-06-12
+
+- [2.18.0] Move plugin related methods to ```app```
+- [2.18.0] Last argument of ```app.dump()``` serves as options if it a plain object with certain keys
+
 ## 2026-06-03
 
 - [2.17.0] Combine all helpers to ```_helper.js```

package/.mocharc.json

@@ -1,4 +0,0 @@
-{
-  "spec": "test/**/*.test.js",
-  "timeout": 5000
-}