Skip to content
Skills Library
AI & agents · Testing

a2a-testing

/a2a-testing

Test A2A implementations — unit tests, integration tests, mock agents, protocol conformance, and end-to-end multi-agent testing. Use when building test suites for A2A servers, clients, or multi-agent systems.

Licence
MIT
Last repository change
14.09.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
1
Deprecation

No signals detected. Repository changed on 14.09.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Test A2A implementations — unit tests, integration tests, mock agents, protocol conformance, and end-to-end multi-agent testing. Use when building test suites for A2A servers, clients, or multi-agent systems.

Original author description

Test A2A implementations — unit tests, integration tests, mock agents, protocol conformance, and end-to-end multi-agent testing. Use when building test suites for A2A servers, clients, or multi-agent systems.

How it works

  1. Before writing code
  2. Conceptual Architecture
Original SKILL.md headings · 109 lines, 551 words
SKILL.md preview
---
name: a2a-testing
description: Test A2A implementations — unit tests, integration tests, mock agents, protocol conformance, and end-to-end multi-agent testing. Use when building test suites for A2A servers, clients, or multi-agent systems.
allowed-tools: Read, Write, Edit, Bash, Grep, Glob, WebSearch, WebFetch
---

# A2A Testing

## Before writing code

**Fetch live docs**:
1. Fetch `https://a2a-protocol.org/latest/specification/` for protocol requirements to test against
2. Web-search `site:github.com a2aproject A2A testing conformance` for testing tools and guidance
3. Web-search `site:github.com a2aproject a2a-samples test` for test examples
4. Fetch SDK docs for test utilities, mock classes, and test helpers

## Conceptual Architecture

### Testing Levels

A2A implementations need testing at multiple levels:

#### 1. Unit Tests
Test individual components in isolation:
- Agent handler logic (given input message, verify output)
- Task state management (verify state transitions)
- Message/Part construction and parsing
- Agent Card validation
- Error code generation

#### 2. Integration Tests
Test the A2A server with a real HTTP stack:
- Send JSON-RPC requests, verify responses
- Test all supported methods (message/send, tasks/get, etc.)
- Verify Agent Card serving at `/.well-known/agent-card.json`
- Test authentication flows
- Test streaming with SSE client

#### 3. Protocol Conformance Tests
Verify compliance with the A2A specification:
- All required methods are implemented
- Request/response schemas match the spec
- Error codes are correct
- State transitions follow the rules
- Agent Card schema is valid

#### 4. End-to-End Tests
Test full multi-agent workflows:
- Client discovers agent via Agent Card
- Client sends task, agent processes, client receives result
- Multi-turn conversations complete successfully
- Error scenarios are handled gracefully
- Multiple agents collaborate on a complex task

### Mock Agents

For testing clients, create mock A2A servers that:
- Return predefined responses
- Simulate different task states
- Simulate errors and failures
- Simulate slow responses and timeouts
- Support streaming with controlled events

For testing servers, create mock A2A clients that:
- Send various message types and parts
- Exercise multi-turn flows
- Send invalid requests to test error handling
- Simulate disconnections during streaming

### What to Test

**Server tests:**
- Agent Card is valid and accessible
- All declared methods work correctly
- Task state transitions are correct
- Error codes are appropriate
- Streaming events are properly formatted
- Push notifications are delivered
- Authentication is enforced
- Concurrent requests are handled

**Client tests:**
- Agent Card discovery and parsing
- Request construction (correct JSON-RPC format)
- Response handling for all task states
- Error handling and retry logic
- Multi-turn conversation flow
- Streaming event processing
- Authentication credential handling

### Testing Patterns

**Stateful server tests**: Use an in-memory task store, send a sequence of requests, verify the accumulated state.

**Snapshot testing**: Capture JSON-RPC request/response pairs and verify they match expected schemas.

**Chaos testing**: Introduce random failures, slow responses, and disconnections to test resilience.

**Contract testing**: Verify that client and server agree on the message schemas (both sides validate against the spec).

### Best Practices

- Test all 9 task states, not just the happy path
- Test invalid state transitions (should return errors, not crash)
- Test with all Part types (TextPart, FilePart, DataPart)
- Test streaming with slow consumers and fast producers
- Test authentication with valid and invalid credentials
- Use deterministic agent logic in tests (not real LLMs) for reproducibility
- Validate all JSON-RPC responses against the schema
- Run tests in CI/CD pipelines
- Test Agent Card changes (schema validation)

Fetch any official conformance test suites or testing utilities from the A2A project before building custom test infrastructure.

Versions

The database has no other skills named a2a-testing.

Database snapshot: 13.11.2026 · package version c45b0a7a993b (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100test-generator
    Generate comprehensive test suites including unit tests, integration tests, and e2e tests. Use this skill when users need help writing tests, improving test coverage, or setting up testing frameworks.
  • 100testing
    Generate, execute, and analyze tests for codebases, covering unit, integration, and end-to-end testing with coverage reporting. Use when the user requests testing or provides relevant inputs for this workflow.
  • 100testing-expert
    Expert-level software testing with unit tests, integration tests, E2E tests, TDD/BDD, and testing best practices. Use when the user mentions TDD, BDD, unit tests, integration tests, or end-to-end tests, or when the task involves Testing Fundamentals, Unit Testing, Integration…
  • 100testing-strategy
    Comprehensive testing methodology, test pyramid, deterministic unit tests, and integration testing. Use when designing test suites or debugging flaky tests.
  • 90mobile-testing
    Use this skill when the user asks about mobile testing strategies, unit tests, widget tests, component tests, integration tests, E2E, golden/snapshot tests, mocking, or CI test integration.
  • 100javascript-testing-patterns
    Implement comprehensive testing strategies using Jest, Vitest, and Testing Library for unit tests, integration tests, and end-to-end testing with mocking, fixtures, and test-driven development. Use when writing JavaScript/TypeScript tests, setting up test infrastructure, or…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.