@polderlabs/bizar 4.5.2 → 4.7.0

package/bizar-dash/tests/lib/i18n.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from 'vitest';
+import { t, setLocale, getLocale } from '../../src/web/lib/i18n';
+
+describe('i18n', () => {
+  it('t() returns the key if no translation exists', () => {
+    expect(t('nonexistent.key')).toBe('nonexistent.key');
+  });
+
+  it('t() returns translation if registered', () => {
+    setLocale('en', { 'hello': 'Hello World' });
+    expect(t('hello')).toBe('Hello World');
+  });
+
+  it('setLocale() switches locale and getLocale() reflects it', () => {
+    setLocale('en');
+    expect(getLocale()).toBe('en');
+
+    setLocale('fr');
+    expect(getLocale()).toBe('fr');
+
+    setLocale('de', { greet: 'Hallo' });
+    expect(getLocale()).toBe('de');
+    expect(t('greet')).toBe('Hallo');
+  });
+
+  it('supports variable interpolation with {varName} syntax', () => {
+    setLocale('en', {
+      greeting: 'Hello, {name}!',
+      ageMsg: '{name} is {age} years old',
+    });
+    expect(t('greeting', { name: 'World' })).toBe('Hello, World!');
+    expect(t('ageMsg', { name: 'Alice', age: 30 })).toBe('Alice is 30 years old');
+  });
+
+  it('falls back to en translations when current locale is missing a key', () => {
+    setLocale('en', { shared: 'English text' });
+    setLocale('fr', { local: 'Texte français' });
+
+    // 'shared' is not in fr, should fall back to en
+    expect(t('shared')).toBe('English text');
+    // 'local' is in fr
+    expect(t('local')).toBe('Texte français');
+    // Neither locale has this
+    expect(t('missing')).toBe('missing');
+  });
+});

package/bizar-dash/tests/lib/utils.test.ts

