@push.rocks/smartrust 1.3.2 → 1.4.1

package/test/test.sockettransport.node.ts

@@ -1,312 +0,0 @@
-import { expect, tap } from '@git.zone/tstest/tapbundle';
-import * as path from 'path';
-import * as fs from 'fs';
-import * as childProcess from 'child_process';
-import * as os from 'os';
-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 mockServerPath = path.join(testDir, 'helpers/mock-socket-server.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 } };
-};
-
-/**
- * Start the mock socket server and return the socket path.
- * Returns { proc, socketPath }.
- */
-async function startMockServer(testName: string): Promise<{ proc: childProcess.ChildProcess; socketPath: string }> {
-  const socketPath = path.join(os.tmpdir(), `smartrust-test-${Date.now()}-${testName}.sock`);
-
-  const proc = childProcess.spawn('node', [mockServerPath, socketPath], {
-    stdio: ['pipe', 'pipe', 'pipe'],
-  });
-
-  // Wait for the server to signal readiness via stdout
-  return new Promise((resolve, reject) => {
-    let stdoutData = '';
-    const timeout = setTimeout(() => {
-      proc.kill();
-      reject(new Error('Mock server did not start within 5s'));
-    }, 5000);
-
-    proc.stdout!.on('data', (data: Buffer) => {
-      stdoutData += data.toString();
-      const lines = stdoutData.split('\n');
-      for (const line of lines) {
-        if (line.trim()) {
-          try {
-            const parsed = JSON.parse(line.trim());
-            if (parsed.ready) {
-              clearTimeout(timeout);
-              resolve({ proc, socketPath: parsed.socketPath });
-              return;
-            }
-          } catch { /* not JSON yet */ }
-        }
-      }
-    });
-
-    proc.on('error', (err) => {
-      clearTimeout(timeout);
-      reject(err);
-    });
-
-    proc.on('exit', (code) => {
-      clearTimeout(timeout);
-      reject(new Error(`Mock server exited with code ${code}`));
-    });
-  });
-}
-
-function stopMockServer(proc: childProcess.ChildProcess, socketPath: string) {
-  try { proc.kill('SIGTERM'); } catch { /* ignore */ }
-  try { fs.unlinkSync(socketPath); } catch { /* ignore */ }
-}
-
-// === Socket Transport Tests via RustBridge.connect() ===
-
-tap.test('socket: should connect and receive ready event', async () => {
-  const { proc, socketPath } = await startMockServer('connect-ready');
-  try {
-    const bridge = new RustBridge<TMockCommands>({
-      binaryName: 'mock-daemon',
-      readyTimeoutMs: 5000,
-    });
-
-    const result = await bridge.connect(socketPath);
-    expect(result).toBeTrue();
-    expect(bridge.running).toBeTrue();
-
-    bridge.kill();
-    expect(bridge.running).toBeFalse();
-  } finally {
-    stopMockServer(proc, socketPath);
-  }
-});
-
-tap.test('socket: should send command and receive response', async () => {
-  const { proc, socketPath } = await startMockServer('send-command');
-  try {
-    const bridge = new RustBridge<TMockCommands>({
-      binaryName: 'mock-daemon',
-      readyTimeoutMs: 5000,
-    });
-
-    await bridge.connect(socketPath);
-
-    const result = await bridge.sendCommand('echo', { hello: 'world', num: 42 });
-    expect(result).toEqual({ hello: 'world', num: 42 });
-
-    bridge.kill();
-  } finally {
-    stopMockServer(proc, socketPath);
-  }
-});
-
-tap.test('socket: should handle error responses', async () => {
-  const { proc, socketPath } = await startMockServer('error-response');
-  try {
-    const bridge = new RustBridge<TMockCommands>({
-      binaryName: 'mock-daemon',
-      readyTimeoutMs: 5000,
-    });
-
-    await bridge.connect(socketPath);
-
-    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();
-  } finally {
-    stopMockServer(proc, socketPath);
-  }
-});
-
-tap.test('socket: should receive custom events', async () => {
-  const { proc, socketPath } = await startMockServer('custom-events');
-  try {
-    const bridge = new RustBridge<TMockCommands>({
-      binaryName: 'mock-daemon',
-      readyTimeoutMs: 5000,
-    });
-
-    await bridge.connect(socketPath);
-
-    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();
-  } finally {
-    stopMockServer(proc, socketPath);
-  }
-});
-
-tap.test('socket: should handle multiple concurrent commands', async () => {
-  const { proc, socketPath } = await startMockServer('concurrent');
-  try {
-    const bridge = new RustBridge<TMockCommands>({
-      binaryName: 'mock-daemon',
-      readyTimeoutMs: 5000,
-    });
-
-    await bridge.connect(socketPath);
-
-    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();
-  } finally {
-    stopMockServer(proc, socketPath);
-  }
-});
-
-tap.test('socket: should handle 1MB payload round-trip', async () => {
-  const { proc, socketPath } = await startMockServer('large-payload');
-  try {
-    const bridge = new RustBridge<TMockCommands>({
-      binaryName: 'mock-daemon',
-      readyTimeoutMs: 5000,
-      requestTimeoutMs: 30000,
-    });
-
-    await bridge.connect(socketPath);
-
-    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();
-  } finally {
-    stopMockServer(proc, socketPath);
-  }
-});
-
-tap.test('socket: should disconnect without killing the daemon', async () => {
-  const { proc, socketPath } = await startMockServer('no-kill-daemon');
-  try {
-    // First connection
-    const bridge1 = new RustBridge<TMockCommands>({
-      binaryName: 'mock-daemon',
-      readyTimeoutMs: 5000,
-    });
-    await bridge1.connect(socketPath);
-    expect(bridge1.running).toBeTrue();
-
-    // Disconnect
-    bridge1.kill();
-    expect(bridge1.running).toBeFalse();
-
-    // Second connection — daemon should still be alive
-    const bridge2 = new RustBridge<TMockCommands>({
-      binaryName: 'mock-daemon',
-      readyTimeoutMs: 5000,
-    });
-    const result = await bridge2.connect(socketPath);
-    expect(result).toBeTrue();
-    expect(bridge2.running).toBeTrue();
-
-    // Verify the daemon is functional
-    const echoResult = await bridge2.sendCommand('echo', { reconnected: true });
-    expect(echoResult).toEqual({ reconnected: true });
-
-    bridge2.kill();
-  } finally {
-    stopMockServer(proc, socketPath);
-  }
-});
-
-tap.test('socket: should stream responses via socket', async () => {
-  const { proc, socketPath } = await startMockServer('streaming');
-  try {
-    const bridge = new RustBridge<TMockCommands>({
-      binaryName: 'mock-daemon',
-      readyTimeoutMs: 5000,
-      requestTimeoutMs: 10000,
-    });
-
-    await bridge.connect(socketPath);
-
-    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();
-  } finally {
-    stopMockServer(proc, socketPath);
-  }
-});
-
-tap.test('socket: should return false when socket path does not exist', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'mock-daemon',
-    readyTimeoutMs: 3000,
-  });
-
-  const result = await bridge.connect('/tmp/nonexistent-smartrust-test.sock');
-  expect(result).toBeFalse();
-  expect(bridge.running).toBeFalse();
-});
-
-tap.test('socket: should throw when sending command while not connected', async () => {
-  const bridge = new RustBridge<TMockCommands>({
-    binaryName: 'mock-daemon',
-  });
-
-  let threw = false;
-  try {
-    await bridge.sendCommand('echo', {});
-  } catch (err: any) {
-    threw = true;
-    expect(err.message).toInclude('not running');
-  }
-  expect(threw).toBeTrue();
-});
-
-export default tap.start();

package/test/test.ts

@@ -1,12 +0,0 @@
-import { expect, tap } from '@git.zone/tstest/tapbundle';
-import * as smartrust from '../ts/index.js';
-
-tap.test('should export RustBridge', async () => {
-  expect(smartrust.RustBridge).toBeTypeOf('function');
-});
-
-tap.test('should export RustBinaryLocator', async () => {
-  expect(smartrust.RustBinaryLocator).toBeTypeOf('function');
-});
-
-export default tap.start();

package/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "esModuleInterop": true,
-    "verbatimModuleSyntax": true
-  },
-  "exclude": [
-    "dist_*/**/*.d.ts"
-  ]
-}