@push.rocks/smartrust 1.3.1 → 1.4.0

package/test/helpers/mock-rust-binary.mjs

@@ -1,104 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Mock "Rust binary" for testing the RustBridge IPC protocol.
- * Reads JSON lines from stdin via Buffer-based scanner, writes JSON lines to stdout.
- * Emits a ready event on startup.
- */
-
-// Emit ready event
-const readyEvent = JSON.stringify({ event: 'ready', data: { version: '1.0.0' } });
-process.stdout.write(readyEvent + '\n');
-
-// Buffer-based newline scanner for stdin (mirrors the RustBridge approach)
-let stdinBuffer = Buffer.alloc(0);
-
-process.stdin.on('data', (chunk) => {
-  stdinBuffer = Buffer.concat([stdinBuffer, chunk]);
-
-  let newlineIndex;
-  while ((newlineIndex = stdinBuffer.indexOf(0x0A)) !== -1) {
-    const lineBuffer = stdinBuffer.subarray(0, newlineIndex);
-    stdinBuffer = stdinBuffer.subarray(newlineIndex + 1);
-    const line = lineBuffer.toString('utf8').trim();
-    if (line) {
-      handleLine(line);
-    }
-  }
-});
-
-/**
- * Backpressure-aware write to stdout.
- */
-function writeResponse(data) {
-  const json = JSON.stringify(data) + '\n';
-  if (!process.stdout.write(json)) {
-    // Wait for drain before continuing
-    process.stdout.once('drain', () => {});
-  }
-}
-
-function handleLine(line) {
-  let request;
-  try {
-    request = JSON.parse(line);
-  } catch {
-    return;
-  }
-
-  const { id, method, params } = request;
-
-  if (method === 'echo') {
-    // Echo back the params as result
-    writeResponse({ id, success: true, result: params });
-  } else if (method === 'largeEcho') {
-    // Echo back params (same as echo, named distinctly for large payload tests)
-    writeResponse({ id, success: true, result: params });
-  } else if (method === 'error') {
-    // Return an error
-    writeResponse({ id, success: false, error: 'Test error message' });
-  } else if (method === 'emitEvent') {
-    // Emit a custom event, then respond with success
-    writeResponse({ event: params.eventName, data: params.eventData });
-    writeResponse({ id, success: true, result: null });
-  } else if (method === 'slow') {
-    // Respond after a delay
-    setTimeout(() => {
-      writeResponse({ id, success: true, result: { delayed: true } });
-    }, 100);
-  } else if (method === 'streamEcho') {
-    // Send params.count stream chunks, then final response
-    const count = params.count || 0;
-    let sent = 0;
-    const interval = setInterval(() => {
-      if (sent < count) {
-        writeResponse({ id, stream: true, data: { index: sent, value: `chunk_${sent}` } });
-        sent++;
-      } else {
-        clearInterval(interval);
-        writeResponse({ id, success: true, result: { totalChunks: count } });
-      }
-    }, 10);
-  } else if (method === 'streamError') {
-    // Send 1 chunk, then error
-    writeResponse({ id, stream: true, data: { index: 0, value: 'before_error' } });
-    setTimeout(() => {
-      writeResponse({ id, success: false, error: 'Stream error after chunk' });
-    }, 20);
-  } else if (method === 'streamEmpty') {
-    // Zero chunks, immediate final response
-    writeResponse({ id, success: true, result: { totalChunks: 0 } });
-  } else if (method === 'exit') {
-    // Graceful exit
-    writeResponse({ id, success: true, result: null });
-    process.exit(0);
-  } else {
-    // Unknown command
-    writeResponse({ id, success: false, error: `Unknown method: ${method}` });
-  }
-}
-
-// Handle SIGTERM gracefully
-process.on('SIGTERM', () => {
-  process.exit(0);
-});

package/test/helpers/mock-socket-server.mjs

