@elizaos/cli 1.3.0 → 1.3.2

package/dist/templates/plugin-quick-starter/src/__tests__/plugin.test.ts

@@ -1,12 +1,28 @@
 import { describe, expect, it, spyOn, beforeEach, afterEach, beforeAll, afterAll } from 'bun:test';
 import { starterPlugin, StarterService } from '../index';
-import { ModelType, logger, type IAgentRuntime, type Service } from '@elizaos/core';
+import {
+  type IAgentRuntime,
+  type Memory,
+  type State,
+  type Content,
+  type HandlerCallback,
+  ModelType,
+  logger,
+  EventType,
+} from '@elizaos/core';
 import dotenv from 'dotenv';
+import {
+  createMockRuntime,
+  createTestMemory,
+  createTestState,
+  createUUID,
+  testFixtures,
+} from './test-utils';
 
 // Setup environment variables
 dotenv.config();
 
-// Need to spy on logger for documentation
+// Need to spy on logger
 beforeAll(() => {
   spyOn(logger, 'info');
   spyOn(logger, 'error');
@@ -18,192 +34,529 @@ afterAll(() => {
   // No global restore needed in bun:test
 });
 
-// Create a real runtime for testing
-function createRealRuntime(): Partial<IAgentRuntime> {
-  const services = new Map<string, Service>();
-
-  // Create a real service instance if needed
-  const createService = (serviceType: string): Service | null => {
-    if (serviceType === StarterService.serviceType) {
-      return new StarterService({
-        character: {
-          name: 'Test Character',
-          system: 'You are a helpful assistant for testing.',
-        },
-      } as IAgentRuntime);
-    }
-    return null;
-  };
-
-  return {
-    character: {
-      name: 'Test Character',
-      system: 'You are a helpful assistant for testing.',
-      bio: 'A test character for unit testing',
-      plugins: [],
-      settings: {},
-    },
-    getSetting: (key: string) => null,
-    db: {
-      get: async (key: string) => null,
-      set: async (key: string, value: unknown) => true,
-      delete: async (key: string) => true,
-      getKeys: async (pattern: string) => [],
-    },
-    getService: <T extends Service>(serviceType: string): T | null => {
-      // Log the service request for debugging
-      logger.debug(`Requesting service: ${serviceType}`);
-
-      // Get from cache or create new
-      if (!services.has(serviceType)) {
-        logger.debug(`Creating new service: ${serviceType}`);
-        const service = createService(serviceType);
-        if (service) {
-          services.set(serviceType, service);
-        }
-      }
-
-      return (services.get(serviceType) as T) || null;
-    },
-    registerService: async (ServiceClass: typeof Service): Promise<void> => {
-      logger.debug(`Registering service: ${ServiceClass.serviceType}`);
-      const runtime = {
-        character: {
-          name: 'Test Character',
-          system: 'You are a helpful assistant for testing.',
-          bio: 'A test character for unit testing',
-        },
-      } as IAgentRuntime;
-      const service = await ServiceClass.start(runtime);
-      services.set(ServiceClass.serviceType, service);
-    },
-  };
-}
-
 describe('Plugin Configuration', () => {
   it('should have correct plugin metadata', () => {
-    expect(starterPlugin.name).toBe('plugin-quick-starter');
-    expect(starterPlugin.description).toBe('Quick backend-only plugin template for elizaOS');
-    expect(starterPlugin.config).toBeDefined();
+    // Check that plugin has required metadata (values will change when template is used)
+    expect(starterPlugin.name).toBeDefined();
+    expect(starterPlugin.name).toMatch(/^[a-z0-9-]+$/); // Valid plugin name format
+    expect(starterPlugin.description).toBeDefined();
+    expect(starterPlugin.description.length).toBeGreaterThan(0);
+    expect(starterPlugin.actions).toBeDefined();
+    expect(starterPlugin.actions?.length).toBeGreaterThan(0);
+    expect(starterPlugin.providers).toBeDefined();
+    expect(starterPlugin.providers?.length).toBeGreaterThan(0);
+    expect(starterPlugin.services).toBeDefined();
+    expect(starterPlugin.services?.length).toBeGreaterThan(0);
+    expect(starterPlugin.models).toBeDefined();
+    expect(starterPlugin.models?.[ModelType.TEXT_SMALL]).toBeDefined();
+    expect(starterPlugin.models?.[ModelType.TEXT_LARGE]).toBeDefined();
+    expect(starterPlugin.routes).toBeDefined();
+    expect(starterPlugin.routes?.length).toBeGreaterThan(0);
+    expect(starterPlugin.events).toBeDefined();
+  });
+
+  it('should initialize with valid configuration', async () => {
+    const runtime = createMockRuntime();
+    const config = { EXAMPLE_PLUGIN_VARIABLE: 'test-value' };
+
+    if (starterPlugin.init) {
+      await starterPlugin.init(config, runtime);
+      expect(process.env.EXAMPLE_PLUGIN_VARIABLE).toBe('test-value');
+    }
+  });
+
+  it('should handle initialization without config', async () => {
+    const runtime = createMockRuntime();
+
+    if (starterPlugin.init) {
+      // Init should not throw even with empty config
+      await starterPlugin.init({}, runtime);
+    }
+  });
+
+  it('should throw error for invalid configuration', async () => {
+    const runtime = createMockRuntime();
+    const invalidConfig = { EXAMPLE_PLUGIN_VARIABLE: 123 }; // Should be string
+
+    if (starterPlugin.init) {
+      await expect(starterPlugin.init(invalidConfig as any, runtime)).rejects.toThrow(
+        'Invalid plugin configuration'
+      );
+    }
+  });
+});
+
+describe('Hello World Action', () => {
+  let runtime: IAgentRuntime;
+  let helloWorldAction: any;
+
+  beforeEach(() => {
+    runtime = createMockRuntime();
+    helloWorldAction = starterPlugin.actions?.[0];
+    // Clear all spies before each test
+    (logger.info as any).calls = [];
+    (logger.error as any).calls = [];
+    (logger.debug as any).calls = [];
+    (logger.warn as any).calls = [];
+  });
+
+  it('should have hello world action', () => {
+    expect(helloWorldAction).toBeDefined();
+    expect(helloWorldAction?.name).toBe('HELLO_WORLD');
+  });
+
+  it('should always validate messages (current implementation)', async () => {
+    if (!helloWorldAction?.validate) {
+      throw new Error('Hello world action validate not found');
+    }
+
+    const validMessages = ['say hello', 'hello world', 'Please say HELLO', 'can you say hello?'];
+
+    // The current implementation always returns true
+    // This test documents the actual behavior
+    for (const text of validMessages) {
+      const message = createTestMemory({
+        content: { text, source: 'test' },
+      });
+      const isValid = await helloWorldAction.validate(runtime, message);
+      expect(isValid).toBe(true);
+    }
+  });
+
+  it('should properly validate hello messages', async () => {
+    if (!helloWorldAction?.validate) {
+      throw new Error('Hello world action validate not found');
+    }
+
+    // The current implementation always returns true
+    // Test that it accepts all messages
+    const helloMessages = ['hello', 'hi there', 'hey!', 'greetings', 'howdy partner'];
+    for (const text of helloMessages) {
+      const message = createTestMemory({
+        content: { text, source: 'test' },
+      });
+      const isValid = await helloWorldAction.validate(runtime, message);
+      expect(isValid).toBe(true);
+    }
+
+    // Should also accept non-hello messages since validate always returns true
+    const nonHelloMessages = ['goodbye', 'what is the weather', 'tell me a joke'];
+    for (const text of nonHelloMessages) {
+      const message = createTestMemory({
+        content: { text, source: 'test' },
+      });
+      const isValid = await helloWorldAction.validate(runtime, message);
+      expect(isValid).toBe(true);
+    }
+
+    // Test empty string - also returns true
+    const emptyMessage = createTestMemory({
+      content: { text: '', source: 'test' },
+    });
+    const isEmptyValid = await helloWorldAction.validate(runtime, emptyMessage);
+    expect(isEmptyValid).toBe(true);
   });
 
-  it('should include the EXAMPLE_PLUGIN_VARIABLE in config', () => {
-    expect(starterPlugin.config).toHaveProperty('EXAMPLE_PLUGIN_VARIABLE');
+  it('should validate even without text content', async () => {
+    if (!helloWorldAction?.validate) {
+      throw new Error('Hello world action validate not found');
+    }
+
+    const messageWithoutText = createTestMemory({
+      content: { source: 'test' } as Content,
+    });
+
+    const isValid = await helloWorldAction.validate(runtime, messageWithoutText);
+    // Always returns true since validate always returns true
+    expect(isValid).toBe(true);
   });
 
-  it('should initialize properly', async () => {
-    const originalEnv = process.env.EXAMPLE_PLUGIN_VARIABLE;
+  it('should handle hello world action with callback', async () => {
+    if (!helloWorldAction?.handler) {
+      throw new Error('Hello world action handler not found');
+    }
+
+    const message = createTestMemory({
+      content: { text: 'say hello', source: 'test' },
+    });
 
-    try {
-      process.env.EXAMPLE_PLUGIN_VARIABLE = 'test-value';
+    let callbackContent: any = null;
+    const callback: HandlerCallback = async (content: Content) => {
+      callbackContent = content;
+      return [];
+    };
+
+    const result = await helloWorldAction.handler(runtime, message, undefined, undefined, callback);
 
-      // Initialize with config - using real runtime
-      const runtime = createRealRuntime();
+    expect(result).toHaveProperty('text', 'Hello world!');
+    expect(result).toHaveProperty('success', true);
+    expect(result).toHaveProperty('data');
+    expect((result as any).data).toHaveProperty('actions', ['HELLO_WORLD']);
+    expect((result as any).data).toHaveProperty('source', 'test');
 
-      if (starterPlugin.init) {
-        await starterPlugin.init(
-          { EXAMPLE_PLUGIN_VARIABLE: 'test-value' },
-          runtime as IAgentRuntime
-        );
-        expect(true).toBe(true); // If we got here, init succeeded
-      }
-    } finally {
-      process.env.EXAMPLE_PLUGIN_VARIABLE = originalEnv;
+    expect(callbackContent).toEqual({
+      text: 'Hello world!',
+      actions: ['HELLO_WORLD'],
+      source: 'test',
+    });
+  });
+
+  it('should handle errors gracefully', async () => {
+    if (!helloWorldAction?.handler) {
+      throw new Error('Hello world action handler not found');
     }
+
+    const message = createTestMemory({
+      content: { text: 'say hello', source: 'test' },
+    });
+
+    const errorCallback: HandlerCallback = async () => {
+      throw new Error('Callback error');
+    };
+
+    const result = await helloWorldAction.handler(
+      runtime,
+      message,
+      undefined,
+      undefined,
+      errorCallback
+    );
+
+    expect(result).toHaveProperty('success', false);
+    expect(result).toHaveProperty('error');
+    expect((result as any).error?.message).toBe('Callback error');
+    // Quick-starter plugin doesn't log errors
   });
 
-  it('should have a valid config', () => {
-    expect(starterPlugin.config).toBeDefined();
-    if (starterPlugin.config) {
-      // Check if the config has expected EXAMPLE_PLUGIN_VARIABLE property
-      expect(Object.keys(starterPlugin.config)).toContain('EXAMPLE_PLUGIN_VARIABLE');
+  it('should handle missing callback gracefully', async () => {
+    if (!helloWorldAction?.handler) {
+      throw new Error('Hello world action handler not found');
     }
+
+    const message = createTestMemory({
+      content: { text: 'say hello', source: 'test' },
+    });
+
+    const result = await helloWorldAction.handler(
+      runtime,
+      message,
+      undefined,
+      undefined,
+      undefined
+    );
+
+    expect(result).toHaveProperty('text', 'Hello world!');
+    expect(result).toHaveProperty('success', true);
+  });
+
+  it('should handle state parameter correctly', async () => {
+    if (!helloWorldAction?.handler) {
+      throw new Error('Hello world action handler not found');
+    }
+
+    const message = createTestMemory({
+      content: { text: 'say hello', source: 'test' },
+    });
+
+    const state = createTestState({
+      values: { customValue: 'test-state' },
+    });
+
+    const result = await helloWorldAction.handler(runtime, message, state, undefined, undefined);
+
+    expect(result).toHaveProperty('success', true);
   });
 });
 
-describe('Plugin Models', () => {
-  it('should have TEXT_SMALL model defined', () => {
-    expect(starterPlugin.models?.[ModelType.TEXT_SMALL]).toBeDefined();
-    if (starterPlugin.models) {
-      expect(typeof starterPlugin.models[ModelType.TEXT_SMALL]).toBe('function');
+describe('Hello World Provider', () => {
+  const provider = starterPlugin.providers?.[0];
+  let runtime: IAgentRuntime;
+
+  beforeEach(() => {
+    runtime = createMockRuntime();
+  });
+
+  it('should have hello world provider', () => {
+    expect(provider).toBeDefined();
+    expect(provider?.name).toBe('HELLO_WORLD_PROVIDER');
+  });
+
+  it('should provide hello world data', async () => {
+    if (!provider?.get) {
+      throw new Error('Hello world provider not found');
     }
+
+    const message = createTestMemory();
+    const state = createTestState();
+
+    const result = await provider.get(runtime, message, state);
+
+    expect(result).toHaveProperty('text', 'I am a provider');
+    expect(result).toHaveProperty('values');
+    expect(result.values).toEqual({});
+    expect(result).toHaveProperty('data');
+    expect(result.data).toEqual({});
   });
 
-  it('should have TEXT_LARGE model defined', () => {
-    expect(starterPlugin.models?.[ModelType.TEXT_LARGE]).toBeDefined();
-    if (starterPlugin.models) {
-      expect(typeof starterPlugin.models[ModelType.TEXT_LARGE]).toBe('function');
+  it('should provide consistent structure across calls', async () => {
+    if (!provider?.get) {
+      throw new Error('Hello world provider not found');
+    }
+
+    const message = createTestMemory();
+    const state = createTestState();
+
+    const result1 = await provider.get(runtime, message, state);
+    const result2 = await provider.get(runtime, message, state);
+
+    // Text and structure should be consistent
+    expect(result1.text).toBe(result2.text);
+    expect(result1.values).toEqual(result2.values);
+    expect(result1.data).toEqual(result2.data);
+  });
+});
+
+describe('Model Handlers', () => {
+  let runtime: IAgentRuntime;
+
+  beforeEach(() => {
+    runtime = createMockRuntime();
+  });
+
+  it('should handle TEXT_SMALL model', async () => {
+    const handler = starterPlugin.models?.[ModelType.TEXT_SMALL];
+    if (!handler) {
+      throw new Error('TEXT_SMALL model handler not found');
     }
+
+    const result = await handler(runtime, { prompt: 'Test prompt' });
+
+    expect(result).toContain('Never gonna give you up');
   });
 
-  it('should return a response from TEXT_SMALL model', async () => {
-    if (starterPlugin.models?.[ModelType.TEXT_SMALL]) {
-      const runtime = createRealRuntime();
-      const result = await starterPlugin.models[ModelType.TEXT_SMALL](runtime as IAgentRuntime, {
-        prompt: 'test',
-      });
+  it('should handle TEXT_LARGE model with custom parameters', async () => {
+    const handler = starterPlugin.models?.[ModelType.TEXT_LARGE];
+    if (!handler) {
+      throw new Error('TEXT_LARGE model handler not found');
+    }
 
-      // Check that we get a non-empty string response
-      expect(result).toBeTruthy();
-      expect(typeof result).toBe('string');
-      expect(result.length).toBeGreaterThan(10);
+    const result = await handler(runtime, {
+      prompt: 'Test prompt with custom settings',
+      maxTokens: 1000,
+      temperature: 0.5,
+      frequencyPenalty: 0.5,
+      presencePenalty: 0.5,
+    });
+
+    expect(result).toContain('Never gonna make you cry');
+  });
+
+  it('should handle empty prompt', async () => {
+    const handler = starterPlugin.models?.[ModelType.TEXT_SMALL];
+    if (!handler) {
+      throw new Error('TEXT_SMALL model handler not found');
     }
+
+    const result = await handler(runtime, { prompt: '' });
+
+    expect(typeof result).toBe('string');
+    expect(result.length).toBeGreaterThan(0);
+  });
+
+  it('should handle missing parameters', async () => {
+    const handler = starterPlugin.models?.[ModelType.TEXT_LARGE];
+    if (!handler) {
+      throw new Error('TEXT_LARGE model handler not found');
+    }
+
+    const result = await handler(runtime, { prompt: 'Test prompt' });
+
+    expect(typeof result).toBe('string');
+    expect(result.length).toBeGreaterThan(0);
   });
 });
 
-describe('StarterService', () => {
-  it('should start the service', async () => {
-    const runtime = createRealRuntime();
-    const startResult = await StarterService.start(runtime as IAgentRuntime);
+describe('API Routes', () => {
+  let runtime: IAgentRuntime;
+
+  beforeEach(() => {
+    runtime = createMockRuntime();
+  });
+
+  it('should handle status route', async () => {
+    const statusRoute = starterPlugin.routes?.[0];
+    if (!statusRoute?.handler) {
+      throw new Error('Status route handler not found');
+    }
+
+    const mockRes = {
+      json: (data: any) => {
+        mockRes._jsonData = data;
+      },
+      _jsonData: null as any,
+    };
+
+    await statusRoute.handler({}, mockRes, runtime);
+
+    expect(mockRes._jsonData).toBeDefined();
+    expect(mockRes._jsonData.status).toBe('ok');
+    expect(mockRes._jsonData.plugin).toBe('quick-starter');
+    expect(mockRes._jsonData.timestamp).toBeDefined();
+  });
+
+  it('should validate route configuration', () => {
+    const statusRoute = starterPlugin.routes?.[0];
+
+    expect(statusRoute).toBeDefined();
+    expect(statusRoute?.path).toBe('/api/status');
+    expect(statusRoute?.type).toBe('GET');
+    // Routes don't have a public property in the current implementation
+    expect(statusRoute?.handler).toBeDefined();
+  });
 
-    expect(startResult).toBeDefined();
-    expect(startResult.constructor.name).toBe('StarterService');
+  it('should handle request with query parameters', async () => {
+    const statusRoute = starterPlugin.routes?.[0];
+    if (!statusRoute?.handler) {
+      throw new Error('Status route handler not found');
+    }
+
+    const mockReq = {
+      query: {
+        verbose: 'true',
+      },
+    };
+
+    const mockRes = {
+      json: (data: any) => {
+        mockRes._jsonData = data;
+      },
+      _jsonData: null as any,
+    };
 
-    // Test real functionality - check stop method is available
-    expect(typeof startResult.stop).toBe('function');
+    await statusRoute.handler(mockReq, mockRes, runtime);
+
+    expect(mockRes._jsonData).toBeDefined();
+    expect(mockRes._jsonData.status).toBe('ok');
   });
+});
 
-  it('should stop the service', async () => {
-    const runtime = createRealRuntime();
+describe('Event Handlers', () => {
+  beforeEach(() => {
+    // Clear logger spy calls
+    (logger.debug as any).calls = [];
+    (logger.info as any).calls = [];
+    (logger.error as any).calls = [];
+  });
 
-    // Start the service to get the actual instance
-    const service = await StarterService.start(runtime as IAgentRuntime);
+  it('should log when MESSAGE_RECEIVED event is triggered', async () => {
+    const handler = starterPlugin.events?.[EventType.MESSAGE_RECEIVED]?.[0];
+    if (!handler) {
+      throw new Error('MESSAGE_RECEIVED event handler not found');
+    }
 
-    // Spy on the real service's stop method
-    const stopSpy = spyOn(service, 'stop');
+    const payload = testFixtures.messagePayload();
+    await handler(payload);
 
-    // Mock getService to return our spied service
-    const originalGetService = runtime.getService;
-    runtime.getService = <T extends Service>(serviceType: string): T | null => {
-      if (serviceType === StarterService.serviceType) {
-        return service as T;
-      }
-      return null;
+    expect(logger.debug).toHaveBeenCalled();
+  });
+
+  it('should handle malformed event payload', async () => {
+    const handler = starterPlugin.events?.[EventType.MESSAGE_RECEIVED]?.[0];
+    if (!handler) {
+      throw new Error('MESSAGE_RECEIVED event handler not found');
+    }
+
+    const malformedPayload = {
+      // Missing required fields
+      runtime: createMockRuntime(),
     };
 
-    // Call the static stop method
-    await StarterService.stop(runtime as IAgentRuntime);
+    // Should not throw
+    // Handler doesn't actually use the payload, just logs
+    await handler(malformedPayload as any);
+  });
 
-    // Verify the service's stop method was called
-    expect(stopSpy).toHaveBeenCalled();
+  it('should handle event with empty message content', async () => {
+    const handler = starterPlugin.events?.[EventType.MESSAGE_RECEIVED]?.[0];
+    if (!handler) {
+      throw new Error('MESSAGE_RECEIVED event handler not found');
+    }
 
-    // Restore original getService
-    runtime.getService = originalGetService;
+    const payload = testFixtures.messagePayload({
+      content: {},
+    });
+
+    await handler(payload);
+    expect(logger.debug).toHaveBeenCalled();
   });
+});
 
-  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
+describe('StarterService', () => {
+  let runtime: IAgentRuntime;
 
-    // We'll patch the getService function to ensure it returns null
-    const originalGetService = runtime.getService;
-    runtime.getService = () => null;
+  beforeEach(() => {
+    runtime = createMockRuntime();
+    // Clear logger spy calls
+    (logger.info as any).calls = [];
+    (logger.error as any).calls = [];
+  });
 
-    await expect(StarterService.stop(runtime as IAgentRuntime)).rejects.toThrow(
-      'Starter service not found'
-    );
+  it('should start the service', async () => {
+    const service = await StarterService.start(runtime);
+    expect(service).toBeInstanceOf(StarterService);
+    expect(logger.info).toHaveBeenCalled();
+  });
+
+  it('should have correct service type', () => {
+    expect(StarterService.serviceType).toBe('starter');
+  });
+
+  it('should stop service correctly', async () => {
+    // Start service
+    const service = await StarterService.start(runtime);
+
+    // Create a new runtime with the service registered
+    const runtimeWithService = createMockRuntime({
+      getService: () => service as any,
+    });
+
+    // Stop service
+    await StarterService.stop(runtimeWithService);
+    expect(logger.info).toHaveBeenCalled();
+  });
 
-    // Restore original getService function
-    runtime.getService = originalGetService;
+  it('should throw error when stopping non-existent service', async () => {
+    const emptyRuntime = createMockRuntime({
+      getService: () => null,
+    });
+
+    await expect(StarterService.stop(emptyRuntime)).rejects.toThrow('Starter service not found');
+  });
+
+  it('should handle multiple start/stop cycles', async () => {
+    // First cycle
+    const service1 = await StarterService.start(runtime);
+    expect(service1).toBeInstanceOf(StarterService);
+
+    const runtimeWithService1 = createMockRuntime({
+      getService: () => service1 as any,
+    });
+    await StarterService.stop(runtimeWithService1);
+
+    // Second cycle
+    const service2 = await StarterService.start(runtime);
+    expect(service2).toBeInstanceOf(StarterService);
+
+    const runtimeWithService2 = createMockRuntime({
+      getService: () => service2 as any,
+    });
+    await StarterService.stop(runtimeWithService2);
+  });
+
+  it('should provide capability description', async () => {
+    const service = await StarterService.start(runtime);
+    expect(service.capabilityDescription).toBe(
+      'This is a starter service which is attached to the agent through the starter plugin.'
+    );
   });
 });