qe-n8n-integration-testing-patterns

inclusion	auto
name	qe-n8n-integration-testing-patterns
description	API contract testing, authentication flows, rate limit handling, and error scenario coverage for n8n integrations with external services. Use when testing n8n node integrations.
tags	["n8n","integration","api","authentication","oauth","rate-limiting","testing"]

n8n Integration Testing Patterns

<default_to_action> When testing n8n integrations:

1. VERIFY connectivity and authentication
2. TEST all configured operations
3. VALIDATE API response handling
4. CHECK rate limit behavior
5. CONFIRM error handling works

Quick Integration Checklist:

• Credentials valid and not expired
• API permissions sufficient for operations
• Rate limits understood and respected
• Error responses properly handled
• Data formats match API expectations

Critical Success Factors:

• Test in isolation before workflow integration
• Verify OAuth token refresh works
• Check API version compatibility
• Monitor rate limit headers </default_to_action>

Quick Reference Card

Common n8n Integrations

Category	Services	Auth Type
Communication	Slack, Teams, Discord	OAuth2, Webhook
Data Storage	Google Sheets, Airtable	OAuth2, API Key
CRM	Salesforce, HubSpot	OAuth2
Dev Tools	GitHub, Jira, Linear	OAuth2, API Key
Marketing	Mailchimp, SendGrid	API Key

Authentication Types

Type	Setup	Refresh
OAuth2	User authorization flow	Automatic token refresh
API Key	Manual key entry	Manual rotation
Basic Auth	Username/password	No refresh needed
Header Auth	Custom header	Manual rotation

---

Connectivity Testing

// Test integration connectivity
async function testIntegrationConnectivity(nodeName: string): Promise<ConnectivityResult> {
  const node = await getNodeConfig(nodeName);

  // Check credential exists
  if (!node.credentials) {
    return { connected: false, error: 'No credentials configured' };
  }

  // Test based on integration type
  switch (getIntegrationType(node.type)) {
    case 'slack':
      return await testSlackConnectivity(node.credentials);
    case 'google-sheets':
      return await testGoogleSheetsConnectivity(node.credentials);
    case 'jira':
      return await testJiraConnectivity(node.credentials);
    case 'github':
      return await testGitHubConnectivity(node.credentials);
    default:
      return  (node);
  }
}


  (): <> {
   {
     response =  (, {
      : { :  }
    });
     data =  response.();

     {
      : data.,
      : data.,
      : data.,
      : data.?. || []
    };
  }  (error) {
     { : , : error. };
  }
}


  (): <> {
   {
     response =  (, {
      : { :  }
    });

     (response. === ) {
      
       refreshed =  (credentials);
       (refreshed) {
         ({ ...credentials, : refreshed });
      }
       { : , :  };
    }

     data =  response.();
     { : , : data. };
  }  (error) {
     { : , : error. };
  }
}

---

API Operation Testing

// Test integration operations
async function testIntegrationOperations(nodeName: string): Promise<OperationResult[]> {
  const node = await getNodeConfig(nodeName);
  const operations = getNodeOperations(node.type);
  const results: OperationResult[] = [];

  for (const operation of operations) {
    const testData = generateTestData(node.type, operation);

    try {
      const startTime = Date.now();
      const response = await executeOperation(node, operation, testData);

      results.push({
        operation,
        success: true,
        responseTime: Date.now() - startTime,
        responseStatus: response.status,
        dataValid: validateResponseData(response.data, operation)
      });
    } catch (error) {
      results.push({
        operation,
        success: false,
        error: error.,
        : (error)
      });
    }
  }

   results;
}


 ():  {
   testDataMap = {
    : {
      : {
        : ,
        : 
      },
      : {
        : ,
        : ,
        : 
      }
    },
    : {
      : {
        : ,
        : ,
        : [[, ,  ().()]]
      },
      : {
        : ,
        : 
      }
    },
    : {
      : {
        : ,
        : ,
        : ,
        : 
      },
      : {
        : ,
        : { :  }
      }
    }
  };

   testDataMap[nodeType]?.[operation] || {};
}