@@ -1,124 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Mock "Rust daemon" for testing the SocketTransport and RustBridge socket mode.
- * Creates a Unix socket server, accepts connections, and speaks the same
- * JSON-over-newline IPC protocol as mock-rust-binary.mjs.
- *
- * Usage: node mock-socket-server.mjs <socket-path>
- * Signals readiness by writing a JSON line to stdout: {"socketPath":"...","ready":true}
- */
-
-import * as net from 'net';
-import * as fs from 'fs';
-
-const socketPath = process.argv[2];
-if (!socketPath) {
-  process.stderr.write('Usage: mock-socket-server.mjs <socket-path>\n');
-  process.exit(1);
-}
-
-// Remove stale socket file
-try { fs.unlinkSync(socketPath); } catch { /* ignore */ }
-
-/**
- * Backpressure-aware write to a socket.
- */
-function writeResponse(conn, data) {
-  const json = JSON.stringify(data) + '\n';
-  if (!conn.write(json)) {
-    conn.once('drain', () => {});
-  }
-}
-
-function handleLine(line, conn) {
-  let request;
-  try {
-    request = JSON.parse(line);
-  } catch {
-    return;
-  }
-
-  const { id, method, params } = request;
-
-  if (method === 'echo') {
-    writeResponse(conn, { id, success: true, result: params });
-  } else if (method === 'largeEcho') {
-    writeResponse(conn, { id, success: true, result: params });
-  } else if (method === 'error') {
-    writeResponse(conn, { id, success: false, error: 'Test error message' });
-  } else if (method === 'emitEvent') {
-    writeResponse(conn, { event: params.eventName, data: params.eventData });
-    writeResponse(conn, { id, success: true, result: null });
-  } else if (method === 'slow') {
-    setTimeout(() => {
-      writeResponse(conn, { id, success: true, result: { delayed: true } });
-    }, 100);
-  } else if (method === 'streamEcho') {
-    const count = params.count || 0;
-    let sent = 0;
-    const interval = setInterval(() => {
-      if (sent < count) {
-        writeResponse(conn, { id, stream: true, data: { index: sent, value: `chunk_${sent}` } });
-        sent++;
-      } else {
-        clearInterval(interval);
-        writeResponse(conn, { id, success: true, result: { totalChunks: count } });
-      }
-    }, 10);
-  } else if (method === 'streamError') {
-    writeResponse(conn, { id, stream: true, data: { index: 0, value: 'before_error' } });
-    setTimeout(() => {
-      writeResponse(conn, { id, success: false, error: 'Stream error after chunk' });
-    }, 20);
-  } else if (method === 'streamEmpty') {
-    writeResponse(conn, { id, success: true, result: { totalChunks: 0 } });
-  } else if (method === 'exit') {
-    writeResponse(conn, { id, success: true, result: null });
-    // In socket mode, 'exit' just closes this connection, not the server
-    setTimeout(() => conn.end(), 50);
-  } else {
-    writeResponse(conn, { id, success: false, error: `Unknown method: ${method}` });
-  }
-}
-
-const server = net.createServer((conn) => {
-  // Send ready event on each new connection
-  writeResponse(conn, { event: 'ready', data: { version: '1.0.0' } });
-
-  // Buffer-based newline scanner for incoming data
-  let buffer = Buffer.alloc(0);
-  conn.on('data', (chunk) => {
-    buffer = Buffer.concat([buffer, chunk]);
-    let idx;
-    while ((idx = buffer.indexOf(0x0A)) !== -1) {
-      const lineBuffer = buffer.subarray(0, idx);
-      buffer = buffer.subarray(idx + 1);
-      const line = lineBuffer.toString('utf8').trim();
-      if (line) {
-        handleLine(line, conn);
-      }
-    }
-  });
-
-  conn.on('error', () => { /* ignore client errors */ });
-});
-
-server.listen(socketPath, () => {
-  // Signal to parent that the server is ready
-  process.stdout.write(JSON.stringify({ socketPath, ready: true }) + '\n');
-});
-
-// Handle SIGTERM gracefully
-process.on('SIGTERM', () => {
-  server.close();
-  try { fs.unlinkSync(socketPath); } catch { /* ignore */ }
-  process.exit(0);
-});
-
-// Handle SIGINT
-process.on('SIGINT', () => {
-  server.close();
-  try { fs.unlinkSync(socketPath); } catch { /* ignore */ }
-  process.exit(0);
-});

