testing-helper

Create comprehensive tests for elizaOS plugins, characters, and actions. Triggers on "create tests", "test elizaOS plugin", or "write agent tests"

⭐5stars🔀1forks📁View on GitHub🕐Updated Jan 11, 2026

When & Why to Use This Skill

The Testing Helper skill is a specialized developer tool designed to automate the creation of comprehensive test suites for the elizaOS framework. It streamlines the software development lifecycle (SDLC) for AI agents by generating high-quality unit, integration, and end-to-end (E2E) tests. By focusing on core components like actions, providers, and character configurations, this skill ensures that AI agents are robust, reliable, and perform as expected before deployment, significantly reducing manual debugging time and improving code coverage.

Use Cases

  • Generating Vitest-based unit tests for custom elizaOS actions to validate input validation and execution logic.
  • Creating integration tests to ensure that new plugins and their associated components interact correctly with the AgentRuntime.
  • Developing end-to-end (E2E) test scripts to simulate real-world user interactions and verify the entire agentic response flow.
  • Validating character configuration files to ensure required fields, bios, and message examples are correctly structured and functional.
  • Automating the setup of mock runtimes and messages to test providers and evaluators under various edge-case scenarios.
nametesting-helper
descriptionCreate comprehensive tests for elizaOS plugins, characters, and actions. Triggers on "create tests", "test elizaOS plugin", or "write agent tests"
allowed-tools[Write, Read, Edit]

Testing Helper Skill

Generate comprehensive test suites for elizaOS components with unit, integration, and E2E tests.

Test Structure

__tests__/
├── unit/
│   ├── actions.test.ts
│   ├── providers.test.ts
│   ├── evaluators.test.ts
│   └── services.test.ts
├── integration/
│   ├── plugin.test.ts
│   └── character.test.ts
└── e2e/
    └── agent-flow.test.ts

Action Tests

import { describe, it, expect, beforeEach } from 'vitest';
import { myAction } from '../src/actions/myAction';
import { createMockRuntime, createMockMessage } from '@elizaos/core/test';

describe('MyAction', () => {
  let runtime: any;
  let message: any;

  beforeEach(() => {
    runtime = createMockRuntime();
    message = createMockMessage();
  });

  it('validates correct input', async () => {
    const valid = await myAction.validate(runtime, message);
    expect(valid).toBe(true);
  });

  it('rejects invalid input', async () => {
    message.content = {};
    const valid = await myAction.validate(runtime, message);
    expect(valid).toBe(false);
  });

  it('executes successfully', async () => {
    const result = await myAction.handler(runtime, message);
    expect(result).toBeDefined();
  });

  it('handles errors gracefully', async () => {
    runtime.createMemory = () => { throw new Error('Test error'); };
    const result = await myAction.handler(runtime, message);
    expect(result).toContain('failed');
  });
});

Provider Tests

describe('MyProvider', () => {
  it('returns valid data', async () => {
    const result = await myProvider.get(runtime, message);

    expect(result).toHaveProperty('values');
    expect(result).toHaveProperty('data');
    expect(result).toHaveProperty('text');
    expect(typeof result.text).toBe('string');
  });

  it('handles missing data', async () => {
    const result = await myProvider.get(runtime, null);
    expect(result.text).toBe('');
  });
});

Character Tests

describe('Character Configuration', () => {
  it('has required fields', () => {
    expect(character.name).toBeDefined();
    expect(character.bio).toBeDefined();
  });

  it('has valid plugins', () => {
    expect(character.plugins).toContain('@elizaos/plugin-bootstrap');
  });

  it('has valid message examples', () => {
    character.messageExamples?.forEach(conversation => {
      expect(Array.isArray(conversation)).toBe(true);
      conversation.forEach(msg => {
        expect(msg).toHaveProperty('name');
        expect(msg).toHaveProperty('content');
      });
    });
  });
});

Integration Tests

describe('Plugin Integration', () => {
  let runtime: AgentRuntime;

  beforeAll(async () => {
    runtime = new AgentRuntime({
      character: testCharacter,
      plugins: [myPlugin]
    });
    await runtime.initialize();
  });

  afterAll(async () => {
    await runtime.stop();
  });

  it('loads plugin correctly', () => {
    expect(runtime.plugins).toContain(myPlugin);
  });

  it('registers actions', () => {
    const action = runtime.actions.find(a => a.name === 'MY_ACTION');
    expect(action).toBeDefined();
  });
});

E2E Tests

describe('Agent Flow', () => {
  it('processes message end-to-end', async () => {
    const response = await runtime.processMessage({
      content: { text: 'Hello' },
      senderId: 'user-1',
      roomId: 'room-1'
    });

    expect(response.content.text).toBeDefined();
  });
});

Coverage Requirements

  • Unit tests: >80% code coverage
  • Integration tests: All components
  • E2E tests: Main user flows
  • Error scenarios tested
  • Edge cases covered