---

Authentication Testing

OAuth2 Flow Testing

// Test OAuth2 authentication
async function testOAuth2Authentication(credentials: any): Promise<OAuth2Result> {
  const result: OAuth2Result = {
    tokenValid: false,
    refreshWorking: false,
    scopes: [],
    expiresIn: 0
  };

  // Test current token
  const tokenTest = await testAccessToken(credentials.accessToken);
  result.tokenValid = tokenTest.valid;
  result.scopes = tokenTest.scopes;

  // Check expiration
  if (credentials.expiresAt) {
    result.expiresIn = new Date(credentials.expiresAt).getTime() - Date.now();
    result.expiresSoon = result.expiresIn < 3600000; // Less than 1 hour
  }

  // Test refresh token
  if (credentials.refreshToken) {
    try {
      const newToken = await refreshOAuthToken(credentials);
      result. = !!newToken;
    }  (error) {
      result. = error.;
    }
  }

   result;
}


  (): <> {
   currentScopes =  (credentials.);
   missingScopes = requiredScopes.( !currentScopes.(s));

   {
    : missingScopes. === ,
    currentScopes,
    missingScopes,
    : missingScopes. > 
      ? 
      : 
  };
}

API Key Testing

// Test API key validity
async function testAPIKey(integration: string, apiKey: string): Promise<APIKeyResult> {
  const endpoints = {
    'sendgrid': 'https://api.sendgrid.com/v3/user/profile',
    'mailchimp': 'https://us1.api.mailchimp.com/3.0/ping',
    'airtable': 'https://api.airtable.com/v0/meta/whoami'
  };

  const endpoint = endpoints[integration];
  if (!endpoint) {
    return { valid: false, error: 'Unknown integration' };
  }

  try {
    const response = await fetch(endpoint, {
      headers: { 'Authorization': `Bearer ${apiKey}` }
    });

    return {
      valid: response.status === 200,
      status: response.status,
      rateLimit: extractRateLimitInfo(response.headers)
    };
  } catch (error) {
    return { valid: false, error: error.message };
  }
}

---

Rate Limit Testing

// Test rate limit handling
async function testRateLimits(nodeName: string, requestCount: number): Promise<RateLimitResult> {
  const results: RequestResult[] = [];
  let rateLimitHit = false;
  let retryAfter = 0;

  for (let i = 0; i < requestCount; i++) {
    const startTime = Date.now();
    const response = await makeRequest(nodeName);

    results.push({
      requestNumber: i + 1,
      status: response.status,
      responseTime: Date.now() - startTime,
      rateLimitRemaining: response.headers['x-ratelimit-remaining'],
      rateLimitLimit: response.headers['x-ratelimit-limit']
    });

    if (response.status === 429) {
      rateLimitHit = true;
      retryAfter = parseInt(response.headers['retry-after'] || '60');
      break;
    }

    
     ();
  }

   {
    : results.,
    rateLimitHit,
    retryAfter,
    results,
    : rateLimitHit
      ? 
      : 
  };
}


 ():  {
   {
    : headers.(),
    : headers.(),
    : headers.(),
    : headers.()
  };
}

---

Error Handling Testing