package/test/test.linescanner.node.ts

@@ -1,89 +0,0 @@
-import { expect, tap } from '@git.zone/tstest/tapbundle';
-import { LineScanner } from '../ts/classes.linescanner.js';
-
-const noopLogger = { log() {} };
-
-tap.test('should parse a single complete line', async () => {
-  const scanner = new LineScanner(1024 * 1024, noopLogger);
-  const lines: string[] = [];
-  scanner.push(Buffer.from('{"hello":"world"}\n'), (line) => lines.push(line));
-  expect(lines.length).toEqual(1);
-  expect(lines[0]).toEqual('{"hello":"world"}');
-});
-
-tap.test('should parse multiple lines in one chunk', async () => {
-  const scanner = new LineScanner(1024 * 1024, noopLogger);
-  const lines: string[] = [];
-  scanner.push(Buffer.from('{"a":1}\n{"b":2}\n{"c":3}\n'), (line) => lines.push(line));
-  expect(lines.length).toEqual(3);
-  expect(lines[0]).toEqual('{"a":1}');
-  expect(lines[1]).toEqual('{"b":2}');
-  expect(lines[2]).toEqual('{"c":3}');
-});
-
-tap.test('should handle a line split across chunks', async () => {
-  const scanner = new LineScanner(1024 * 1024, noopLogger);
-  const lines: string[] = [];
-  scanner.push(Buffer.from('{"hel'), (line) => lines.push(line));
-  expect(lines.length).toEqual(0);
-  scanner.push(Buffer.from('lo":"world"}\n'), (line) => lines.push(line));
-  expect(lines.length).toEqual(1);
-  expect(lines[0]).toEqual('{"hello":"world"}');
-});
-
-tap.test('should drop oversized lines', async () => {
-  const scanner = new LineScanner(100, noopLogger);
-  const lines: string[] = [];
-  // Line is 200 chars + newline, exceeds maxPayloadSize of 100
-  const oversized = 'x'.repeat(200) + '\n';
-  scanner.push(Buffer.from(oversized), (line) => lines.push(line));
-  expect(lines.length).toEqual(0);
-});
-
-tap.test('should clear buffer on OOM (no newline, exceeds max)', async () => {
-  const scanner = new LineScanner(100, noopLogger);
-  const lines: string[] = [];
-  // Push 200 bytes without any newline — exceeds maxPayloadSize
-  scanner.push(Buffer.from('x'.repeat(200)), (line) => lines.push(line));
-  expect(lines.length).toEqual(0);
-  // After clearing, should work normally again
-  scanner.push(Buffer.from('{"ok":true}\n'), (line) => lines.push(line));
-  expect(lines.length).toEqual(1);
-  expect(lines[0]).toEqual('{"ok":true}');
-});
-
-tap.test('should skip empty lines', async () => {
-  const scanner = new LineScanner(1024 * 1024, noopLogger);
-  const lines: string[] = [];
-  scanner.push(Buffer.from('\n\n{"a":1}\n\n'), (line) => lines.push(line));
-  expect(lines.length).toEqual(1);
-  expect(lines[0]).toEqual('{"a":1}');
-});
-
-tap.test('should handle mixed complete and partial lines', async () => {
-  const scanner = new LineScanner(1024 * 1024, noopLogger);
-  const lines: string[] = [];
-  // First chunk: one complete line + start of second line
-  scanner.push(Buffer.from('{"first":1}\n{"sec'), (line) => lines.push(line));
-  expect(lines.length).toEqual(1);
-  // Second chunk: end of second line + complete third line
-  scanner.push(Buffer.from('ond":2}\n{"third":3}\n'), (line) => lines.push(line));
-  expect(lines.length).toEqual(3);
-  expect(lines[1]).toEqual('{"second":2}');
-  expect(lines[2]).toEqual('{"third":3}');
-});
-
-tap.test('clear should reset the buffer', async () => {
-  const scanner = new LineScanner(1024 * 1024, noopLogger);
-  const lines: string[] = [];
-  // Push partial data
-  scanner.push(Buffer.from('{"partial":'), (line) => lines.push(line));
-  // Clear
-  scanner.clear();
-  // Now push a complete new line — old partial should not affect it
-  scanner.push(Buffer.from('{"fresh":true}\n'), (line) => lines.push(line));
-  expect(lines.length).toEqual(1);
-  expect(lines[0]).toEqual('{"fresh":true}');
-});
-
-export default tap.start();

