Skip to main content سوق المهارات اكتشف واستكشف مهارات الذكاء الاصطناعي التي بناها المجتمع.
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
عرض تفاصيل Prompt يتجاوز الأمر المباشر Prompt المخصّص للمراجعة. افحص المصدر قبل تشغيله.
npx skills add https://github.com/proffesor-for-testing/agentic-qe --skill n8n-workflow-testing-fundamentalsيبقى الأمر في سطر واحد. مرّر أفقيًا لمراجعته كاملًا قبل النسخ.
تفضّل نسخة محلية؟ نزّل الملفات المتاحة حاليًا لدى SkillsMP.
تحميل Zip جاري التحميل... 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.
المهن ذات الصلة SOC
استنادا إلى تصنيف SOC المهني
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.