@@ -0,0 +1,194 @@
+import { describe, it, expect, vi } from 'vitest';
+import {
+  cn,
+  formatRelative,
+  formatTime,
+  truncate,
+  debounce,
+  statusBadgeKind,
+  hashText,
+  autoTitleFromContent,
+} from '../../src/web/lib/utils';
+
+describe('cn', () => {
+  it('joins class names', () => {
+    expect(cn('a', 'b')).toBe('a b');
+  });
+
+  it('filters falsy values', () => {
+    expect(cn('a', false, null, undefined, 'b')).toBe('a b');
+  });
+
+  it('returns empty string with no args', () => {
+    expect(cn()).toBe('');
+  });
+});
+
+describe('formatRelative', () => {
+  it('returns empty string for null/undefined', () => {
+    expect(formatRelative(null)).toBe('');
+    expect(formatRelative(undefined)).toBe('');
+  });
+
+  it('returns "just now" for recent timestamps', () => {
+    expect(formatRelative(Date.now())).toBe('just now');
+    expect(formatRelative(Date.now() + 1000)).toBe('just now');
+  });
+
+  it('returns minutes', () => {
+    const fiveMinAgo = Date.now() - 5 * 60_000;
+    expect(formatRelative(fiveMinAgo)).toBe('5m ago');
+  });
+
+  it('returns hours', () => {
+    const twoHoursAgo = Date.now() - 2 * 3_600_000;
+    expect(formatRelative(twoHoursAgo)).toBe('2h ago');
+  });
+
+  it('returns days', () => {
+    const threeDaysAgo = Date.now() - 3 * 86_400_000;
+    expect(formatRelative(threeDaysAgo)).toBe('3d ago');
+  });
+
+  it('returns localized date for older timestamps', () => {
+    const oldDate = Date.now() - 30 * 86_400_000;
+    const result = formatRelative(oldDate);
+    expect(result).not.toMatch(/^(just now|\d+[mhd] ago)$/);
+    expect(result.length).toBeGreaterThan(0);
+  });
+});
+
+describe('formatTime', () => {
+  it('returns empty for null/undefined', () => {
+    expect(formatTime(null)).toBe('');
+    expect(formatTime(undefined)).toBe('');
+  });
+
+  it('formats a Date object', () => {
+    const d = new Date('2024-06-15T12:00:00');
+    const result = formatTime(d);
+    expect(result).toBe(d.toLocaleString());
+  });
+
+  it('formats a timestamp number', () => {
+    const ts = new Date('2024-06-15T12:00:00').getTime();
+    expect(formatTime(ts)).toBe(new Date(ts).toLocaleString());
+  });
+});
+
+describe('truncate', () => {
+  it('returns empty for null/undefined', () => {
+    expect(truncate(null)).toBe('');
+    expect(truncate(undefined)).toBe('');
+  });
+
+  it('returns string as-is when shorter than max', () => {
+    expect(truncate('hello', 10)).toBe('hello');
+  });
+
+  it('truncates with ellipsis when longer than max', () => {
+    expect(truncate('hello world this is long', 10)).toBe('hello worl…');
+  });
+
+  it('uses default max of 160', () => {
+    const short = 'a'.repeat(100);
+    expect(truncate(short)).toBe(short);
+    const long = 'a'.repeat(200);
+    expect(truncate(long)).toHaveLength(161);
+    expect(truncate(long)).toMatch(/…$/);
+  });
+});
+
+describe('debounce', () => {
+  it('delays execution', () => {
+    vi.useFakeTimers();
+    const fn = vi.fn();
+    const debounced = debounce(fn, 100);
+
+    debounced();
+    expect(fn).not.toHaveBeenCalled();
+
+    vi.advanceTimersByTime(100);
+    expect(fn).toHaveBeenCalledOnce();
+    vi.useRealTimers();
+  });
+
+  it('calls with the latest arguments', () => {
+    vi.useFakeTimers();
+    const fn = vi.fn();
+    const debounced = debounce(fn, 100);
+
+    debounced('a');
+    debounced('b');
+    vi.advanceTimersByTime(100);
+
+    expect(fn).toHaveBeenCalledOnce();
+    expect(fn).toHaveBeenCalledWith('b');
+    vi.useRealTimers();
+  });
+});
+
+describe('statusBadgeKind', () => {
+  it('returns success for approved/done', () => {
+    expect(statusBadgeKind('approved')).toBe('success');
+    expect(statusBadgeKind('done')).toBe('success');
+  });
+
+  it('returns empty for draft/queued', () => {
+    expect(statusBadgeKind('draft')).toBe('');
+    expect(statusBadgeKind('queued')).toBe('');
+  });
+
+  it('returns info for in-progress/doing', () => {
+    expect(statusBadgeKind('in-progress')).toBe('info');
+    expect(statusBadgeKind('doing')).toBe('info');
+  });
+
+  it('returns error for rejected', () => {
+    expect(statusBadgeKind('rejected')).toBe('error');
+  });
+
+  it('returns accent for unknown statuses', () => {
+    expect(statusBadgeKind('unknown')).toBe('accent');
+  });
+});
+
+describe('hashText', () => {
+  it('returns a string', () => {
+    expect(typeof hashText('hello')).toBe('string');
+  });
+
+  it('is deterministic', () => {
+    expect(hashText('hello')).toBe(hashText('hello'));
+  });
+
+  it('differs for different inputs', () => {
+    expect(hashText('hello')).not.toBe(hashText('world'));
+  });
+});
+
+describe('autoTitleFromContent', () => {
+  it('extracts first non-empty line', () => {
+    expect(autoTitleFromContent('Hello world')).toBe('Hello world');
+  });
+
+  it('strips markdown heading markers', () => {
+    expect(autoTitleFromContent('## My Feature')).toBe('My Feature');
+  });
+
+  it('generates fallback title when body is empty', () => {
+    const result = autoTitleFromContent('');
+    expect(result).toMatch(/^Untitled task/);
+  });
+
+  it('returns empty when fallback is false and body is empty', () => {
+    expect(autoTitleFromContent('', false)).toBe('');
+  });
+
+  it('truncates long first lines', () => {
+    const long = 'a'.repeat(100);
+    const result = autoTitleFromContent(long);
+    expect(result.length).toBeLessThan(long.length);
+    expect(result).toMatch(/…$/);
+  });
+});

