@push.rocks/smartrust 1.3.1 → 1.4.0

package/test/test.rustbridge.node.ts

@@ -1,440 +0,0 @@
-import { expect, tap } from '@git.zone/tstest/tapbundle';
-import * as path from 'path';
-import { RustBridge } from '../ts/classes.rustbridge.js';
-import type { ICommandDefinition } from '../ts/interfaces/index.js';
-
-const testDir = path.resolve(path.dirname(new URL(import.meta.url).pathname));
-const mockBinaryPath = path.join(testDir, 'helpers/mock-rust-binary.mjs');
-
-// Define the command types for our mock binary
-type TMockCommands = {
-  echo: { params: Record<string, any>; result: Record<string, any> };
-  largeEcho: { params: Record<string, any>; result: Record<string, any> };
-  error: { params: {}; result: never };
-  emitEvent: { params: { eventName: string; eventData: any }; result: null };
-  slow: { params: {}; result: { delayed: boolean } };
-  exit: { params: {}; result: null };
-  streamEcho: { params: { count: number }; chunk: { index: number; value: string }; result: { totalChunks: number } };
-  streamError: { params: {}; chunk: { index: number; value: string }; result: never };
-  streamEmpty: { params: {}; chunk: never; result: { totalChunks: number } };
-};
-
-tap.test('should spawn and receive ready event', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'node',
-    binaryPath: 'node',
-    cliArgs: [mockBinaryPath],
-    readyTimeoutMs: 5000,
-  });
-
-  const result = await bridge.spawn();
-  expect(result).toBeTrue();
-  expect(bridge.running).toBeTrue();
-
-  bridge.kill();
-  expect(bridge.running).toBeFalse();
-});
-
-tap.test('should send command and receive response', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'node',
-    binaryPath: 'node',
-    cliArgs: [mockBinaryPath],
-    readyTimeoutMs: 5000,
-  });
-
-  await bridge.spawn();
-
-  const result = await bridge.sendCommand('echo', { hello: 'world', num: 42 });
-  expect(result).toEqual({ hello: 'world', num: 42 });
-
-  bridge.kill();
-});
-
-tap.test('should handle error responses', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'node',
-    binaryPath: 'node',
-    cliArgs: [mockBinaryPath],
-    readyTimeoutMs: 5000,
-  });
-
-  await bridge.spawn();
-
-  let threw = false;
-  try {
-    await bridge.sendCommand('error', {});
-  } catch (err: any) {
-    threw = true;
-    expect(err.message).toInclude('Test error message');
-  }
-  expect(threw).toBeTrue();
-
-  bridge.kill();
-});
-
-tap.test('should receive custom events from the binary', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'node',
-    binaryPath: 'node',
-    cliArgs: [mockBinaryPath],
-    readyTimeoutMs: 5000,
-  });
-
-  await bridge.spawn();
-
-  const eventPromise = new Promise<any>((resolve) => {
-    bridge.once('management:testEvent', (data) => {
-      resolve(data);
-    });
-  });
-
-  await bridge.sendCommand('emitEvent', {
-    eventName: 'testEvent',
-    eventData: { key: 'value' },
-  });
-
-  const eventData = await eventPromise;
-  expect(eventData).toEqual({ key: 'value' });
-
-  bridge.kill();
-});
-
-tap.test('should handle delayed responses', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'node',
-    binaryPath: 'node',
-    cliArgs: [mockBinaryPath],
-    readyTimeoutMs: 5000,
-    requestTimeoutMs: 5000,
-  });
-
-  await bridge.spawn();
-
-  const result = await bridge.sendCommand('slow', {});
-  expect(result).toEqual({ delayed: true });
-
-  bridge.kill();
-});
-
-tap.test('should handle multiple concurrent commands', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'node',
-    binaryPath: 'node',
-    cliArgs: [mockBinaryPath],
-    readyTimeoutMs: 5000,
-  });
-
-  await bridge.spawn();
-
-  const results = await Promise.all([
-    bridge.sendCommand('echo', { id: 1 }),
-    bridge.sendCommand('echo', { id: 2 }),
-    bridge.sendCommand('echo', { id: 3 }),
-  ]);
-
-  expect(results[0]).toEqual({ id: 1 });
-  expect(results[1]).toEqual({ id: 2 });
-  expect(results[2]).toEqual({ id: 3 });
-
-  bridge.kill();
-});
-
-tap.test('should throw when sending command while not running', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'node',
-    binaryPath: 'node',
-    cliArgs: [mockBinaryPath],
-  });
-
-  let threw = false;
-  try {
-    await bridge.sendCommand('echo', {});
-  } catch (err: any) {
-    threw = true;
-    expect(err.message).toInclude('not running');
-  }
-  expect(threw).toBeTrue();
-});
-
-tap.test('should return false when binary not found', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'nonexistent-binary-xyz',
-    searchSystemPath: false,
-  });
-
-  const result = await bridge.spawn();
-  expect(result).toBeFalse();
-  expect(bridge.running).toBeFalse();
-});
-
-tap.test('should emit exit event when process exits', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'node',
-    binaryPath: 'node',
-    cliArgs: [mockBinaryPath],
-    readyTimeoutMs: 5000,
-  });
-
-  await bridge.spawn();
-
-  const exitPromise = new Promise<number | null>((resolve) => {
-    bridge.once('exit', (code) => {
-      resolve(code);
-    });
-  });
-
-  // Tell mock binary to exit
-  await bridge.sendCommand('exit', {});
-
-  const exitCode = await exitPromise;
-  expect(exitCode).toEqual(0);
-  expect(bridge.running).toBeFalse();
-});
-
-tap.test('should handle 1MB payload round-trip', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'node',
-    binaryPath: 'node',
-    cliArgs: [mockBinaryPath],
-    readyTimeoutMs: 5000,
-    requestTimeoutMs: 30000,
-  });
-
-  await bridge.spawn();
-
-  // Create a ~1MB payload
-  const largeString = 'x'.repeat(1024 * 1024);
-  const result = await bridge.sendCommand('largeEcho', { data: largeString });
-  expect(result.data).toEqual(largeString);
-  expect(result.data.length).toEqual(1024 * 1024);
-
-  bridge.kill();
-});
-
-tap.test('should handle 10MB payload round-trip', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'node',
-    binaryPath: 'node',
-    cliArgs: [mockBinaryPath],
-    readyTimeoutMs: 5000,
-    requestTimeoutMs: 60000,
-  });
-
-  await bridge.spawn();
-
-  // Create a ~10MB payload
-  const largeString = 'y'.repeat(10 * 1024 * 1024);
-  const result = await bridge.sendCommand('largeEcho', { data: largeString });
-  expect(result.data).toEqual(largeString);
-  expect(result.data.length).toEqual(10 * 1024 * 1024);
-
-  bridge.kill();
-});
-
-tap.test('should reject outbound messages exceeding maxPayloadSize', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'node',
-    binaryPath: 'node',
-    cliArgs: [mockBinaryPath],
-    readyTimeoutMs: 5000,
-    maxPayloadSize: 1000,
-  });
-
-  await bridge.spawn();
-
-  let threw = false;
-  try {
-    await bridge.sendCommand('largeEcho', { data: 'z'.repeat(2000) });
-  } catch (err: any) {
-    threw = true;
-    expect(err.message).toInclude('maxPayloadSize');
-  }
-  expect(threw).toBeTrue();
-
-  bridge.kill();
-});
-
-tap.test('should handle multiple large concurrent commands', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'node',
-    binaryPath: 'node',
-    cliArgs: [mockBinaryPath],
-    readyTimeoutMs: 5000,
-    requestTimeoutMs: 30000,
-  });
-
-  await bridge.spawn();
-
-  const size = 500 * 1024; // 500KB each
-  const results = await Promise.all([
-    bridge.sendCommand('largeEcho', { data: 'a'.repeat(size), id: 1 }),
-    bridge.sendCommand('largeEcho', { data: 'b'.repeat(size), id: 2 }),
-    bridge.sendCommand('largeEcho', { data: 'c'.repeat(size), id: 3 }),
-  ]);
-
-  expect(results[0].data.length).toEqual(size);
-  expect(results[0].data[0]).toEqual('a');
-  expect(results[1].data.length).toEqual(size);
-  expect(results[1].data[0]).toEqual('b');
-  expect(results[2].data.length).toEqual(size);
-  expect(results[2].data[0]).toEqual('c');
-
-  bridge.kill();
-});
-
-// === Streaming tests ===
-
-tap.test('streaming: should receive chunks via for-await-of and final result', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'node',
-    binaryPath: 'node',
-    cliArgs: [mockBinaryPath],
-    readyTimeoutMs: 5000,
-    requestTimeoutMs: 10000,
-  });
-
-  await bridge.spawn();
-
-  const stream = bridge.sendCommandStreaming('streamEcho', { count: 5 });
-  const chunks: Array<{ index: number; value: string }> = [];
-
-  for await (const chunk of stream) {
-    chunks.push(chunk);
-  }
-
-  expect(chunks.length).toEqual(5);
-  for (let i = 0; i < 5; i++) {
-    expect(chunks[i].index).toEqual(i);
-    expect(chunks[i].value).toEqual(`chunk_${i}`);
-  }
-
-  const result = await stream.result;
-  expect(result.totalChunks).toEqual(5);
-
-  bridge.kill();
-});
-
-tap.test('streaming: should handle zero chunks (immediate result)', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'node',
-    binaryPath: 'node',
-    cliArgs: [mockBinaryPath],
-    readyTimeoutMs: 5000,
-  });
-
-  await bridge.spawn();
-
-  const stream = bridge.sendCommandStreaming('streamEmpty', {});
-  const chunks: any[] = [];
-
-  for await (const chunk of stream) {
-    chunks.push(chunk);
-  }
-
-  expect(chunks.length).toEqual(0);
-
-  const result = await stream.result;
-  expect(result.totalChunks).toEqual(0);
-
-  bridge.kill();
-});
-
-tap.test('streaming: should propagate error to iterator and .result', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'node',
-    binaryPath: 'node',
-    cliArgs: [mockBinaryPath],
-    readyTimeoutMs: 5000,
-    requestTimeoutMs: 10000,
-  });
-
-  await bridge.spawn();
-
-  const stream = bridge.sendCommandStreaming('streamError', {});
-  const chunks: any[] = [];
-  let iteratorError: Error | null = null;
-
-  try {
-    for await (const chunk of stream) {
-      chunks.push(chunk);
-    }
-  } catch (err: any) {
-    iteratorError = err;
-  }
-
-  // Should have received at least one chunk before error
-  expect(chunks.length).toEqual(1);
-  expect(chunks[0].value).toEqual('before_error');
-
-  // Iterator should have thrown
-  expect(iteratorError).toBeTruthy();
-  expect(iteratorError!.message).toInclude('Stream error after chunk');
-
-  // .result should also reject
-  let resultError: Error | null = null;
-  try {
-    await stream.result;
-  } catch (err: any) {
-    resultError = err;
-  }
-  expect(resultError).toBeTruthy();
-  expect(resultError!.message).toInclude('Stream error after chunk');
-
-  bridge.kill();
-});
-
-tap.test('streaming: should fail when bridge is not running', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'node',
-    binaryPath: 'node',
-    cliArgs: [mockBinaryPath],
-  });
-
-  const stream = bridge.sendCommandStreaming('streamEcho', { count: 3 });
-
-  let resultError: Error | null = null;
-  try {
-    await stream.result;
-  } catch (err: any) {
-    resultError = err;
-  }
-  expect(resultError).toBeTruthy();
-  expect(resultError!.message).toInclude('not running');
-});
-
-tap.test('streaming: should fail when killed mid-stream', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'node',
-    binaryPath: 'node',
-    cliArgs: [mockBinaryPath],
-    readyTimeoutMs: 5000,
-    requestTimeoutMs: 30000,
-  });
-
-  await bridge.spawn();
-
-  // Request many chunks so we can kill mid-stream
-  const stream = bridge.sendCommandStreaming('streamEcho', { count: 100 });
-  const chunks: any[] = [];
-  let iteratorError: Error | null = null;
-
-  // Kill after a short delay
-  setTimeout(() => {
-    bridge.kill();
-  }, 50);
-
-  try {
-    for await (const chunk of stream) {
-      chunks.push(chunk);
-    }
-  } catch (err: any) {
-    iteratorError = err;
-  }
-
-  // Should have gotten some chunks but not all
-  expect(iteratorError).toBeTruthy();
-  expect(iteratorError!.message).toInclude('killed');
-});
-
-export default tap.start();