@elizaos/cli 1.0.8 → 1.0.10

package/templates/project-starter/src/__tests__/plugin.test.ts

@@ -0,0 +1,393 @@
+import { describe, expect, it, spyOn, beforeEach, afterEach, beforeAll, afterAll } from 'bun:test';
+import plugin from '../plugin';
+import { ModelType, logger } from '@elizaos/core';
+import { StarterService } from '../plugin';
+import dotenv from 'dotenv';
+
+// Setup environment variables
+dotenv.config();
+
+// Need to spy on logger for documentation
+beforeAll(() => {
+  spyOn(logger, 'info');
+  spyOn(logger, 'error');
+  spyOn(logger, 'warn');
+  spyOn(logger, 'debug');
+});
+
+afterAll(() => {
+  // No global restore needed in bun:test;
+});
+
+// Helper function to document test results
+function documentTestResult(testName: string, result: any, error: Error | null = null) {
+  // Clean, useful test documentation for developers
+  logger.info(`✓ Testing: ${testName}`);
+
+  if (error) {
+    logger.error(`✗ Error: ${error.message}`);
+    if (error.stack) {
+      logger.error(`Stack: ${error.stack}`);
+    }
+    return;
+  }
+
+  if (result) {
+    if (typeof result === 'string') {
+      if (result.trim() && result.length > 0) {
+        const preview = result.length > 60 ? `${result.substring(0, 60)}...` : result;
+        logger.info(`  → ${preview}`);
+      }
+    } else if (typeof result === 'object') {
+      try {
+        // Show key information in a clean format
+        const keys = Object.keys(result);
+        if (keys.length > 0) {
+          const preview = keys.slice(0, 3).join(', ');
+          const more = keys.length > 3 ? ` +${keys.length - 3} more` : '';
+          logger.info(`  → {${preview}${more}}`);
+        }
+      } catch (e) {
+        logger.info(`  → [Complex object]`);
+      }
+    }
+  }
+}
+
+// Create a real runtime for testing
+function createRealRuntime() {
+  const services = new Map();
+
+  // Create a real service instance if needed
+  const createService = (serviceType: string) => {
+    if (serviceType === StarterService.serviceType) {
+      return new StarterService({
+        character: {
+          name: 'Test Character',
+          system: 'You are a helpful assistant for testing.',
+        },
+      } as any);
+    }
+    return null;
+  };
+
+  return {
+    character: {
+      name: 'Test Character',
+      system: 'You are a helpful assistant for testing.',
+      plugins: [],
+      settings: {},
+    },
+    getSetting: (key: string) => null,
+    models: plugin.models,
+    db: {
+      get: async (key: string) => null,
+      set: async (key: string, value: any) => true,
+      delete: async (key: string) => true,
+      getKeys: async (pattern: string) => [],
+    },
+    getService: (serviceType: string) => {
+      // Get from cache or create new
+      if (!services.has(serviceType)) {
+        services.set(serviceType, createService(serviceType));
+      }
+
+      return services.get(serviceType);
+    },
+    registerService: (serviceType: string, service: any) => {
+      services.set(serviceType, service);
+    },
+  };
+}
+
+describe('Plugin Configuration', () => {
+  it('should have correct plugin metadata', () => {
+    expect(plugin.name).toBe('starter');
+    expect(plugin.description).toBe('A starter plugin for Eliza');
+    expect(plugin.config).toBeDefined();
+
+    documentTestResult('Plugin metadata check', {
+      name: plugin.name,
+      description: plugin.description,
+      hasConfig: !!plugin.config,
+    });
+  });
+
+  it('should include the EXAMPLE_PLUGIN_VARIABLE in config', () => {
+    expect(plugin.config).toHaveProperty('EXAMPLE_PLUGIN_VARIABLE');
+
+    documentTestResult('Plugin config check', {
+      hasExampleVariable: plugin.config ? 'EXAMPLE_PLUGIN_VARIABLE' in plugin.config : false,
+      configKeys: Object.keys(plugin.config || {}),
+    });
+  });
+
+  it('should initialize properly', async () => {
+    const originalEnv = process.env.EXAMPLE_PLUGIN_VARIABLE;
+
+    try {
+      process.env.EXAMPLE_PLUGIN_VARIABLE = 'test-value';
+
+      // Initialize with config - using real runtime
+      const runtime = createRealRuntime();
+
+      let error: Error | null = null;
+      try {
+        await plugin.init?.({ EXAMPLE_PLUGIN_VARIABLE: 'test-value' }, runtime as any);
+        expect(true).toBe(true); // If we got here, init succeeded
+      } catch (e) {
+        error = e as Error;
+        logger.error('Plugin initialization error:', e);
+      }
+
+      documentTestResult(
+        'Plugin initialization',
+        {
+          success: !error,
+          configValue: process.env.EXAMPLE_PLUGIN_VARIABLE,
+        },
+        error
+      );
+    } finally {
+      process.env.EXAMPLE_PLUGIN_VARIABLE = originalEnv;
+    }
+  });
+
+  it('should throw an error on invalid config', async () => {
+    // Test with empty string (less than min length 1)
+    if (plugin.init) {
+      const runtime = createRealRuntime();
+      let error: Error | null = null;
+
+      try {
+        await plugin.init({ EXAMPLE_PLUGIN_VARIABLE: '' }, runtime as any);
+        // Should not reach here
+        expect(true).toBe(false);
+      } catch (e) {
+        error = e as Error;
+        // This is expected - test passes
+        expect(error).toBeTruthy();
+      }
+
+      documentTestResult(
+        'Plugin invalid config',
+        {
+          errorThrown: !!error,
+          errorMessage: error?.message || 'No error message',
+        },
+        error
+      );
+    }
+  });
+
+  it('should have a valid config', () => {
+    expect(plugin.config).toBeDefined();
+    if (plugin.config) {
+      // Check if the config has expected EXAMPLE_PLUGIN_VARIABLE property
+      expect(Object.keys(plugin.config)).toContain('EXAMPLE_PLUGIN_VARIABLE');
+    }
+  });
+});
+
+describe('Plugin Models', () => {
+  it('should have TEXT_SMALL model defined', () => {
+    if (plugin.models) {
+      expect(plugin.models).toHaveProperty(ModelType.TEXT_SMALL);
+      expect(typeof plugin.models[ModelType.TEXT_SMALL]).toBe('function');
+
+      documentTestResult('TEXT_SMALL model check', {
+        defined: ModelType.TEXT_SMALL in plugin.models,
+        isFunction: typeof plugin.models[ModelType.TEXT_SMALL] === 'function',
+      });
+    }
+  });
+
+  it('should have TEXT_LARGE model defined', () => {
+    if (plugin.models) {
+      expect(plugin.models).toHaveProperty(ModelType.TEXT_LARGE);
+      expect(typeof plugin.models[ModelType.TEXT_LARGE]).toBe('function');
+
+      documentTestResult('TEXT_LARGE model check', {
+        defined: ModelType.TEXT_LARGE in plugin.models,
+        isFunction: typeof plugin.models[ModelType.TEXT_LARGE] === 'function',
+      });
+    }
+  });
+
+  it('should return a response from TEXT_SMALL model', async () => {
+    if (plugin.models && plugin.models[ModelType.TEXT_SMALL]) {
+      const runtime = createRealRuntime();
+
+      let result = '';
+      let error: Error | null = null;
+
+      try {
+        logger.info('Using OpenAI for TEXT_SMALL model');
+        result = await plugin.models[ModelType.TEXT_SMALL](runtime as any, { prompt: 'test' });
+
+        // Check that we get a non-empty string response
+        expect(result).toBeTruthy();
+        expect(typeof result).toBe('string');
+        expect(result.length).toBeGreaterThan(10);
+      } catch (e) {
+        error = e as Error;
+        logger.error('TEXT_SMALL model test failed:', e);
+      }
+
+      documentTestResult('TEXT_SMALL model plugin test', result, error);
+    }
+  });
+});
+
+describe('StarterService', () => {
+  it('should start the service', async () => {
+    const runtime = createRealRuntime();
+    let startResult;
+    let error: Error | null = null;
+
+    try {
+      logger.info('Using OpenAI for TEXT_SMALL model');
+      startResult = await StarterService.start(runtime as any);
+
+      expect(startResult).toBeDefined();
+      expect(startResult.constructor.name).toBe('StarterService');
+
+      // Test real functionality - check stop method is available
+      expect(typeof startResult.stop).toBe('function');
+    } catch (e) {
+      error = e as Error;
+      logger.error('Service start error:', e);
+    }
+
+    documentTestResult(
+      'StarterService start',
+      {
+        success: !!startResult,
+        serviceType: startResult?.constructor.name,
+      },
+      error
+    );
+  });
+
+  it('should throw an error on startup if the service is already registered', async () => {
+    const runtime = createRealRuntime();
+
+    // First registration should succeed
+    const result1 = await StarterService.start(runtime as any);
+    expect(result1).toBeTruthy();
+
+    let startupError: Error | null = null;
+
+    try {
+      // Second registration should fail
+      await StarterService.start(runtime as any);
+      expect(true).toBe(false); // Should not reach here
+    } catch (e) {
+      startupError = e as Error;
+      expect(e).toBeTruthy();
+    }
+
+    documentTestResult(
+      'StarterService double start',
+      {
+        errorThrown: !!startupError,
+        errorMessage: startupError?.message || 'No error message',
+      },
+      startupError
+    );
+  });
+
+  it('should stop the service', async () => {
+    const runtime = createRealRuntime();
+    let error: Error | null = null;
+
+    try {
+      // Register a real service first
+      const service = new StarterService(runtime as any);
+      runtime.registerService(StarterService.serviceType, service);
+
+      // Spy on the real service's stop method
+      const stopSpy = spyOn(service, 'stop');
+
+      // Call the static stop method
+      await StarterService.stop(runtime as any);
+
+      // Verify the service's stop method was called
+      expect(stopSpy).toHaveBeenCalled();
+    } catch (e) {
+      error = e as Error;
+      logger.error('Service stop error:', e);
+    }
+
+    documentTestResult(
+      'StarterService stop',
+      {
+        success: !error,
+      },
+      error
+    );
+  });
+
+  it('should throw an error when stopping a non-existent service', async () => {
+    const runtime = createRealRuntime();
+    // Don't register a service, so getService will return null
+
+    let error: Error | null = null;
+
+    try {
+      // We'll patch the getService function to ensure it returns null
+      const originalGetService = runtime.getService;
+      runtime.getService = () => null;
+
+      await StarterService.stop(runtime as any);
+      // Should not reach here
+      expect(true).toBe(false);
+    } catch (e) {
+      error = e as Error;
+      // This is expected - verify it's the right error
+      expect(error).toBeTruthy();
+      if (error instanceof Error) {
+        expect(error.message).toContain('Starter service not found');
+      }
+    }
+
+    documentTestResult(
+      'StarterService non-existent stop',
+      {
+        errorThrown: !!error,
+        errorMessage: error?.message || 'No error message',
+      },
+      error
+    );
+  });
+
+  it('should stop a registered service', async () => {
+    const runtime = createRealRuntime();
+
+    // First start the service
+    const startResult = await StarterService.start(runtime as any);
+    expect(startResult).toBeTruthy();
+
+    let stopError: Error | unknown = null;
+    let stopSuccess = false;
+
+    try {
+      // Then stop it
+      await StarterService.stop(runtime as any);
+      stopSuccess = true;
+    } catch (e) {
+      stopError = e;
+      expect(true).toBe(false); // Should not reach here
+    }
+
+    documentTestResult(
+      'StarterService stop',
+      {
+        success: stopSuccess,
+        errorThrown: !!stopError,
+        errorMessage: stopError instanceof Error ? stopError.message : String(stopError),
+      },
+      stopError instanceof Error ? stopError : null
+    );
+  });
+});