package/bizar-dash/tests/logger.test.mjs

@@ -0,0 +1,207 @@
+/**
+ * tests/logger.test.mjs
+ *
+ * Tests for src/server/logger.mjs — verifies level filtering, JSON
+ * output shape, context merge behaviour, and the child() factory.
+ *
+ * The module reads BIZAR_LOG_LEVEL at import time, so each test that
+ * needs a different level uses Node's --import flag… except that's
+ * hard to do mid-test. Instead we set the env BEFORE the first
+ * dynamic import by using a top-level await and reset modules via
+ * `node:test`'s `mock`.
+ *
+ * Simpler: we always force level='debug' at the top of each test
+ * with a child module that re-exports the logger functions but
+ * respects a per-test override. That mirrors what real callers do
+ * anyway — they call the functions, not the level constant.
+ *
+ * Strategy: capture stdout/stderr by replacing console.{log,warn,error}
+ * in-place for the duration of the test, then assert on the captured
+ * lines. Restore the originals in finally.
+ */
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { Writable } from 'node:stream';
+
+function captureConsole() {
+  const original = {
+    log: console.log,
+    warn: console.warn,
+    error: console.error,
+  };
+  const lines = [];
+  const sink = new Writable({
+    write(chunk, _enc, cb) {
+      lines.push(String(chunk).replace(/\n$/, ''));
+      cb();
+    },
+  });
+  // Replace console.* with writes to our sink. The logger calls
+  // console.log/warn/error, so we route each stream independently to
+  // its own bucket so we can verify the level → stream mapping.
+  const buckets = { log: [], warn: [], error: [] };
+  console.log = (...args) => {
+    buckets.log.push(args.map(String).join(' '));
+    sink.write(args.map(String).join(' ') + '\n');
+  };
+  console.warn = (...args) => {
+    buckets.warn.push(args.map(String).join(' '));
+    sink.write(args.map(String).join(' ') + '\n');
+  };
+  console.error = (...args) => {
+    buckets.error.push(args.map(String).join(' '));
+    sink.write(args.map(String).join(' ') + '\n');
+  };
+  return {
+    buckets,
+    lines,
+    restore() {
+      console.log = original.log;
+      console.warn = original.warn;
+      console.error = original.error;
+    },
+  };
+}
+
+/**
+ * Force BIZAR_LOG_LEVEL to the given value BEFORE importing the
+ * logger module. We delete the cached module from require.cache so
+ * the level constant re-evaluates, then dynamic-import it fresh.
+ */
+async function loadLogger(level) {
+  // For ESM the import cache lives on the loader, not require.cache.
+  // Use a unique query string per level to force a fresh module
+  // evaluation (Node treats different specifiers as different modules).
+  const url = `../src/server/logger.mjs?level=${level}`;
+  process.env.BIZAR_LOG_LEVEL = level;
+  return import(url);
+}
+
+test('logger emits JSON with ts/level/msg shape', async () => {
+  process.env.BIZAR_LOG_LEVEL = 'debug';
+  const cap = captureConsole();
+  try {
+    const { info } = await loadLogger('debug');
+    info('server started', { port: 4317 });
+    assert.equal(cap.buckets.log.length, 1);
+    const parsed = JSON.parse(cap.buckets.log[0]);
+    assert.equal(parsed.msg, 'server started');
+    assert.equal(parsed.level, 'info');
+    assert.equal(parsed.port, 4317);
+    assert.ok(typeof parsed.ts === 'string');
+    // ts must look like an ISO timestamp.
+    assert.match(parsed.ts, /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
+  } finally {
+    cap.restore();
+  }
+});
+
+test('level filtering — debug suppressed at default level', async () => {
+  process.env.BIZAR_LOG_LEVEL = 'info';
+  const cap = captureConsole();
+  try {
+    const { debug, info } = await loadLogger('info');
+    debug('should not appear');
+    info('should appear');
+    assert.equal(cap.buckets.log.length, 1);
+    const parsed = JSON.parse(cap.buckets.log[0]);
+    assert.equal(parsed.msg, 'should appear');
+    assert.equal(parsed.level, 'info');
+  } finally {
+    cap.restore();
+  }
+});
+
+test('level filtering — warn goes to console.warn, error to console.error', async () => {
+  process.env.BIZAR_LOG_LEVEL = 'debug';
+  const cap = captureConsole();
+  try {
+    const { warn, error } = await loadLogger('debug');
+    warn('a warning', { module: 'test' });
+    error('a failure', { module: 'test', code: 'E_BANG' });
+    assert.equal(cap.buckets.warn.length, 1);
+    assert.equal(cap.buckets.error.length, 1);
+    assert.equal(cap.buckets.log.length, 0);
+    const w = JSON.parse(cap.buckets.warn[0]);
+    assert.equal(w.level, 'warn');
+    assert.equal(w.module, 'test');
+    const e = JSON.parse(cap.buckets.error[0]);
+    assert.equal(e.level, 'error');
+    assert.equal(e.code, 'E_BANG');
+  } finally {
+    cap.restore();
+  }
+});
+
+test('level filtering — error suppressed above error level (none higher exists)', async () => {
+  // There's no level above error, so this is a sanity test: errors
+  // always print. Make sure we didn't accidentally silence them.
+  process.env.BIZAR_LOG_LEVEL = 'error';
+  const cap = captureConsole();
+  try {
+    const { info, warn, error } = await loadLogger('error');
+    info('hidden');
+    warn('hidden');
+    error('visible');
+    assert.equal(cap.buckets.error.length, 1);
+    assert.equal(cap.buckets.log.length, 0);
+    assert.equal(cap.buckets.warn.length, 0);
+    assert.equal(JSON.parse(cap.buckets.error[0]).msg, 'visible');
+  } finally {
+    cap.restore();
+  }
+});
+
+test('child logger binds context to every call', async () => {
+  process.env.BIZAR_LOG_LEVEL = 'debug';
+  const cap = captureConsole();
+  try {
+    const { child } = await loadLogger('debug');
+    const log = child({ module: 'overview', session: 'abc' });
+    log.info('snapshot built', { size: 42 });
+    log.warn('cache miss');
+    // Both calls should carry the bound module + session.
+    const i = JSON.parse(cap.buckets.log[0]);
+    assert.equal(i.msg, 'snapshot built');
+    assert.equal(i.module, 'overview');
+    assert.equal(i.session, 'abc');
+    assert.equal(i.size, 42);
+    const w = JSON.parse(cap.buckets.warn[0]);
+    assert.equal(w.msg, 'cache miss');
+    assert.equal(w.module, 'overview');
+    assert.equal(w.session, 'abc');
+  } finally {
+    cap.restore();
+  }
+});
+
+test('child per-call context overrides bound context', async () => {
+  process.env.BIZAR_LOG_LEVEL = 'debug';
+  const cap = captureConsole();
+  try {
+    const { child } = await loadLogger('debug');
+    const log = child({ module: 'overview', session: 'abc' });
+    log.info('snapshot', { session: 'override' });
+    const parsed = JSON.parse(cap.buckets.log[0]);
+    // Per-call context wins over the bound context for shared keys.
+    assert.equal(parsed.session, 'override');
+    assert.equal(parsed.module, 'overview');
+  } finally {
+    cap.restore();
+  }
+});
+
+test('undefined ctx is ignored without throwing', async () => {
+  process.env.BIZAR_LOG_LEVEL = 'debug';
+  const cap = captureConsole();
+  try {
+    const { info } = await loadLogger('debug');
+    assert.doesNotThrow(() => info('hello'));
+    assert.doesNotThrow(() => info('hello', null));
+    assert.doesNotThrow(() => info('hello', undefined));
+    const parsed = JSON.parse(cap.buckets.log[0]);
+    assert.equal(parsed.msg, 'hello');
+  } finally {
+    cap.restore();
+  }
+});

package/bizar-dash/tests/metrics.test.mjs

@@ -0,0 +1,183 @@
+/**
+ * tests/metrics.test.mjs
+ *
+ * Tests for src/server/metrics.mjs — verifies counter/gauge/histogram
+ * accumulators, label handling, and Prometheus text exposition output.
+ *
+ * Each test resets the registry in finally so order doesn't matter
+ * and tests are independent.
+ */
+import test from 'node:test';
+import assert from 'node:assert/strict';
+
+const METRICS_URL = '../src/server/metrics.mjs';
+
+async function loadMetrics() {
+  // Bump the URL per-test-call to force fresh module load (the
+  // registry state lives at module scope, so a fresh import = a fresh
+  // empty registry). Tests reset() in finally too as belt-and-braces.
+  const url = `${METRICS_URL}?v=${Date.now()}-${Math.random()}`;
+  return import(url);
+}
+
+test('counter increments without labels', async () => {
+  const m = await loadMetrics();
+  try {
+    const c = m.counter('hits_total', 'Total hits');
+    c.inc();
+    c.inc();
+    c.inc();
+    const out = m.render();
+    assert.match(out, /^# HELP hits_total Total hits/m);
+    assert.match(out, /^# TYPE hits_total counter/m);
+    assert.match(out, /^hits_total 3$/m);
+  } finally {
+    m.reset();
+  }
+});
+
+test('counter increments are partitioned by labels', async () => {
+  const m = await loadMetrics();
+  try {
+    const c = m.counter('http_requests_total', 'HTTP requests');
+    c.inc({ method: 'GET', status: '200' });
+    c.inc({ method: 'GET', status: '200' });
+    c.inc({ method: 'POST', status: '200' });
+    c.inc({ method: 'GET', status: '500' });
+    const out = m.render();
+    // Two GET 200 → value 2.
+    assert.match(out, /^http_requests_total\{method="GET",status="200"\} 2$/m);
+    // One of each for the other combinations.
+    assert.match(out, /^http_requests_total\{method="POST",status="200"\} 1$/m);
+    assert.match(out, /^http_requests_total\{method="GET",status="500"\} 1$/m);
+  } finally {
+    m.reset();
+  }
+});
+
+test('gauge stores last value per label set', async () => {
+  const m = await loadMetrics();
+  try {
+    const g = m.gauge('ws_clients', 'Active WS clients');
+    g.set(3);
+    g.set(7); // overwrites the 3
+    g.set(12, { shard: 'a' });
+    g.set(5, { shard: 'b' });
+    const out = m.render();
+    assert.match(out, /^# TYPE ws_clients gauge/m);
+    assert.match(out, /^ws_clients 7$/m);
+    assert.match(out, /^ws_clients\{shard="a"\} 12$/m);
+    assert.match(out, /^ws_clients\{shard="b"\} 5$/m);
+  } finally {
+    m.reset();
+  }
+});
+
+test('histogram tracks count/sum + bucket counts', async () => {
+  const m = await loadMetrics();
+  try {
+    const h = m.histogram('latency_seconds', 'Request latency', {
+      buckets: [0.1, 0.5, 1, 5],
+    });
+    h.observe(0.05); // bucket le=0.1
+    h.observe(0.2);  // bucket le=0.5
+    h.observe(0.2);  // bucket le=0.5
+    h.observe(2);    // bucket le=5
+    h.observe(10);   // +Inf
+    const out = m.render();
+    assert.match(out, /^# TYPE latency_seconds histogram/m);
+    // Bucket counts: cumulative per Prometheus convention.
+    assert.match(out, /^latency_seconds_bucket\{le="0\.1"\} 1$/m);
+    assert.match(out, /^latency_seconds_bucket\{le="0\.5"\} 3$/m);
+    assert.match(out, /^latency_seconds_bucket\{le="1"\} 3$/m);
+    assert.match(out, /^latency_seconds_bucket\{le="5"\} 4$/m);
+    assert.match(out, /^latency_seconds_bucket\{le="\+Inf"\} 5$/m);
+    // Count + sum.
+    assert.match(out, /^latency_seconds_count 5$/m);
+    assert.match(out, /^latency_seconds_sum 12\.45$/m);
+  } finally {
+    m.reset();
+  }
+});
+
+test('histogram uses default buckets when none provided', async () => {
+  const m = await loadMetrics();
+  try {
+    const h = m.histogram('req_dur', 'Request duration');
+    h.observe(0.001); // fits in default 0.005 bucket
+    const out = m.render();
+    // We don't assert specific default values — just that the
+    // standard bucket boundaries appear in the output.
+    assert.match(out, /le="0\.005"/);
+    assert.match(out, /le="\+Inf"/);
+    assert.match(out, /^req_dur_count 1$/m);
+  } finally {
+    m.reset();
+  }
+});
+
+test('render returns empty string when no metrics registered', async () => {
+  const m = await loadMetrics();
+  try {
+    assert.equal(m.render(), '');
+  } finally {
+    m.reset();
+  }
+});
+
+test('render combines counters, gauges, histograms in order', async () => {
+  const m = await loadMetrics();
+  try {
+    m.counter('first_total', 'first').inc();
+    m.gauge('second', 'second').set(42);
+    m.histogram('third', 'third').observe(1);
+    const out = m.render();
+    const i1 = out.indexOf('# TYPE first_total');
+    const i2 = out.indexOf('# TYPE second');
+    const i3 = out.indexOf('# TYPE third');
+    assert.ok(i1 >= 0 && i2 > i1 && i3 > i2, 'metrics must render in registration order');
+  } finally {
+    m.reset();
+  }
+});
+
+test('label values are escaped', async () => {
+  const m = await loadMetrics();
+  try {
+    const c = m.counter('events_total', 'Events');
+    c.inc({ name: 'has "quote"' });
+    const out = m.render();
+    assert.match(out, /events_total\{name="has \\"quote\\""\} 1/);
+  } finally {
+    m.reset();
+  }
+});
+
+test('reset clears all metric types', async () => {
+  const m = await loadMetrics();
+  m.counter('c', 'c').inc();
+  m.gauge('g', 'g').set(1);
+  m.histogram('h', 'h').observe(1);
+  assert.notEqual(m.render(), '');
+  m.reset();
+  assert.equal(m.render(), '');
+});
+
+test('labels with same content but different key order collapse to one bucket', async () => {
+  // Prometheus convention is that label sets are unordered, so
+  // {a:'1',b:'2'} and {b:'2',a:'1'} must be the same series. Our
+  // implementation sorts keys before stringifying so this holds.
+  const m = await loadMetrics();
+  try {
+    const c = m.counter('mixed_total', 'mixed');
+    c.inc({ a: '1', b: '2' });
+    c.inc({ b: '2', a: '1' });
+    const out = m.render();
+    // Only one series line — both inc calls collapsed.
+    const matches = out.match(/^mixed_total\{/gm) || [];
+    assert.equal(matches.length, 1);
+    assert.match(out, /^mixed_total\{a="1",b="2"\} 2$/m);
+  } finally {
+    m.reset();
+  }
+});

package/bizar-dash/tests/server-bugfixes.test.mjs

@@ -312,7 +312,7 @@ describe('Bug S3 — chat.mjs per-session delta cap', () => {
     );
     assert.match(src, /CHAT_DELTA_BUFFER_CAP\s*=\s*1000/,
       'cap constant should be set to 1000');
-    assert.match(src, /console\.warn\(/,
-      'cap-exceeded path should log a warning');
+    assert.match(src, /logWarn\(/,
+      'cap-exceeded path should log a warning via the structured logger');
   });
 });

package/bizar-dash/tests/setup.ts

@@ -0,0 +1,7 @@
+import '@testing-library/jest-dom/vitest';
+import { cleanup } from '@testing-library/react';
+import { afterEach } from 'vitest';
+
+afterEach(() => {
+  cleanup();
+});

package/bizar-dash/vitest.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vitest/config';
+import react from '@vitejs/plugin-react';
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    environment: 'jsdom',
+    globals: true,
+    setupFiles: ['./tests/setup.ts'],
+    include: ['tests/**/*.test.{ts,tsx}'],
+    exclude: ['tests/**/*.test.mjs'],
+  },
+});