// Test error scenarios
async function testErrorScenarios(nodeName: string): Promise<ErrorTestResult[]> {
  const scenarios = [
    { name: 'Invalid credentials', modify: { credentials: null } },
    { name: 'Invalid endpoint', modify: { url: 'https://invalid.example.com' } },
    { name: 'Timeout', modify: { timeout: 1 } },
    { name: 'Invalid data', modify: { data: { invalid: true } } },
    { name: 'Not found', modify: { resourceId: 'nonexistent-123' } },
    { name: 'Permission denied', modify: { scope: 'read-only' } }
  ];

  const results: ErrorTestResult[] = [];

  for (const scenario of scenarios) {
    try {
      const response = await executeWithModification(nodeName, scenario.modify);

      results.({
        : scenario.,
        : response. >= ,
        : response.,
        : response.?.?.,
        : response.?. > 
      });
    }  (error) {
      results.({
        : scenario.,
        : ,
        : ,
        : error..,
        : error.
      });
    }
  }

   results;
}


 ():  {
   (error. ===  || error. === )  ;
   (error. === )  ;
   (error. === )  ;
   (error. >= )  ;
   (error. === )  ;
   (error. === )  ;
   ;
}

---

Integration-Specific Patterns

Slack Integration

const slackTestPatterns = {
  // Test message posting
  testPostMessage: async (credentials) => {
    return await fetch('https://slack.com/api/chat.postMessage', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${credentials.accessToken}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        channel: 'C123456',
        text: 'Integration test message'
      })
    });
  },

  // Test file upload
  testFileUpload: async (credentials) => {
    const formData = new FormData();
    formData.append('channels', 'C123456');
    formData.append('content', 'Test file content');
    formData.append('filename', 'test.txt');

    return await fetch('https://slack.com/api/files.upload', {
      method: 'POST',
      headers: { 'Authorization': `Bearer ${credentials.accessToken}` },
      : formData
    });
  },

  
  : [, , ]
};

Google Sheets Integration

const googleSheetsTestPatterns = {
  // Test read operation
  testReadRows: async (credentials, spreadsheetId) => {
    return await fetch(
      `https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}/values/Sheet1!A1:Z10`,
      { headers: { 'Authorization': `Bearer ${credentials.accessToken}` } }
    );
  },

  // Test append operation
  testAppendRow: async (credentials, spreadsheetId, values) => {
    return await fetch(
      `https://sheets.googleapis.com/v4/spreadsheets/${spreadsheetId}/values/Sheet1!A:Z:append?valueInputOption=USER_ENTERED`,
      {
        method: 'POST',
        headers: {
          'Authorization': `Bearer ${credentials.accessToken}`,
          'Content-Type': 'application/json'
        },
        body: JSON.stringify({ values: [values] })
      }
    );
  },

  // Required scopes
  requiredScopes: ['https://www.googleapis.com/auth/spreadsheets']
};

---

Test Report Template

# Integration Test Report

## Summary
| Integration | Status | Auth | Operations | Errors |
|-------------|--------|------|------------|--------|
| Slack | PASS | OK | 4/4 | 0 |
| Google Sheets | WARN | Expiring | 3/3 | 0 |
| Jira | FAIL | OK | 2/4 | 2 |

## Authentication Status
- Slack: OAuth2 valid, expires in 28 days
- Google Sheets: OAuth2 expires in 2 hours - REFRESH RECOMMENDED
- Jira: API Key valid

## Rate Limit Status
| Integration | Limit | Used | Remaining |
|-------------|-------|------|-----------|
| Slack | 50/min | 12 | 38 |
| Google Sheets | 100/min | 45 | 55 |
| Jira | 100/min | 8 | 92 |

## Failed Operations
### Jira: Transition Issue
- Error: Invalid transition for current state
- Fix: Check workflow transitions in Jira

## Recommendations
1. Refresh Google Sheets OAuth token before expiration
2. Fix Jira workflow transition logic

---

Related Skills

• n8n-workflow-testing-fundamentals
• n8n-security-testing
• api-testing-patterns

---

Remember

n8n integrates with 400+ services, each with unique authentication, rate limits, and API quirks. Testing requires:

• Connectivity verification
• Authentication validation (OAuth refresh, API key expiry)
• Operation testing with realistic data
• Rate limit awareness
• Error handling verification

With Agents: Use n8n-integration-test for comprehensive integration testing. Coordinate with n8n-workflow-executor to test integrations in context.