package/templates/project-starter/src/__tests__/provider.test.ts

@@ -0,0 +1,325 @@
+import { describe, expect, it, spyOn, beforeAll, afterAll } from 'bun:test';
+import plugin from '../plugin';
+import type { IAgentRuntime, Memory, State, Provider } from '@elizaos/core';
+import { logger } from '@elizaos/core';
+import { v4 as uuidv4 } from 'uuid';
+import dotenv from 'dotenv';
+
+// Setup environment variables
+dotenv.config();
+
+// Set up logging to capture issues
+beforeAll(() => {
+  spyOn(logger, 'info');
+  spyOn(logger, 'error');
+  spyOn(logger, 'warn');
+  spyOn(logger, 'debug');
+});
+
+afterAll(() => {
+  // No global restore needed in bun:test;
+});
+
+// Helper function to document test results
+function documentTestResult(testName: string, result: any, error: Error | null = null) {
+  // Clean, useful test documentation for developers
+  logger.info(`✓ Testing: ${testName}`);
+
+  if (error) {
+    logger.error(`✗ Error: ${error.message}`);
+    if (error.stack) {
+      logger.error(`Stack: ${error.stack}`);
+    }
+    return;
+  }
+
+  if (result) {
+    if (typeof result === 'string') {
+      if (result.trim() && result.length > 0) {
+        const preview = result.length > 60 ? `${result.substring(0, 60)}...` : result;
+        logger.info(`  → ${preview}`);
+      }
+    } else if (typeof result === 'object') {
+      try {
+        // Show key information in a clean format
+        const keys = Object.keys(result);
+        if (keys.length > 0) {
+          const preview = keys.slice(0, 3).join(', ');
+          const more = keys.length > 3 ? ` +${keys.length - 3} more` : '';
+          logger.info(`  → {${preview}${more}}`);
+        }
+      } catch (e) {
+        logger.info(`  → [Complex object]`);
+      }
+    }
+  }
+}
+
+// Create a realistic runtime for testing
+function createRealRuntime(): IAgentRuntime {
+  return {
+    character: {
+      name: 'Test Character',
+      system: 'You are a helpful assistant for testing.',
+      plugins: [],
+      settings: {},
+    },
+    getSetting: (key: string) => null,
+    models: plugin.models,
+    db: {
+      get: async (key: string) => {
+        return null;
+      },
+      set: async (key: string, value: any) => {
+        return true;
+      },
+      delete: async (key: string) => {
+        return true;
+      },
+      getKeys: async (pattern: string) => {
+        return [];
+      },
+    },
+    memory: {
+      add: async (memory: any) => {
+        // Memory operations for testing
+      },
+      get: async (id: string) => {
+        return null;
+      },
+      getByEntityId: async (entityId: string) => {
+        return [];
+      },
+      getLatest: async (entityId: string) => {
+        return null;
+      },
+      getRecentMessages: async (options: any) => {
+        return [];
+      },
+      search: async (query: string) => {
+        return [];
+      },
+    },
+    getService: (serviceType: string) => {
+      return null;
+    },
+  } as unknown as IAgentRuntime;
+}
+
+// Create realistic memory object
+function createRealMemory(): Memory {
+  const entityId = uuidv4();
+  const roomId = uuidv4();
+
+  return {
+    id: uuidv4(),
+    entityId,
+    roomId,
+    timestamp: Date.now(),
+    content: {
+      text: 'What can you provide?',
+      source: 'test',
+      actions: [],
+    },
+    metadata: {
+      type: 'custom',
+      sessionId: uuidv4(),
+      conversationId: uuidv4(),
+    },
+  } as Memory;
+}
+
+describe('Provider Tests', () => {
+  // Find the HELLO_WORLD_PROVIDER from the providers array
+  const helloWorldProvider = plugin.providers?.find(
+    (provider) => provider.name === 'HELLO_WORLD_PROVIDER'
+  );
+
+  describe('HELLO_WORLD_PROVIDER', () => {
+    it('should exist in the plugin', () => {
+      expect(plugin.providers).toBeDefined();
+      expect(Array.isArray(plugin.providers)).toBe(true);
+
+      if (plugin.providers) {
+        expect(plugin.providers.length).toBeGreaterThan(0);
+        const result = plugin.providers.find((p) => p.name === 'HELLO_WORLD_PROVIDER');
+        expect(result).toBeDefined();
+        documentTestResult('Provider exists check', {
+          found: !!result,
+          providers: plugin.providers.map((p) => p.name),
+        });
+      }
+    });
+
+    it('should have the correct structure', () => {
+      if (helloWorldProvider) {
+        expect(helloWorldProvider).toHaveProperty('name', 'HELLO_WORLD_PROVIDER');
+        expect(helloWorldProvider).toHaveProperty('description');
+        expect(helloWorldProvider).toHaveProperty('get');
+        expect(typeof helloWorldProvider.get).toBe('function');
+
+        documentTestResult('Provider structure check', {
+          name: helloWorldProvider.name,
+          description: helloWorldProvider.description,
+          hasGetMethod: typeof helloWorldProvider.get === 'function',
+        });
+      }
+    });
+
+    it('should have a description explaining its purpose', () => {
+      if (helloWorldProvider && helloWorldProvider.description) {
+        expect(typeof helloWorldProvider.description).toBe('string');
+        expect(helloWorldProvider.description.length).toBeGreaterThan(0);
+
+        documentTestResult('Provider description check', {
+          description: helloWorldProvider.description,
+        });
+      }
+    });
+
+    it('should return provider data from the get method', async () => {
+      if (helloWorldProvider) {
+        const runtime = createRealRuntime();
+        const message = createRealMemory();
+        const state = {
+          values: { example: 'test value' },
+          data: { additionalContext: 'some context' },
+          text: 'Current state context',
+        } as State;
+
+        let result: any = null;
+        let error: Error | null = null;
+
+        try {
+          logger.info('Calling provider.get with real implementation');
+          result = await helloWorldProvider.get(runtime, message, state);
+
+          expect(result).toBeDefined();
+          expect(result).toHaveProperty('text');
+          expect(result).toHaveProperty('values');
+          expect(result).toHaveProperty('data');
+
+          // Look for potential issues in the result
+          if (result && (!result.text || result.text.length === 0)) {
+            logger.warn('Provider returned empty text');
+          }
+
+          if (result && Object.keys(result.values).length === 0) {
+            logger.warn('Provider returned empty values object');
+          }
+
+          if (result && Object.keys(result.data).length === 0) {
+            logger.warn('Provider returned empty data object');
+          }
+        } catch (e) {
+          error = e as Error;
+          logger.error('Error in provider.get:', e);
+        }
+
+        documentTestResult('Provider get method', result, error);
+      }
+    });
+
+    it('should handle error conditions gracefully', async () => {
+      if (helloWorldProvider) {
+        const runtime = createRealRuntime();
+        // Create an invalid memory object to simulate an error scenario
+        const invalidMemory = {
+          // Missing properties that would be required
+          id: uuidv4(),
+        } as unknown as Memory;
+
+        const state = {
+          values: {},
+          data: {},
+          text: '',
+        } as State;
+
+        let result: any = null;
+        let error: Error | null = null;
+
+        try {
+          logger.info('Calling provider.get with invalid memory object');
+          result = await helloWorldProvider.get(runtime, invalidMemory, state);
+
+          // Even with invalid input, it should not throw errors
+          expect(result).toBeDefined();
+
+          // Log what actual implementation does with invalid input
+          logger.info('Provider handled invalid input without throwing');
+        } catch (e) {
+          error = e as Error;
+          logger.error('Provider threw an error with invalid input:', e);
+        }
+
+        documentTestResult('Provider error handling', result, error);
+      }
+    });
+  });
+
+  describe('Provider Registration', () => {
+    it('should include providers in the plugin definition', () => {
+      expect(plugin).toHaveProperty('providers');
+      expect(Array.isArray(plugin.providers)).toBe(true);
+
+      documentTestResult('Plugin providers check', {
+        hasProviders: !!plugin.providers,
+        providersCount: plugin.providers?.length || 0,
+      });
+    });
+
+    it('should correctly initialize providers array', () => {
+      // Providers should be an array with at least one provider
+      if (plugin.providers) {
+        expect(plugin.providers.length).toBeGreaterThan(0);
+
+        let allValid = true;
+        const invalidProviders: string[] = [];
+
+        // Each provider should have the required structure
+        plugin.providers.forEach((provider: Provider) => {
+          const isValid =
+            provider.name !== undefined &&
+            provider.description !== undefined &&
+            typeof provider.get === 'function';
+
+          if (!isValid) {
+            allValid = false;
+            invalidProviders.push(provider.name || 'unnamed');
+          }
+
+          expect(provider).toHaveProperty('name');
+          expect(provider).toHaveProperty('description');
+          expect(provider).toHaveProperty('get');
+          expect(typeof provider.get).toBe('function');
+        });
+
+        documentTestResult('Provider initialization check', {
+          providersCount: plugin.providers.length,
+          allValid,
+          invalidProviders,
+        });
+      }
+    });
+
+    it('should have unique provider names', () => {
+      if (plugin.providers) {
+        const providerNames = plugin.providers.map((provider) => provider.name);
+        const uniqueNames = new Set(providerNames);
+
+        const duplicates = providerNames.filter(
+          (name, index) => providerNames.indexOf(name) !== index
+        );
+
+        // There should be no duplicate provider names
+        expect(providerNames.length).toBe(uniqueNames.size);
+
+        documentTestResult('Provider uniqueness check', {
+          totalProviders: providerNames.length,
+          uniqueProviders: uniqueNames.size,
+          duplicates,
+        });
+      }
+    });
+  });
+});