n8n-trigger-testing-strategies — Claude Code skill: test n8n triggers
n8n-trigger-testing-strategies — a skill for testing how n8n workflows get triggered: webhooks, cron schedules, service events, polling. Useful when a workflow fires at the wrong moment or not at all.
MIT 128 installs ★ 533 updated 2026-10-25
npx skills add proffesor-for-testing/agentic-qe --skill n8n-trigger-testing-strategies -a claude-codeWhat n8n-trigger-testing-strategies does
The skill covers every way an n8n workflow can start: an HTTP webhook, a cron schedule, a service event, a polling check. A reference card maps trigger types to what to test, and there are TypeScript helpers plus an n8n-trigger-test subagent that walks the checklist from identifying the trigger to timing the response.
Webhook runs feed the endpoint an empty object, a big JSON body, a deeply nested one and a string full of special characters. Separate helpers loop over HTTP verbs and over auth scenarios: no header, a bad token, a good one, an expired one. Schedules get a cron validator that checks each field against its range (minutes 0–59, hours 0–23, day of month 1–31, month 1–12, weekday 0–7) and lists upcoming runs.
Auth checks need both a live token and an expired one. With only the first, you cannot tell whether the webhook rejects old sessions. The cron validator takes five or six fields; a four-part expression comes back as an error.
What it helps with
- send empty, oversized and nested payloads at a webhook
- find out which HTTP verbs the endpoint allows and which return 405
- confirm the webhook rejects a request with no token or an expired one
- validate a cron expression field by field and see the next runs
- time the trigger response across input types
Example prompts for the agent
- Test the webhook of my n8n workflow with an empty payload, a large JSON body and a deeply nested object.
- Check that the webhook refuses requests without an
Authorizationheader and with an expired token. - Walk through the cron expression
*/5 * * * *and show the next five runs.
How to install n8n-trigger-testing-strategies
1Skills CLI (Vercel)
npx skills add proffesor-for-testing/agentic-qe --skill n8n-trigger-testing-strategies -a claude-code2Manually: put the files in place
~/.claude/skills/n8n-trigger-testing-strategies/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/n8n-trigger-testing-strategies/
1Skills CLI (Vercel)
npx skills add proffesor-for-testing/agentic-qe --skill n8n-trigger-testing-strategies -a codex2Manually: put the files in place
.agents/skills/n8n-trigger-testing-strategies/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add proffesor-for-testing/agentic-qe --skill n8n-trigger-testing-strategies -a cursor2Manually: put the files in place
.cursor/skills/n8n-trigger-testing-strategies/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install proffesor-for-testing/agentic-qe assets/skills/n8n-trigger-testing-strategies2Manually: put the files in place
.github/skills/n8n-trigger-testing-strategies/SKILL.md1Skills CLI (Vercel)
npx skills add proffesor-for-testing/agentic-qe --skill n8n-trigger-testing-strategies -a gemini-cli2Platform CLI
gemini skills install https://github.com/proffesor-for-testing/agentic-qe --path assets/skills/n8n-trigger-testing-strategiesManually: put the files in place
.devin/skills/n8n-trigger-testing-strategies/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add proffesor-for-testing/agentic-qe --skill n8n-trigger-testing-strategies -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about n8n-trigger-testing-strategies
How do I install n8n-trigger-testing-strategies in Claude Code?
Run npx skills add proffesor-for-testing/agentic-qe --skill n8n-trigger-testing-strategies -a claude-code. The skill lands at ~/.claude/skills/n8n-trigger-testing-strategies/SKILL.md.
What does n8n-trigger-testing-strategies do?
It hands the agent test recipes for n8n triggers: webhook payloads, HTTP method sweeps, auth scenarios, cron field validation and response timing.
Does it need a running n8n instance?
The webhook helpers send requests to the address you supply, so the workflow has to be reachable. Auth scenarios also need a valid token and an expired one.
Source text
SKILL.md · MIT
---
name: n8n-trigger-testing-strategies
description: "Webhook testing, schedule validation, event-driven triggers, and polling mechanism testing for n8n workflows. Use when testing how workflows are triggered."
category: n8n-testing
priority: high
tokenEstimate: 1000
agents: [n8n-trigger-test]
implementation_status: production
optimization_version: 1.0
last_optimized: 2025-12-15
dependencies: []
quick_reference_card: true
tags: [n8n, triggers, webhook, schedule, cron, polling, testing]
trust_tier: 3
validation:
schema_path: schemas/output.json
validator_path: scripts/validate-config.json
eval_path: evals/n8n-trigger-testing-strategies.yaml
---
# n8n Trigger Testing Strategies
<default_to_action>
When testing n8n triggers:
1. IDENTIFY trigger type (webhook, schedule, polling, event)
2. TEST with various valid payloads
3. VERIFY authentication and authorization
4. CHECK error handling for invalid inputs
5. MEASURE response time and reliability
**Quick Trigger Checklist:**
- Trigger activates workflow correctly
- Payload parsed and validated
- Authentication enforced (if configured)
- Error responses are informative
- Response time is acceptable
**Critical Success Factors:**
- Test edge cases (empty payloads, large payloads)
- Verify idempotency where needed
- Check timeout handling
- Monitor for missed triggers
</default_to_action>
## Quick Reference Card
### n8n Trigger Types
| Type | Use Case | Testing Focus |
|------|----------|---------------|
| **Webhook** | External HTTP calls | Payloads, auth, methods |
| **Schedule** | Timed execution | Cron accuracy, timezone |
| **Polling** | Check for changes | Interval, deduplication |
| **Event** | Service events | Event handling, filtering |
### Common Webhook Configurations
| Setting | Options | Impact |
|---------|---------|--------|
| HTTP Method | GET, POST, PUT, DELETE | Request handling |
| Authentication | None, Basic, Header | Security |
| Response Mode | Immediately, Last Node, Custom | Response timing |
| Path | Custom URL path | Endpoint identification |
---
## Webhook Testing
### Basic Webhook Test
```typescript
// Test webhook with various payloads
async function testWebhook(webhookUrl: string): Promise<WebhookTestResult> {
const testPayloads = [
// Valid JSON
{ type: 'json', data: { event: 'test', timestamp: Date.now() } },
// Empty object
{ type: 'empty', data: {} },
// Large payload
{ type: 'large', data: { items: Array(1000).fill({ id: 1, name: 'test' }) } },
// Nested data
{ type: 'nested', data: { level1: { level2: { level3: { value: 'deep' } } } } },
// Special characters
{ type: 'special', data: { text: 'Hello <script>alert("xss")</script>' } }
];
const results: PayloadTestResult[] = [];
for (const payload of testPayloads) {
const startTime = Date.now();
try {
const response = await fetch(webhookUrl, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(payload.data)
});
results.push({
payloadType: payload.type,
success: response.ok,
status: response.status,
responseTime: Date.now() - startTime,
responseBody: await response.text()
});
} catch (error) {
results.push({
payloadType: payload.type,
success: false,
error: error.message
});
}
}
return { webhookUrl, results };
}
```
### HTTP Method Testing
```typescript
// Test all HTTP methods
async function testWebhookMethods(webhookUrl: string): Promise<MethodTestResult[]> {
const methods = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD', 'OPTIONS'];
const results: MethodTestResult[] = [];
for (const method of methods) {
try {
const response = await fetch(webhookUrl, {
method,
headers: { 'Content-Type': 'application/json' },
body: ['GET', 'HEAD', 'OPTIONS'].includes(method) ? undefined : '{}'
});
results.push({
method,
allowed: response.ok || response.status !== 405,
status: response.status,
statusText: response.statusText
});
} catch (error) {
results.push({
method,
allowed: false,
error: error.message
});
}
}
return results;
}
```
### Authentication Testing
```typescript
// Test webhook authentication
async function testWebhookAuth(webhookUrl: string, authConfig: AuthConfig): Promise<AuthTestResult> {
const scenarios = [
// No auth
{ name: 'no-auth', headers: {} },
// Invalid auth
{ name: 'invalid-auth', headers: { 'Authorization': 'Bearer invalid-token' } },
// Valid auth
{ name: 'valid-auth', headers: { 'Authorization': `Bearer ${authConfig.token}` } },
// Expired auth
{ name: 'expired-auth', headers: { 'Authorization': `Bearer ${authConfig.expiredToken}` } }
];
const results: AuthScenarioResult[] = [];
for (const scenario of scenarios) {
const response = await fetch(webhookUrl, {
method: 'POST',
headers: {
'Content-Type': 'application/json',
...scenario.headers
},
body: '{}'
});
results.push({
scenario: scenario.name,
status: response.status,
authenticated: response.ok,
errorMessage: response.ok ? null : await response.text()
});
}
return {
authRequired: !results.find(r => r.scenario === 'no-auth')?.authenticated,
invalidRejected: !results.find(r => r.scenario === 'invalid-auth')?.authenticated,
validAccepted: results.find(r => r.scenario === 'valid-auth')?.authenticated,
results
};
}
```
---
## Schedule Testing
### Cron Expression Validation
```typescript
// Validate cron expression
function validateCronExpression(expression: string): CronValidationResult {
const parts = expression.trim().split(/\s+/);
if (parts.length < 5 || parts.length > 6) {
return {
valid: false,
error: `Expected 5-6 parts, got ${parts.length}`
};
}
const [minute, hour, dayOfMonth, month, dayOfWeek, year] = parts;
const validations = [
{ field: 'minute', value: minute, range: [0, 59] },
{ field: 'hour', value: hour, range: [0, 23] },
{ field: 'dayOfMonth', value: dayOfMonth, range: [1, 31] },
{ field: 'month', value: month, range: [1, 12] },
{ field: 'dayOfWeek', value: dayOfWeek, range: [0, 7] }
];
for (const v of validations) {
const result = validateCronField(v.value, v.range);
if (!result.valid) {
return { valid: false, error: `Invalid ${v.field}: ${result.error}` };
}
}
return {
valid: true,
description: describeCronExpression(expression),
nextExecutions: getNextCronExecutions(expression, 5)
};
}
// Get human-readable description
function describeCronExpression(expression: string): string {
// Common patterns
const patterns: Record<string, string> = {
'* * * * *': 'Every minute',
'*/5 * * * *': 'Every 5 minutes',
'0 * * * *': 'Every hour',
'0 0 * * *': 'Every day at midnight',
'0 9 * * 1-5': 'Weekdays at 9:00 AM',
'0 0 1 * *': 'First day of every month',
'0 0 * * 0': 'Every Sunday at midnight'
};
return patterns[expression] || 'Custom schedule';
}
// Calculate next execution times
function getNextCronExecutions(expression: string, count: number): Date[] {
const executions: Date[] = [];
let current = new Date();
// Simple implementation - use cron-parser library in production
for (let i = 0; i < count; i++) {
const next = calculateNextCronExecution(expression, current);
executions.push(next);
current = new Date(next.getTime() + 60000); // Move past this execution
}
return executions;
}
```
### Schedule Reliability Testing
```typescript
// Test schedule trigger reliability
async function testScheduleReliability(triggerId: string, testDuration: number): Promise<ScheduleTestResult> {
const startTime = Date.now();
const expectedExecutions: Date[] = [];
const actualExecutions: Date[] = [];
// Calculate expected execution times
const cronExpression = await getTriggerCronExpression(triggerId);
let checkTime = new Date(startTime);
while (checkTime.getTime() < startTime + testDuration) {
const nextExec = calculateNextCronExecution(cronExpression, checkTime);
if (nextExec.getTime() < startTime + testDuration) {
expectedExecutions.push(nextExec);
}
checkTime = new Date(nextExec.getTime() + 60000);
}
// Monitor actual executions
const executionListener = onExecutionStart(triggerId, (exec) => {
actualExecutions.push(new Date(exec.startedAt));
});
// Wait for test duration
await sleep(testDuration);
executionListener.stop();
// Compare expected vs actual
const comparison = compareExecutions(expectedExecutions, actualExecutions);
return {
testDuration,
expectedCount: expectedExecutions.length,
actualCount: actualExecutions.length,
missedExecutions: comparison.missed,
extraExecutions: comparison.extra,
timingAccuracy: comparison.timingAccuracy,
reliability: (actualExecutions.length / expectedExecutions.length) * 100
};
}
```
---
## Polling Trigger Testing
```typescript
// Test polling trigger behavior
async function testPollingTrigger(triggerId: string, testConfig: PollingTestConfig): Promise<PollingTestResult> {
const { interval, testDuration, simulateDataChanges } = testConfig;
const pollEvents: PollEvent[] = [];
const triggeredExecutions: Execution[] = [];
// Monitor polling events
const pollListener = onPoll(triggerId, (event) => {
pollEvents.push({
timestamp: new Date(),
dataFound: event.hasNewData,
itemCount: event.items?.length || 0
});
});
// Monitor triggered executions
const execListener = onExecutionStart(triggerId, (exec) => {
triggeredExecutions.push(exec);
});
// Optionally simulate data changes
if (simulateDataChanges) {
for (const change of simulateDataChanges) {
setTimeout(() => {
injectTestData(triggerId, change.data);
}, change.at);
}
}
// Wait for test duration
await sleep(testDuration);
pollListener.stop();
execListener.stop();
// Analyze results
const expectedPolls = Math.floor(testDuration / interval);
const actualPolls = pollEvents.length;
return {
interval,
testDuration,
expectedPolls,
actualPolls,
pollAccuracy: (actualPolls / expectedPolls) * 100,
averageInterval: calculateAverageInterval(pollEvents),
executionsTriggered: triggeredExecutions.length,
deduplicationWorking: checkDeduplication(triggeredExecutions),
pollEvents
};
}
// Check if deduplication is working
function checkDeduplication(executions: Execution[]): boolean {
const processedIds = new Set();
for (const exec of executions) {
const itemIds = exec.data?.resultData?.runData?.Trigger?.[0]?.data?.main?.[0]
?.map(item => item.json?.id);
if (itemIds) {
for (const id of itemIds) {
if (processedIds.has(id)) {
return false; // Duplicate found
}
processedIds.add(id);
}
}
}
return true;
}
```
---
## Event Trigger Testing
```typescript
// Test event-driven triggers
async function testEventTrigger(triggerId: string, eventConfig: EventTestConfig): Promise<EventTestResult> {
const { eventType, testEvents, timeout } = eventConfig;
const results: EventResult[] = [];
for (const testEvent of testEvents) {
// Emit test event
const startTime = Date.now();
await emitTestEvent(eventType, testEvent.payload);
// Wait for trigger
try {
const execution = await waitForTrigger(triggerId, timeout);
results.push({
eventType: testEvent.type,
triggered: true,
latency: Date.now() - startTime,
payloadReceived: execution.data?.inputData
});
} catch (error) {
results.push({
eventType: testEvent.type,
triggered: false,
error: error.message
});
}
}
return {
eventType,
testsRun: testEvents.length,
triggered: results.filter(r => r.triggered).length,
averageLatency: average(results.filter(r => r.triggered).map(r => r.latency)),
results
};
}
```
---
## Trigger Response Testing
```typescript
// Test trigger response modes
async function testTriggerResponses(webhookUrl: string): Promise<ResponseTestResult> {
// Test immediate response
const immediateStart = Date.now();
const immediateResponse = await fetch(webhookUrl, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: '{"test": "immediate"}'
});
const immediateTime = Date.now() - immediateStart;
// Test with workflow execution
const workflowStart = Date.now();
const workflowResponse = await fetch(`${webhookUrl}?waitForResponse=true`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: '{"test": "workflow"}'
});
const workflowTime = Date.now() - workflowStart;
return {
immediateResponse: {
status: immediateResponse.status,
time: immediateTime,
body: await immediateResponse.text()
},
workflowResponse: {
status: workflowResponse.status,
time: workflowTime,
body: await workflowResponse.text()
},
responseMode: workflowTime > immediateTime + 100 ? 'workflow' : 'immediate'
};
}
```
---
## Test Scenarios
```yaml
Webhook Scenarios:
- name: Valid JSON POST
method: POST
payload: {"event": "test"}
expected: 200 OK
- name: Invalid JSON
method: POST
payload: "not valid json"
expected: 400 Bad Request
- name: Missing auth
method: POST
headers: {}
expected: 401 Unauthorized
- name: Large payload
method: POST
payload: [10MB of data]
expected: 413 Payload Too Large
Schedule Scenarios:
- name: Every 5 minutes
cron: "*/5 * * * *"
verify: 12 executions per hour
- name: Weekdays at 9 AM
cron: "0 9 * * 1-5"
verify: 5 executions per week
Polling Scenarios:
- name: 1 minute interval
interval: 60000
verify: ~60 polls per hour
- name: Deduplication
interval: 60000
inject_duplicate: true
verify: No duplicate processing
```
---
## Related Skills
- [n8n-workflow-testing-fundamentals](../n8n-workflow-testing-fundamentals/)
- [n8n-integration-testing-patterns](../n8n-integration-testing-patterns/)
- [n8n-security-testing](../n8n-security-testing/)
---
## Remember
**n8n triggers are the entry points** to workflows. Testing requires:
- Webhook: Payload handling, auth, HTTP methods
- Schedule: Cron accuracy, timezone handling
- Polling: Interval accuracy, deduplication
- Event: Event handling, filtering
**Key patterns:** Test with various payloads (valid, invalid, edge cases). Verify authentication enforcement. Check response times and reliability over time.
© proffesor-for-testing · MIT · proffesor-for-testing/agentic-qe