Skip to main content Início Criadores proffesor-for-testing agentic-qe n8n-workflow-testing-fundamentals
n8n-workflow-testing-fundamentals Comprehensive n8n workflow testing including execution lifecycle, node connection patterns, data flow validation, and error handling strategies. Use when testing n8n workflow automation applications.
Ir para a instalação Skills Marketplace Descubra e explore skills de IA criadas pela comunidade.
Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Mostrar detalhes do prompt Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.
npx skills add https://github.com/proffesor-for-testing/agentic-qe --skill n8n-workflow-testing-fundamentalsO comando permanece em uma só linha. Role horizontalmente para revisá-lo antes de copiar.
Prefere uma cópia local? Baixe os arquivos disponíveis atualmente no SkillsMP.
Baixar Zip Baixando... Mais deste repositório Ruflo is a multi-agent orchestration platform for AI coding agents (Claude Code, Cursor, Codex, Copilot, Gemini, Amp, +12 more). Use this skill when the user wants to (1) install/init ruflo in a project, (2) run multi-agent swarms with hierarchical coordination, (3) use ruflo's 314+ MCP tools for memory, routing, hooks, sub-agents, or workflows, (4) check ruflo status/version/doctor health, or (5) discover which of ruflo's 30+ plugins fits their task.
Build dependency-aware execution plans for complex Agentic QE, Ruflo, integration, migration, or multi-stream engineering programs. Use when Codex must turn research or requirements into phased work, select a small AQE fleet, map critical paths and parallel streams, define acceptance gates, or sequence risky changes. Use aqe-plan-quality instead when the primary output is only a test or quality plan.
Conduct evidence-first technical research for Agentic QE, Ruflo, related ruvnet projects, or external tools. Use when Codex must investigate a repository, compare current upstream changes, trace dependencies and history, distinguish verified facts from inference, or synthesize findings into actionable engineering recommendations. Do not use for a simple known-answer lookup or an implementation-only task.
Ocupações relacionadas SOC
Baseado na classificação ocupacional SOC
Explorador de arquivos
4 arquivos name n8n-workflow-testing-fundamentals description Comprehensive n8n workflow testing including execution lifecycle, node connection patterns, data flow validation, and error handling strategies. Use when testing n8n workflow automation applications. category n8n-testing priority high tokenEstimate 1200 agents ["n8n-workflow-executor","n8n-node-validator","n8n-trigger-test"] implementation_status production optimization_version 1 last_optimized "2025-12-15T00:00:00.000Z" dependencies [] quick_reference_card true tags ["n8n","workflow","automation","testing","data-flow","nodes","triggers"] trust_tier 3 validation {"schema_path":"schemas/output.json","validator_path":"scripts/validate-config.json","eval_path":"evals/n8n-workflow-testing-fundamentals.yaml"}
n8n Workflow Testing Fundamentals
<default_to_action>
When testing n8n workflows:
VALIDATE workflow structure before execution
TEST with realistic test data
VERIFY node-to-node data flow
CHECK error handling paths
MEASURE execution performance
Quick n8n Testing Checklist:
All nodes properly connected (no orphans)
Trigger node correctly configured
Data mappings between nodes valid
Error workflows defined
Credentials properly referenced
Critical Success Factors:
Test each execution path separately
Validate data transformations at each node
Check retry and error handling behavior
Verify integrations with external services
</default_to_action>
Quick Reference Card
When to Use
Testing new n8n workflows
Validating workflow changes
Debugging failed executions
Performance optimization
Pre-deployment validation
n8n Workflow Components
Component Purpose Testing Focus Trigger Starts workflow Reliable activation, payload handling Action Nodes Process data Configuration, data mapping Logic Nodes Control flow Conditional routing, branches Integration Nodes External APIs Auth, rate limits, errors Error Workflow Handle failures Recovery, notifications
Workflow Execution States
State Meaning Test Action runningCurrently executing Monitor progress successCompleted successfully Validate outputs failedExecution failed Analyze error
waitingWaiting for trigger Test trigger mechanism
Workflow Structure Validation
async function validateWorkflowStructure (workflowId : string const workflow = await getWorkflow (workflowId);
const triggerNode = workflow.nodes .find (n =>type .includes ('trigger' ) || n.type .includes ('webhook' )
);
if (!triggerNode) {
throw new Error ('Workflow must have a trigger node' );
}
const connectedNodes = new Set ();
for (const [source, targets] of Object .entries (workflow.connections )) {
connectedNodes.add (source);
for (const outputs of Object .values (targets)) {
for (const connections of outputs) {
for (const conn of connections) {
connectedNodes.add (conn.node );
}
}
}
}
const orphans = workflow.nodes .filter (n =>has (n.name ));
if (orphans.length > 0 ) {
console .warn ('Orphan nodes detected:' , orphans.map (n =>name ));
}
for (const node of workflow.nodes ) {
if (node.credentials ) {
for (const [type , ref] of Object .entries (node.credentials )) {
if (!await credentialExists (ref.id )) {
throw new Error (`Missing credential: ${type } for node ${node.name} ` );
}
}
}
}
return { valid : true , orphans, triggerNode };
}
Execution Testing
async function testWorkflowExecution (workflowId : string , testCases : TestCase []const results : TestResult [] = [];
for (const testCase of testCases) {
const startTime = Date .now ();
const execution = await executeWorkflow (workflowId, testCase.input );
const result = await waitForCompletion (execution.id , testCase.timeout || 30000 );
const outputValid = validateOutput (result.data , testCase.expected );
results.push ({
testCase : testCase.name ,
success : result.status === 'success' && outputValid,
duration : Date .now () - startTime,
actualOutput : result.data ,
expectedOutput : testCase.expected
});
}
return results;
}
const testCases = [
{
name : 'Valid customer data' ,
input : { name : 'John Doe' , email : 'john@example.com' },
expected : { processed : true , customerId : /^cust_/ },
timeout : 10000
},
{
name : 'Missing email' ,
input : { name : 'Jane Doe' },
expected : { error : 'Email required' },
timeout : 5000
},
{
name : 'Invalid email format' ,
input : { name : 'Bob' , email : 'not-an-email' },
expected : { error : 'Invalid email' },
timeout : 5000
}
];
Data Flow Validation
async function validateDataFlow (executionId : string const execution = await getExecution (executionId);
const nodeResults = execution.data .resultData .runData ;
const dataFlow : DataFlowStep [] = [];
for (const [nodeName, runs] of Object .entries (nodeResults)) {
for (const run of runs) {
dataFlow.push ({
node : nodeName,
input : run.data ?.main ?.[0 ]?.[0 ]?.json || {},
output : run.data ?.main ?.[0 ]?.[0 ]?.json || {},
executionTime : run.executionTime ,
status : run.executionStatus
});
}
}
for (let i = 1 ; i < dataFlow.length ; i++) {
const prev = dataFlow[i - 1 ];
const curr = dataFlow[i];
validateDataMapping (prev.output , curr.input );
}
return dataFlow;
}
function validateDataMapping (sourceOutput : any , targetInput : any const missingFields : string [] = [];
for (const [key, value] of Object .entries (targetInput)) {
if (value === undefined && sourceOutput[key] === undefined ) {
missingFields.push (key);
}
}
if (missingFields.length > 0 ) {
console .warn ('Missing fields in data mapping:' , missingFields);
}
return missingFields.length === 0 ;
}
Error Handling Testing
async function testErrorHandling (workflowId : string const errorScenarios = [
{
name : 'API timeout' ,
inject : { delay : 35000 },
expectedError : 'timeout'
},
{
name : 'Invalid data' ,
inject : { invalidField : true },
expectedError : 'validation'
},
{
name : 'Missing credentials' ,
inject : { removeCredentials : true },
expectedError : 'authentication'
}
];
const results : ErrorTestResult [] = [];
for (const scenario of errorScenarios) {
const execution = await executeWithErrorInjection (workflowId, scenario.inject );
const result = await waitForCompletion (execution.id );
results.push ({
scenario : scenario.name ,
errorCaught : result.status === 'failed' ,
errorType : result.data ?.resultData ?.error ?.type ,
expectedError : scenario.expectedError ,
errorWorkflowTriggered : await checkErrorWorkflowTriggered (execution.id ),
alertSent : await checkAlertSent (execution.id )
});
}
return results;
}
async function checkErrorWorkflowTriggered (executionId : string Promise <boolean > {
const errorExecutions = await getExecutions ({
filter : {
metadata : { errorTriggeredBy : executionId }
}
});
return errorExecutions.length > 0 ;
}
Node Connection Patterns
Linear Flow Trigger → Process → Transform → Output
Testing: Execute once, validate each node output
Branching Flow Trigger → IF → [Branch A] → Merge → Output
→ [Branch B] →
Testing: Test both branches separately, verify merge behavior
Parallel Flow Trigger → Split → [Process A] → Merge → Output
→ [Process B] →
Testing: Validate parallel execution, check merge timing
Loop Flow Trigger → SplitInBatches → Process → [Loop back until done] → Output
Testing: Test with varying batch sizes, verify all items processed
Common Testing Patterns
Test Data Generation
const testDataGenerators = {
webhook : () => ({
body : { event : 'test' , timestamp : new Date ().toISOString () },
headers : { 'Content-Type' : 'application/json' },
query : { source : 'test' }
}),
slack : () => ({
type : 'message' ,
channel : 'C123456' ,
user : 'U789012' ,
text : 'Test message'
}),
github : () => ({
action : 'opened' ,
issue : {
number : 1 ,
title : 'Test Issue' ,
body : 'Test body'
},
repository : {
full_name : 'test/repo'
}
}),
stripe : () => ({
type : 'payment_intent.succeeded' ,
data : {
object : {
id : 'pi_test123' ,
amount : 1000 ,
currency : 'usd'
}
}
})
};
Execution Assertions
const workflowAssertions = {
assertCompleted : (execution ) => {
expect (execution.finished ).toBe (true );
expect (execution.status ).toBe ('success' );
},
assertNodeExecuted : (execution, nodeName ) => {
const nodeData = execution.data .resultData .runData [nodeName];
expect (nodeData).toBeDefined ();
expect (nodeData[0 ].executionStatus ).toBe ('success' );
},
assertDataTransformed : (execution, nodeName, expectedData ) => {
const nodeOutput = execution.data .resultData .runData [nodeName][0 ].data .main [0 ][0 ].json ;
expect (nodeOutput).toMatchObject (expectedData);
},
assertExecutionTime : (execution, maxMs ) => {
const duration = new Date (execution.stoppedAt ) - new Date (execution.startedAt );
expect (duration).toBeLessThan (maxMs);
}
};
Agent Coordination Hints
Memory Namespace aqe/n8n/
├── workflows/* - Cached workflow definitions
├── test-results/* - Test execution results
├── validations/* - Validation reports
├── patterns/* - Discovered testing patterns
└── executions/* - Execution tracking
Fleet Coordination
const n8nFleet = await FleetManager .coordinate ({
strategy : 'n8n-testing' ,
agents : [
'n8n-workflow-executor' ,
'n8n-node-validator' ,
'n8n-trigger-test' ,
'n8n-expression-validator' ,
'n8n-integration-test'
],
topology : 'parallel'
});
Related Skills
Remember n8n workflows are JSON-based execution flows that connect 400+ services. Testing requires validating:
Workflow structure (nodes, connections)
Trigger reliability (webhooks, schedules)
Data flow (transformations between nodes)
Error handling (retry, fallback, notifications)
Performance (execution time, resource usage)
With Agents: Use n8n-workflow-executor for execution testing, n8n-node-validator for configuration validation, and coordinate multiple agents for comprehensive workflow testing.
