openclaw-overlay-plugin 0.7.22

package/src/test/request-response-flow.test.ts

@@ -0,0 +1,252 @@
+/**
+ * Tests for request/response flow and duplicate prevention.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+
+// Simple test runner (matching existing pattern)
+let passed = 0;
+let failed = 0;
+
+function test(name: string, fn: () => void | Promise<void>) {
+  return (async () => {
+    try {
+      await fn();
+      console.log(`  ✓ ${name}`);
+      passed++;
+    } catch (err: unknown) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(`  ✗ ${name}`);
+      console.log(`    ${msg}`);
+      failed++;
+    }
+  })();
+}
+
+function assert(condition: boolean, message: string) {
+  if (!condition) throw new Error(`Assertion failed: ${message}`);
+}
+
+// Mock paths for testing
+const TEST_DIR = path.join(process.cwd(), 'test-data');
+const TEST_PATHS = {
+  serviceQueue: path.join(TEST_DIR, 'service-queue.jsonl'),
+  walletDir: path.join(TEST_DIR, 'wallet'),
+  registration: path.join(TEST_DIR, 'registration.json'),
+  services: path.join(TEST_DIR, 'services.json'),
+};
+
+function setupTestEnv() {
+  // Setup test directory
+  if (fs.existsSync(TEST_DIR)) {
+    fs.rmSync(TEST_DIR, { recursive: true, force: true });
+  }
+  fs.mkdirSync(TEST_DIR, { recursive: true });
+}
+
+function cleanupTestEnv() {
+  if (fs.existsSync(TEST_DIR)) {
+    fs.rmSync(TEST_DIR, { recursive: true, force: true });
+  }
+}
+
+async function run() {
+  console.log('\nRequest/Response Flow Tests\n');
+
+  // ── Queue Cleanup Tests ──────────────────────────────────────────────
+
+  await test('cleanupServiceQueue removes old fulfilled entries', async () => {
+    setupTestEnv();
+
+    const now = Date.now();
+    const oldTime = now - (3 * 60 * 60 * 1000); // 3 hours ago
+    const recentTime = now - (30 * 60 * 1000); // 30 minutes ago
+
+    // Add test entries
+    const entries = [
+      { status: 'pending', requestId: 'pending-1', _ts: recentTime },
+      { status: 'fulfilled', requestId: 'old-fulfilled', _ts: oldTime },
+      { status: 'fulfilled', requestId: 'recent-fulfilled', _ts: recentTime },
+      { status: 'rejected', requestId: 'old-rejected', _ts: oldTime }
+    ];
+
+    const content = entries.map(e => JSON.stringify(e)).join('\n') + '\n';
+    fs.writeFileSync(TEST_PATHS.serviceQueue, content);
+
+    // Mock PATHS for cleanupServiceQueue
+    const originalPaths = await import('../scripts/config.js');
+    const mockPaths = { ...originalPaths.PATHS, serviceQueue: TEST_PATHS.serviceQueue };
+
+    // Temporarily replace PATHS
+    (globalThis as Record<string, unknown>).mockPaths = mockPaths;
+
+    // Redefine cleanupServiceQueue with mocked paths
+    function mockCleanupServiceQueue(maxAgeMs = 24 * 60 * 60 * 1000, finalStatusMaxAgeMs = 2 * 60 * 60 * 1000) {
+      if (!fs.existsSync(TEST_PATHS.serviceQueue)) return;
+
+      const currentTime = Date.now();
+      const finalStatuses = ['fulfilled', 'rejected', 'delivery_failed', 'failed', 'error'];
+
+      const lines = fs.readFileSync(TEST_PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
+      const keptLines: string[] = [];
+      let removedCount = 0;
+
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          const entryAge = currentTime - (entry._ts || 0);
+
+          // Always keep pending entries that aren't too old
+          if (entry.status === 'pending' && entryAge < maxAgeMs) {
+            keptLines.push(line);
+            continue;
+          }
+
+          // Keep final status entries only if they're recent
+          if (finalStatuses.includes(entry.status) && entryAge < finalStatusMaxAgeMs) {
+            keptLines.push(line);
+            continue;
+          }
+
+          // Remove this entry
+          removedCount++;
+        } catch {
+          // Keep malformed entries to avoid data loss
+          keptLines.push(line);
+        }
+      }
+
+      if (removedCount > 0) {
+        fs.writeFileSync(TEST_PATHS.serviceQueue, keptLines.join('\n') + (keptLines.length ? '\n' : ''));
+      }
+    }
+
+    // Run cleanup with 2 hour limit for final statuses
+    mockCleanupServiceQueue(24 * 60 * 60 * 1000, 2 * 60 * 60 * 1000);
+
+    // Check remaining entries
+    const lines = fs.readFileSync(TEST_PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
+    const remaining = lines.map(line => JSON.parse(line));
+
+    assert(remaining.length === 2, `Expected 2 remaining entries, got ${remaining.length}`);
+    assert(remaining.find(e => e.requestId === 'pending-1') !== undefined, 'Should keep recent pending');
+    assert(remaining.find(e => e.requestId === 'recent-fulfilled') !== undefined, 'Should keep recent fulfilled');
+    assert(remaining.find(e => e.requestId === 'old-fulfilled') === undefined, 'Should remove old fulfilled');
+    assert(remaining.find(e => e.requestId === 'old-rejected') === undefined, 'Should remove old rejected');
+
+    cleanupTestEnv();
+  });
+
+  await test('updateServiceQueueStatus updates request status atomically', async () => {
+    setupTestEnv();
+
+    // Add a test entry
+    const entry = {
+      status: 'pending',
+      requestId: 'test-request-456',
+      serviceId: 'test-service',
+      from: 'sender-key',
+      _ts: Date.now()
+    };
+
+    fs.writeFileSync(TEST_PATHS.serviceQueue, JSON.stringify(entry) + '\n');
+
+    // Mock updateServiceQueueStatus with test paths
+    function mockUpdateServiceQueueStatus(requestId: string, newStatus: string, additionalFields = {}) {
+      if (!fs.existsSync(TEST_PATHS.serviceQueue)) return false;
+
+      const lines = fs.readFileSync(TEST_PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
+      let updated = false;
+
+      const updatedLines = lines.map(line => {
+        try {
+          const entryData = JSON.parse(line);
+          if (entryData.requestId === requestId) {
+            updated = true;
+            return JSON.stringify({
+              ...entryData,
+              status: newStatus,
+              ...additionalFields,
+              updatedAt: Date.now()
+            });
+          }
+          return line;
+        } catch {
+          return line;
+        }
+      });
+
+      if (updated) {
+        fs.writeFileSync(TEST_PATHS.serviceQueue, updatedLines.join('\n') + '\n');
+      }
+
+      return updated;
+    }
+
+    // Update status
+    const updated = mockUpdateServiceQueueStatus('test-request-456', 'fulfilled', {
+      fulfilledAt: Date.now(),
+      result: { message: 'success' }
+    });
+
+    assert(updated === true, 'Should return true for successful update');
+
+    // Verify update
+    const lines = fs.readFileSync(TEST_PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
+    const updatedEntry = JSON.parse(lines[0]);
+
+    assert(updatedEntry.status === 'fulfilled', 'Status should be updated to fulfilled');
+    assert(updatedEntry.requestId === 'test-request-456', 'Request ID should remain the same');
+    assert(updatedEntry.fulfilledAt !== undefined, 'Should have fulfilledAt timestamp');
+    assert(updatedEntry.updatedAt !== undefined, 'Should have updatedAt timestamp');
+    assert(updatedEntry.result?.message === 'success', 'Should have result data');
+
+    cleanupTestEnv();
+  });
+
+  await test('updateServiceQueueStatus returns false for non-existent request', async () => {
+    setupTestEnv();
+
+    // Mock updateServiceQueueStatus with test paths
+    function mockUpdateServiceQueueStatus(requestId: string, _newStatus: string) {
+      if (!fs.existsSync(TEST_PATHS.serviceQueue)) return false;
+
+      const lines = fs.readFileSync(TEST_PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
+      let updated = false;
+
+      lines.map(line => {
+        try {
+          const entry = JSON.parse(line);
+          if (entry.requestId === requestId) {
+            updated = true;
+          }
+          return line;
+        } catch {
+          return line;
+        }
+      });
+
+      return updated;
+    }
+
+    const updated = mockUpdateServiceQueueStatus('non-existent-request', 'fulfilled');
+    assert(updated === false, 'Should return false for non-existent request');
+
+    cleanupTestEnv();
+  });
+
+  // ── Summary ──────────────────────────────────────────────────────────
+  console.log(`\n${passed} passed, ${failed} failed\n`);
+
+  if (failed > 0) {
+    process.exit(1);
+  }
+}
+
+// Run tests if this file is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  run().catch(console.error);
+}
+
+export { run };

package/src/test/service-system.test.ts

@@ -0,0 +1,241 @@
+/**
+ * Service system comprehensive tests.
+ * Tests service registration, loading, validation, and execution.
+ */
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { serviceRegistry, serviceLoader, serviceManager, initializeServiceSystem } from '../services/index.js';
+import { ServiceDefinition, ServiceCategory } from '../services/types.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(__dirname, '..', '..');
+
+// Test helper functions
+function assert(condition: boolean, message: string) {
+  if (!condition) {
+    throw new Error(`Assertion failed: ${message}`);
+  }
+}
+
+function assertEquals(actual: any, expected: any, message?: string) {
+  if (actual !== expected) {
+    throw new Error(`Assertion failed: ${message || ''} - Expected ${expected}, got ${actual}`);
+  }
+}
+
+console.log('\n=== Service System Tests ===\n');
+
+// Test 1: Service Registry Basic Operations
+console.log('Testing service registry basic operations...');
+
+// Create test service
+const testService: ServiceDefinition = {
+  id: 'test-service',
+  name: 'Test Service',
+  description: 'A test service for unit testing',
+  defaultPrice: 10,
+  category: ServiceCategory.UTILITY,
+  inputSchema: {
+    type: 'object',
+    properties: {
+      message: { type: 'string', description: 'Test message' }
+    },
+    required: ['message']
+  }
+};
+
+// Clear registry for clean test
+serviceRegistry.clear();
+
+// Test registration
+serviceRegistry.register(testService);
+assert(serviceRegistry.get('test-service') !== undefined, 'Service should be registered');
+assertEquals(serviceRegistry.get('test-service')?.name, 'Test Service', 'Service name should match');
+
+// Test listing
+const services = serviceRegistry.list();
+assert(services.length === 1, 'Should have one registered service');
+assertEquals(services[0].id, 'test-service', 'Listed service should match registered service');
+
+console.log('✅ Registry: basic operations work correctly');
+
+// Test 2: Service Registry Validation
+console.log('Testing service registry validation...');
+
+// Test duplicate registration
+try {
+  serviceRegistry.register(testService);
+  throw new Error('Should have thrown error for duplicate registration');
+} catch (error: any) {
+  assert(error.message.includes('already registered'), 'Should reject duplicate registration');
+}
+
+// Test invalid service (missing required fields)
+try {
+  serviceRegistry.register({
+    id: '',
+    name: 'Invalid',
+    description: 'Missing ID',
+    defaultPrice: 10
+  } as ServiceDefinition);
+  throw new Error('Should have thrown error for invalid service');
+} catch (error: any) {
+  assert(error.message.includes('Service ID is required'), 'Should reject service without ID');
+}
+
+console.log('✅ Registry: validation works correctly');
+
+// Test 3: Service Loader Directory Scanning
+console.log('Testing service loader directory scanning...');
+
+// Clear registry for clean test
+serviceRegistry.clear();
+
+// Load built-in services
+const builtInServices = await serviceLoader.loadBuiltInServices();
+assert(builtInServices.length > 0, 'Should load built-in services');
+
+// Check that specific services are loaded
+const expectedServices = ['tell-joke', 'api-proxy', 'summarize', 'memory-store', 'roulette', 'code-develop', 'image-analysis'];
+for (const serviceId of expectedServices) {
+  const service = builtInServices.find(s => s.id === serviceId);
+  assert(service !== undefined, `Should load ${serviceId} service`);
+  assert(service!.name.length > 0, `${serviceId} should have a name`);
+  assert(service!.description.length > 0, `${serviceId} should have a description`);
+  assert(service!.defaultPrice > 0, `${serviceId} should have a valid price`);
+}
+
+console.log('✅ Loader: directory scanning works correctly');
+
+// Test 4: Service Manager Integration
+console.log('Testing service manager integration...');
+
+// Initialize service system
+await initializeServiceSystem();
+
+// Test service discovery
+const joke = serviceManager.registry.get('tell-joke');
+assert(joke !== undefined, 'Should find tell-joke service');
+assertEquals(joke!.name, 'Random Joke', 'Service name should match');
+
+// Test validation with valid input
+const validationResult = serviceManager.validate('tell-joke', { topic: 'programming' });
+assert(validationResult.valid, 'Valid input should pass validation');
+
+// Tell-joke service has no required fields, so empty object is valid
+const emptyInputResult = serviceManager.validate('tell-joke', {});
+assert(emptyInputResult.valid, 'Empty input should be valid for tell-joke service');
+
+// Test with truly invalid input (wrong type)
+const invalidResult = serviceManager.validate('tell-joke', { topic: 123 });
+assert(!invalidResult.valid, 'Invalid input type should fail validation');
+
+console.log('✅ Manager: integration works correctly');
+
+// Test 5: Service Input Schema Validation
+console.log('Testing service input schema validation...');
+
+// Test api-proxy service validation
+const apiProxy = serviceManager.registry.get('api-proxy');
+assert(apiProxy !== undefined, 'Should find api-proxy service');
+
+const validApiInput = { url: 'https://api.example.com/test', method: 'GET' };
+const validApiResult = serviceManager.validate('api-proxy', validApiInput);
+assert(validApiResult.valid, 'Valid api-proxy input should pass');
+
+const invalidApiInput = { method: 'GET' }; // missing required url
+const invalidApiResult = serviceManager.validate('api-proxy', invalidApiInput);
+assert(!invalidApiResult.valid, 'Invalid api-proxy input should fail');
+
+console.log('✅ Validation: input schema validation works correctly');
+
+// Test 6: Service Categories
+console.log('Testing service categories...');
+
+// Check that services have appropriate categories
+const categorizedServices = serviceManager.registry.list();
+const categories = new Set(categorizedServices.map(s => s.category).filter(Boolean));
+assert(categories.size > 0, 'Should have services with categories');
+
+// Verify known categories
+const expectedCategories = ['utility', 'ai', 'entertainment', 'development'];
+for (const category of expectedCategories) {
+  const servicesInCategory = categorizedServices.filter(s => s.category === category);
+  assert(servicesInCategory.length > 0, `Should have services in ${category} category`);
+}
+
+console.log('✅ Categories: service categorization works correctly');
+
+// Test 7: Service Loading Error Handling
+console.log('Testing service loading error handling...');
+
+// Test loading from non-existent directory
+try {
+  await serviceLoader.loadFromDirectory('/non/existent/directory');
+  // Should not throw, but return empty array
+  console.log('✅ Loader: graceful handling of non-existent directory');
+} catch {
+  // This is also acceptable behavior
+  console.log('✅ Loader: appropriate error handling for non-existent directory');
+}
+
+// Test 8: Service Prompt Files
+console.log('Testing service prompt files...');
+
+// Check that services with prompt files can be found
+const servicesWithPrompts = categorizedServices.filter(s => s.promptFile);
+assert(servicesWithPrompts.length > 0, 'Should have services with prompt files');
+
+// Verify prompt files exist
+for (const service of servicesWithPrompts.slice(0, 3)) { // Test first 3 to avoid excessive file I/O
+  if (service.promptFile) {
+    const promptPath = path.resolve(projectRoot, service.promptFile);
+    assert(fs.existsSync(promptPath), `Prompt file should exist: ${service.promptFile}`);
+
+    const content = fs.readFileSync(promptPath, 'utf-8');
+    assert(content.includes(service.id), `Prompt should reference service ID: ${service.id}`);
+  }
+}
+
+console.log('✅ Prompts: service prompt files work correctly');
+
+// Test 9: Service Registry Search and Filter
+console.log('Testing service registry search and filter...');
+
+// Test filtering by category
+const aiServices = categorizedServices.filter(s => s.category === ServiceCategory.AI);
+assert(aiServices.length > 0, 'Should have AI services');
+
+const utilityServices = categorizedServices.filter(s => s.category === ServiceCategory.UTILITY);
+assert(utilityServices.length > 0, 'Should have utility services');
+
+// Test name search
+const jokeServices = categorizedServices.filter(s => s.name.toLowerCase().includes('joke'));
+assert(jokeServices.length > 0, 'Should find joke-related services');
+
+console.log('✅ Search: service filtering works correctly');
+
+// Test 10: Service System State Consistency
+console.log('Testing service system state consistency...');
+
+// Verify that registry and manager are in sync
+const registryServices = serviceManager.registry.list();
+const registryIds = new Set(registryServices.map(s => s.id));
+
+// All services should be unique
+assertEquals(registryIds.size, registryServices.length, 'All service IDs should be unique');
+
+// All services should have valid pricing
+for (const service of registryServices) {
+  assert(service.defaultPrice > 0, `Service ${service.id} should have valid price`);
+  assert(service.name.length > 0, `Service ${service.id} should have a name`);
+  assert(service.description.length > 0, `Service ${service.id} should have a description`);
+}
+
+console.log('✅ Consistency: service system state is consistent');
+
+console.log('\n========================================');
+console.log('Service System Tests completed: All tests passed!');
+console.log('========================================\n');