Squashed 'vendor/ruvector/' content from commit b64c2172

git-subtree-dir: vendor/ruvector
git-subtree-split: b64c21726f2bb37286d9ee36a7869fef60cc6900

npm/packages/agentic-synth/tests/integration/robotics.test.js

@@ -0,0 +1,216 @@
+/**
+ * Integration tests for Agentic Robotics adapter
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { RoboticsAdapter } from '../../src/adapters/robotics.js';
+import { DataGenerator } from '../../src/generators/data-generator.js';
+
+describe('Agentic Robotics Integration', () => {
+  let adapter;
+  let generator;
+
+  beforeEach(async () => {
+    adapter = new RoboticsAdapter({
+      endpoint: 'http://localhost:9000',
+      protocol: 'grpc'
+    });
+
+    generator = new DataGenerator({
+      schema: {
+        action: { type: 'string', length: 8 },
+        value: { type: 'number', min: 0, max: 100 }
+      }
+    });
+
+    await adapter.initialize();
+  });
+
+  afterEach(async () => {
+    if (adapter.initialized) {
+      await adapter.shutdown();
+    }
+  });
+
+  describe('initialization', () => {
+    it('should initialize adapter', async () => {
+      const newAdapter = new RoboticsAdapter();
+      await newAdapter.initialize();
+      expect(newAdapter.initialized).toBe(true);
+    });
+
+    it('should handle re-initialization', async () => {
+      await adapter.initialize();
+      expect(adapter.initialized).toBe(true);
+    });
+
+    it('should shutdown adapter', async () => {
+      await adapter.shutdown();
+      expect(adapter.initialized).toBe(false);
+    });
+  });
+
+  describe('command execution', () => {
+    it('should send basic command', async () => {
+      const command = {
+        type: 'move',
+        payload: { x: 10, y: 20 }
+      };
+
+      const result = await adapter.sendCommand(command);
+
+      expect(result).toHaveProperty('commandId');
+      expect(result.type).toBe('move');
+      expect(result.status).toBe('executed');
+      expect(result.result).toEqual({ x: 10, y: 20 });
+    });
+
+    it('should throw error when not initialized', async () => {
+      await adapter.shutdown();
+
+      await expect(adapter.sendCommand({ type: 'test' })).rejects.toThrow(
+        'Robotics adapter not initialized'
+      );
+    });
+
+    it('should validate command structure', async () => {
+      await expect(adapter.sendCommand({})).rejects.toThrow('Invalid command: missing type');
+      await expect(adapter.sendCommand(null)).rejects.toThrow('Invalid command: missing type');
+    });
+
+    it('should handle commands without payload', async () => {
+      const command = { type: 'status' };
+      const result = await adapter.sendCommand(command);
+
+      expect(result.type).toBe('status');
+      expect(result.status).toBe('executed');
+    });
+  });
+
+  describe('status monitoring', () => {
+    it('should get adapter status', async () => {
+      const status = await adapter.getStatus();
+
+      expect(status).toHaveProperty('initialized');
+      expect(status).toHaveProperty('protocol');
+      expect(status).toHaveProperty('endpoint');
+      expect(status.initialized).toBe(true);
+      expect(status.protocol).toBe('grpc');
+    });
+
+    it('should throw error when checking status while not initialized', async () => {
+      await adapter.shutdown();
+
+      await expect(adapter.getStatus()).rejects.toThrow(
+        'Robotics adapter not initialized'
+      );
+    });
+  });
+
+  describe('end-to-end workflow', () => {
+    it('should generate data and execute commands', async () => {
+      // Generate synthetic command data
+      const data = generator.generate(5);
+
+      // Execute commands
+      const results = [];
+      for (const item of data) {
+        const result = await adapter.sendCommand({
+          type: 'execute',
+          payload: item
+        });
+        results.push(result);
+      }
+
+      expect(results).toHaveLength(5);
+      results.forEach(result => {
+        expect(result.status).toBe('executed');
+        expect(result).toHaveProperty('commandId');
+      });
+    });
+
+    it('should handle batch command execution', async () => {
+      const commands = [
+        { type: 'init', payload: { config: 'test' } },
+        { type: 'move', payload: { x: 1, y: 2 } },
+        { type: 'rotate', payload: { angle: 90 } },
+        { type: 'stop' }
+      ];
+
+      const results = await Promise.all(
+        commands.map(cmd => adapter.sendCommand(cmd))
+      );
+
+      expect(results).toHaveLength(4);
+      expect(results[0].type).toBe('init');
+      expect(results[1].type).toBe('move');
+      expect(results[2].type).toBe('rotate');
+      expect(results[3].type).toBe('stop');
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle initialization failure gracefully', async () => {
+      const failingAdapter = new RoboticsAdapter({
+        endpoint: 'http://invalid:99999'
+      });
+
+      // Note: Mock implementation always succeeds
+      await expect(failingAdapter.initialize()).resolves.toBe(true);
+    });
+
+    it('should handle command execution errors', async () => {
+      await adapter.shutdown();
+
+      await expect(adapter.sendCommand({ type: 'test' })).rejects.toThrow();
+    });
+  });
+
+  describe('performance', () => {
+    it('should execute 100 commands quickly', async () => {
+      const commands = Array.from({ length: 100 }, (_, i) => ({
+        type: 'test',
+        payload: { index: i }
+      }));
+
+      const start = Date.now();
+      await Promise.all(commands.map(cmd => adapter.sendCommand(cmd)));
+      const duration = Date.now() - start;
+
+      expect(duration).toBeLessThan(1000); // Less than 1 second
+    });
+
+    it('should handle concurrent command execution', async () => {
+      const concurrentCommands = 50;
+      const commands = Array.from({ length: concurrentCommands }, (_, i) => ({
+        type: 'concurrent',
+        payload: { id: i }
+      }));
+
+      const results = await Promise.all(
+        commands.map(cmd => adapter.sendCommand(cmd))
+      );
+
+      expect(results).toHaveLength(concurrentCommands);
+      results.forEach(result => {
+        expect(result.status).toBe('executed');
+      });
+    });
+  });
+
+  describe('protocol support', () => {
+    it('should support different protocols', async () => {
+      const protocols = ['grpc', 'http', 'websocket'];
+
+      for (const protocol of protocols) {
+        const protocolAdapter = new RoboticsAdapter({ protocol });
+        await protocolAdapter.initialize();
+
+        const status = await protocolAdapter.getStatus();
+        expect(status.protocol).toBe(protocol);
+
+        await protocolAdapter.shutdown();
+      }
+    });
+  });
+});