onbuzz 3.4.0 → 3.6.2

package/src/utilities/__tests__/logger.test.js

@@ -0,0 +1,129 @@
+import { jest, describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+
+// Mock constants before importing Logger
+jest.unstable_mockModule('../constants.js', () => ({
+  SYSTEM_VERSION: '1.0.0-test'
+}));
+
+const { Logger, createLogger } = await import('../logger.js');
+
+describe('Logger', () => {
+  let consoleSpy;
+  let consoleErrorSpy;
+
+  beforeEach(() => {
+    consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    consoleSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+  });
+
+  test('constructor with no args creates logger with default level info', () => {
+    const logger = new Logger();
+    expect(logger).toBeInstanceOf(Logger);
+    expect(logger.currentLevel).toBe(logger.levels['info']);
+    expect(logger.outputs).toEqual(['console']);
+  });
+
+  test('constructor with level=error only logs errors', () => {
+    const logger = new Logger({ level: 'error' });
+    expect(logger.currentLevel).toBe(0);
+
+    logger.error('error msg');
+    logger.warn('warn msg');
+    logger.info('info msg');
+
+    // error goes to console.error, warn/info would go to console.log
+    expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
+    expect(consoleSpy).toHaveBeenCalledTimes(0);
+  });
+
+  test('info() calls log() internally', () => {
+    const logger = new Logger();
+    const logSpy = jest.spyOn(logger, 'log');
+    logger.info('test message', { key: 'val' });
+
+    expect(logSpy).toHaveBeenCalledWith('info', 'test message', { key: 'val' });
+    logSpy.mockRestore();
+  });
+
+  test('error() logs error level messages via console.error', () => {
+    const logger = new Logger();
+    logger.error('something broke');
+
+    expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
+    expect(consoleErrorSpy.mock.calls[0][0]).toContain('something broke');
+  });
+
+  test('debug() is suppressed when level is info', () => {
+    const logger = new Logger({ level: 'info' });
+    logger.debug('debug detail');
+
+    expect(consoleSpy).not.toHaveBeenCalled();
+    expect(consoleErrorSpy).not.toHaveBeenCalled();
+  });
+
+  test('setLevel changes the active log level', () => {
+    const logger = new Logger({ level: 'info' });
+    expect(logger.currentLevel).toBe(2);
+
+    logger.setLevel('debug');
+    expect(logger.currentLevel).toBe(3);
+
+    // Now debug messages should be logged
+    consoleSpy.mockClear();
+    logger.debug('now visible');
+    expect(consoleSpy).toHaveBeenCalled();
+  });
+
+  test('child() returns a new logger inheriting parent settings', () => {
+    const parent = new Logger({ level: 'debug' });
+    const child = parent.child({ component: 'test-child' });
+
+    expect(child).not.toBe(parent);
+    expect(child.childContext).toEqual({ component: 'test-child' });
+    // Child should inherit parent level
+    expect(child.currentLevel).toBe(parent.currentLevel);
+  });
+
+  test('createLogger returns Logger instance', () => {
+    const logger = createLogger({ level: 'warn', autoInit: false });
+    expect(logger).toBeInstanceOf(Logger);
+    expect(logger.currentLevel).toBe(logger.levels['warn']);
+  });
+
+  test('logToolExecution uses error level when status is failed', () => {
+    const logger = new Logger();
+    const errorSpy = jest.spyOn(logger, 'error');
+    const infoSpy = jest.spyOn(logger, 'info');
+
+    logger.logToolExecution('tool-1', 'op-1', 'failed', 500);
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+    expect(infoSpy).not.toHaveBeenCalled();
+
+    errorSpy.mockRestore();
+    infoSpy.mockRestore();
+  });
+
+  test('logApiRequest uses error level when status >= 400', () => {
+    const logger = new Logger();
+    const errorSpy = jest.spyOn(logger, 'error');
+    const infoSpy = jest.spyOn(logger, 'info');
+
+    logger.logApiRequest('GET', '/api/data', 500, 120);
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+
+    errorSpy.mockClear();
+    infoSpy.mockClear();
+
+    logger.logApiRequest('GET', '/api/data', 200, 80);
+    expect(infoSpy).toHaveBeenCalledTimes(1);
+    expect(errorSpy).not.toHaveBeenCalled();
+
+    errorSpy.mockRestore();
+    infoSpy.mockRestore();
+  });
+});

package/src/utilities/__tests__/platformUtils.test.js

@@ -0,0 +1,87 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import {
+  PLATFORMS,
+  getPlatform,
+  isMacOS,
+  isWindows,
+  isLinux,
+  normalizePath,
+  pathsEqual,
+  pathStartsWith,
+  getPlatformInfo,
+  getDefaultUserAgent,
+  getUserShell,
+  getSystemRestrictedPaths,
+  getPlatformBlockedExtensions
+} from '../platformUtils.js';
+
+describe('platformUtils', () => {
+  describe('getPlatform', () => {
+    test('returns a string matching process.platform', () => {
+      const platform = getPlatform();
+      expect(typeof platform).toBe('string');
+      expect(platform).toBe(process.platform);
+    });
+  });
+
+  describe('PLATFORMS', () => {
+    test('has MACOS, WINDOWS, LINUX keys', () => {
+      expect(PLATFORMS.MACOS).toBe('darwin');
+      expect(PLATFORMS.WINDOWS).toBe('win32');
+      expect(PLATFORMS.LINUX).toBe('linux');
+    });
+  });
+
+  describe('normalizePath', () => {
+    test('handles forward and back slashes consistently', () => {
+      const result = normalizePath('src/utilities/file.js');
+      expect(typeof result).toBe('string');
+      expect(result).not.toBe('');
+
+      // On case-insensitive platforms (macOS/Windows), should lowercase
+      if (process.platform === 'win32' || process.platform === 'darwin') {
+        expect(normalizePath('SRC/File.JS')).toBe(normalizePath('src/file.js'));
+      }
+    });
+  });
+
+  describe('pathsEqual', () => {
+    test('compares case correctly for current platform', () => {
+      expect(pathsEqual('src/file.js', 'src/file.js')).toBe(true);
+
+      if (process.platform === 'win32' || process.platform === 'darwin') {
+        // Case-insensitive platforms
+        expect(pathsEqual('SRC/File.js', 'src/file.js')).toBe(true);
+      } else {
+        // Case-sensitive platforms (Linux)
+        expect(pathsEqual('SRC/File.js', 'src/file.js')).toBe(false);
+      }
+    });
+  });
+
+  describe('pathStartsWith', () => {
+    test('detects prefix correctly', () => {
+      expect(pathStartsWith('src/utilities/file.js', 'src')).toBe(true);
+      expect(pathStartsWith('src/utilities/file.js', 'other')).toBe(false);
+
+      if (process.platform === 'win32' || process.platform === 'darwin') {
+        expect(pathStartsWith('SRC/utilities/file.js', 'src')).toBe(true);
+      }
+    });
+  });
+
+  describe('getPlatformInfo', () => {
+    test('returns object with expected keys', () => {
+      const info = getPlatformInfo();
+      expect(info).toHaveProperty('platform');
+      expect(info).toHaveProperty('arch');
+      expect(info).toHaveProperty('shell');
+      expect(info).toHaveProperty('shellPath');
+      expect(info).toHaveProperty('homeDir');
+      expect(info).toHaveProperty('tmpDir');
+      expect(info).toHaveProperty('nodeVersion');
+      expect(typeof info.platform).toBe('string');
+      expect(typeof info.nodeVersion).toBe('string');
+    });
+  });
+});

package/src/utilities/__tests__/structuredFileValidator.test.js

@@ -0,0 +1,263 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+
+// Mock fs for validateStructuredFile
+jest.unstable_mockModule('fs', () => ({
+  promises: {
+    readFile: jest.fn()
+  }
+}));
+
+const {
+  detectFormat,
+  getSupportedFormats,
+  validateContent,
+  validateStructuredFile,
+  validateForToolResponse,
+  registerValidator,
+  hasValidator,
+  default: validator
+} = await import('../structuredFileValidator.js');
+
+const { promises: mockFs } = await import('fs');
+
+describe('detectFormat', () => {
+  test('returns json for .json files', () => {
+    expect(detectFormat('config.json')).toBe('json');
+    expect(detectFormat('/some/path/data.json')).toBe('json');
+  });
+
+  test('returns yaml for .yml and .yaml files', () => {
+    expect(detectFormat('config.yml')).toBe('yaml');
+    expect(detectFormat('config.yaml')).toBe('yaml');
+  });
+
+  test('returns xml for .xml files', () => {
+    expect(detectFormat('data.xml')).toBe('xml');
+  });
+
+  test('returns toml for .toml files', () => {
+    expect(detectFormat('config.toml')).toBe('toml');
+  });
+
+  test('returns ini for .ini files', () => {
+    expect(detectFormat('settings.ini')).toBe('ini');
+  });
+
+  test('returns env for .env and .env.* files', () => {
+    expect(detectFormat('.env')).toBe('env');
+    expect(detectFormat('.env.local')).toBe('env');
+    expect(detectFormat('.env.production')).toBe('env');
+    expect(detectFormat('.env.custom')).toBe('env');
+  });
+
+  test('returns properties for .properties files', () => {
+    expect(detectFormat('app.properties')).toBe('properties');
+  });
+
+  test('returns null for unknown extensions', () => {
+    expect(detectFormat('readme.txt')).toBeNull();
+    expect(detectFormat('script.py')).toBeNull();
+  });
+});
+
+describe('getSupportedFormats', () => {
+  test('returns array including all built-in formats', () => {
+    const formats = getSupportedFormats();
+    expect(Array.isArray(formats)).toBe(true);
+    expect(formats).toContain('json');
+    expect(formats).toContain('yaml');
+    expect(formats).toContain('xml');
+    expect(formats).toContain('toml');
+    expect(formats).toContain('ini');
+  });
+
+  test('returns unique format names', () => {
+    const formats = getSupportedFormats();
+    const unique = [...new Set(formats)];
+    expect(formats.length).toBe(unique.length);
+  });
+});
+
+describe('validateContent - JSON', () => {
+  test('valid JSON returns { valid: true }', () => {
+    const result = validateContent('{"key": "value"}', 'json');
+    expect(result.valid).toBe(true);
+    expect(result.format).toBe('json');
+    expect(result.errors).toHaveLength(0);
+  });
+
+  test('invalid JSON returns { valid: false } with errors', () => {
+    const result = validateContent('{key: value}', 'json');
+    expect(result.valid).toBe(false);
+    expect(result.errors.length).toBeGreaterThan(0);
+    expect(result.errors[0]).toHaveProperty('message');
+    expect(result.errors[0].severity).toBe('error');
+  });
+
+  test('JSON with returnParsed option includes parsed data', () => {
+    const result = validateContent('{"a": 1}', 'json', { returnParsed: true });
+    expect(result.valid).toBe(true);
+    expect(result.parsed).toEqual({ a: 1 });
+  });
+});
+
+describe('validateContent - YAML', () => {
+  test('valid YAML returns { valid: true }', () => {
+    const result = validateContent('key: value\nother: data', 'yaml');
+    expect(result.valid).toBe(true);
+    expect(result.format).toBe('yaml');
+  });
+
+  test('YAML with tabs returns error', () => {
+    const result = validateContent('\tkey: value', 'yaml');
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.message.includes('tabs'))).toBe(true);
+  });
+});
+
+describe('validateContent - XML', () => {
+  test('valid XML returns { valid: true }', () => {
+    const result = validateContent('<root><child>text</child></root>', 'xml');
+    expect(result.valid).toBe(true);
+    expect(result.format).toBe('xml');
+  });
+
+  test('XML with mismatched tags returns error', () => {
+    const result = validateContent('<root><child>text</wrong></root>', 'xml');
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.message.includes('Mismatched'))).toBe(true);
+  });
+
+  test('XML with unclosed tags returns error', () => {
+    const result = validateContent('<root><child></root>', 'xml');
+    expect(result.valid).toBe(false);
+  });
+
+  test('self-closing XML tags are valid', () => {
+    const result = validateContent('<root><br/></root>', 'xml');
+    expect(result.valid).toBe(true);
+  });
+});
+
+describe('validateContent - TOML', () => {
+  test('valid TOML returns { valid: true }', () => {
+    const result = validateContent('[section]\nkey = "value"', 'toml');
+    expect(result.valid).toBe(true);
+    expect(result.format).toBe('toml');
+  });
+
+  test('TOML with invalid section header returns error', () => {
+    const result = validateContent('[bad section', 'toml');
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.message.includes('Invalid section header'))).toBe(true);
+  });
+
+  test('TOML with duplicate sections returns error', () => {
+    const result = validateContent('[section]\nkey = "a"\n[section]\nkey = "b"', 'toml');
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.message.includes('Duplicate section'))).toBe(true);
+  });
+});
+
+describe('validateContent - INI/ENV/properties', () => {
+  test('valid INI returns { valid: true }', () => {
+    const result = validateContent('[section]\nkey=value', 'ini');
+    expect(result.valid).toBe(true);
+  });
+
+  test('INI with missing closing bracket returns error', () => {
+    const result = validateContent('[section\nkey=value', 'ini');
+    expect(result.valid).toBe(false);
+  });
+
+  test('valid ENV returns { valid: true }', () => {
+    const result = validateContent('MY_VAR=hello\nOTHER=world', 'env');
+    expect(result.valid).toBe(true);
+    expect(result.meta.variableCount).toBe(2);
+  });
+
+  test('ENV with invalid variable name returns error', () => {
+    const result = validateContent('123BAD=value', 'env');
+    expect(result.valid).toBe(false);
+  });
+
+  test('ENV detects duplicate variables as warning', () => {
+    const result = validateContent('VAR=a\nVAR=b', 'env');
+    expect(result.errors.some(e => e.message.includes('Duplicate'))).toBe(true);
+  });
+});
+
+describe('validateContent - unsupported format', () => {
+  test('returns valid=false for unsupported format', () => {
+    const result = validateContent('content', 'unsupported_format_xyz');
+    expect(result.valid).toBe(false);
+    expect(result.errors[0].message).toContain('No validator available');
+  });
+});
+
+describe('validateStructuredFile', () => {
+  test('reads file and validates content', async () => {
+    mockFs.readFile.mockResolvedValue('{"a": 1}');
+    const result = await validateStructuredFile('/path/to/config.json');
+    expect(result.valid).toBe(true);
+    expect(result.meta.filePath).toBe('/path/to/config.json');
+  });
+
+  test('returns error when file cannot be read', async () => {
+    mockFs.readFile.mockRejectedValue(new Error('ENOENT'));
+    const result = await validateStructuredFile('/path/to/missing.json');
+    expect(result.valid).toBe(false);
+    expect(result.meta.readError).toBe(true);
+  });
+
+  test('returns error for unknown format', async () => {
+    const result = await validateStructuredFile('/path/to/file.unknown');
+    expect(result.valid).toBe(false);
+    expect(result.format).toBe('unknown');
+  });
+});
+
+describe('validateForToolResponse', () => {
+  test('returns simplified result for known format', () => {
+    const result = validateForToolResponse('{"a": 1}', 'config.json');
+    expect(result.valid).toBe(true);
+    expect(result.format).toBe('json');
+    expect(result.errorCount).toBe(0);
+  });
+
+  test('returns null for unknown format', () => {
+    const result = validateForToolResponse('content', 'file.txt');
+    expect(result).toBeNull();
+  });
+
+  test('includes errorCount and warningCount for invalid content', () => {
+    const result = validateForToolResponse('{bad json}', 'file.json');
+    expect(result.valid).toBe(false);
+    expect(result.errorCount).toBeGreaterThan(0);
+  });
+});
+
+describe('registerValidator / hasValidator', () => {
+  test('registerValidator adds a custom validator', () => {
+    registerValidator('custom_test_format', (content) => ({
+      valid: true, format: 'custom_test_format', errors: [], meta: {}
+    }));
+    expect(hasValidator('custom_test_format')).toBe(true);
+  });
+
+  test('hasValidator returns false for unregistered format', () => {
+    expect(hasValidator('totally_unknown_format_xyz')).toBe(false);
+  });
+
+  test('registered custom validator is used by validateContent', () => {
+    registerValidator('myformat', (content) => ({
+      valid: content === 'ok',
+      format: 'myformat',
+      errors: content === 'ok' ? [] : [{ message: 'not ok', severity: 'error' }],
+      meta: {}
+    }));
+    expect(validateContent('ok', 'myformat').valid).toBe(true);
+    expect(validateContent('bad', 'myformat').valid).toBe(false);
+  });
+});