package/test/test.rustbinarylocator.node.ts

@@ -1,98 +0,0 @@
-import { expect, tap } from '@git.zone/tstest/tapbundle';
-import * as path from 'path';
-import * as fs from 'fs';
-import { RustBinaryLocator } from '../ts/classes.rustbinarylocator.js';
-
-const testDir = path.resolve(path.dirname(new URL(import.meta.url).pathname));
-
-tap.test('should return null when no binary is found', async () => {
-  const locator = new RustBinaryLocator({
-    binaryName: 'nonexistent-binary-xyz',
-    searchSystemPath: false,
-  });
-  const result = await locator.findBinary();
-  expect(result).toBeNull();
-});
-
-tap.test('should use explicit binaryPath when provided', async () => {
-  const mockBinaryPath = path.join(testDir, 'helpers/mock-rust-binary.mjs');
-  const locator = new RustBinaryLocator({
-    binaryName: 'mock-rust-binary',
-    binaryPath: mockBinaryPath,
-    searchSystemPath: false,
-  });
-  const result = await locator.findBinary();
-  expect(result).toEqual(mockBinaryPath);
-});
-
-tap.test('should cache the result', async () => {
-  const mockBinaryPath = path.join(testDir, 'helpers/mock-rust-binary.mjs');
-  const locator = new RustBinaryLocator({
-    binaryName: 'mock-rust-binary',
-    binaryPath: mockBinaryPath,
-    searchSystemPath: false,
-  });
-
-  const first = await locator.findBinary();
-  const second = await locator.findBinary();
-  expect(first).toEqual(second);
-  expect(first).toEqual(mockBinaryPath);
-});
-
-tap.test('should clear cache', async () => {
-  const mockBinaryPath = path.join(testDir, 'helpers/mock-rust-binary.mjs');
-  const locator = new RustBinaryLocator({
-    binaryName: 'mock-rust-binary',
-    binaryPath: mockBinaryPath,
-    searchSystemPath: false,
-  });
-
-  const first = await locator.findBinary();
-  expect(first).toEqual(mockBinaryPath);
-
-  locator.clearCache();
-  // After clearing, next call should re-search and still find it
-  const second = await locator.findBinary();
-  expect(second).toEqual(mockBinaryPath);
-});
-
-tap.test('should fall back to env var when binaryPath not set', async () => {
-  const mockBinaryPath = path.join(testDir, 'helpers/mock-rust-binary.mjs');
-  const envVar = 'TEST_SMARTRUST_BINARY_' + Date.now();
-  process.env[envVar] = mockBinaryPath;
-
-  const locator = new RustBinaryLocator({
-    binaryName: 'mock-rust-binary',
-    envVarName: envVar,
-    searchSystemPath: false,
-  });
-
-  const result = await locator.findBinary();
-  expect(result).toEqual(mockBinaryPath);
-
-  delete process.env[envVar];
-});
-
-tap.test('should find binary in local paths', async () => {
-  const mockBinaryPath = path.join(testDir, 'helpers/mock-rust-binary.mjs');
-  const locator = new RustBinaryLocator({
-    binaryName: 'mock-rust-binary',
-    localPaths: ['/nonexistent/path/binary', mockBinaryPath],
-    searchSystemPath: false,
-  });
-
-  const result = await locator.findBinary();
-  expect(result).toEqual(mockBinaryPath);
-});
-
-tap.test('should find node in system PATH', async () => {
-  const locator = new RustBinaryLocator({
-    binaryName: 'node',
-    searchSystemPath: true,
-  });
-
-  const result = await locator.findBinary();
-  expect(result).not.toBeNull();
-});
-
-export default tap.start();