n8n-bookstack-agent-tool/dist/src/test/rate-limiting-test.js

Comprehensive BookStack API integration tool for n8n AI Agent with MCP framework compatibility

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.RateLimitingTester = void 0;
const index_js_1 = require("../index.js");
class RateLimitingTester {
    constructor() {
        const config = {
            baseUrl: 'https://wiki.l7cloud.io',
            authType: 'bearer',
            token: 'EnRkbVwqzNSyLaVo7olU8Wx8umGznKuE',
            tokenSecret: 'TyaJ0JHAenwRIgScmsffrCeSIlon4fZ2',
            timeout: 30000,
            retryAttempts: 3,
            retryDelay: 1000
        };
        this.tool = new index_js_1.BookStackN8nTool(config);
    }
    async runRateLimitingTests() {
        console.log('\n⏱️  RATE LIMITING BEHAVIOR TESTS');
        console.log('===============================');
        await this.testBurstRequests();
        await this.testSustainedLoad();
        await this.testRetryBehavior();
        console.log('\n✅ Rate limiting tests completed');
    }
    async testBurstRequests() {
        console.log('\n🚀 Testing burst request handling...');
        const burstSize = 10;
        const promises = [];
        const startTime = Date.now();
        for (let i = 0; i < burstSize; i++) {
            promises.push(this.tool.execCommand('listBooks', { count: 1 })
                .then(() => ({ success: true, index: i }))
                .catch(error => ({ success: false, index: i, error: error.message })));
        }
        try {
            const results = await Promise.all(promises);
            const endTime = Date.now();
            const duration = endTime - startTime;
            const successful = results.filter(r => r.success).length;
            const failed = results.filter(r => !r.success).length;
            console.log(`  📊 Burst Results: ${successful}/${burstSize} successful in ${duration}ms`);
            console.log(`  ✅ Success Rate: ${(successful / burstSize * 100).toFixed(1)}%`);
            if (failed > 0) {
                console.log(`  ⚠️  Failed Requests: ${failed}`);
                const rateLimitErrors = results.filter(r => !r.success && r.error?.includes('rate limit')).length;
                if (rateLimitErrors > 0) {
                    console.log(`  🚫 Rate Limit Errors: ${rateLimitErrors}`);
                }
            }
        }
        catch (error) {
            console.log(`  ❌ Burst test failed: ${error.message}`);
        }
    }
    async testSustainedLoad() {
        console.log('\n⏳ Testing sustained load handling...');
        const requestCount = 20;
        const delayBetweenRequests = 500; // 500ms between requests
        let successCount = 0;
        let errorCount = 0;
        let rateLimitCount = 0;
        const startTime = Date.now();
        for (let i = 0; i < requestCount; i++) {
            try {
                await this.tool.execCommand('listBooks', { count: 1 });
                successCount++;
                console.log(`    Request ${i + 1}/${requestCount}: ✅ Success`);
            }
            catch (error) {
                errorCount++;
                const errorMessage = error.message;
                if (errorMessage.toLowerCase().includes('rate limit') || errorMessage.toLowerCase().includes('429')) {
                    rateLimitCount++;
                    console.log(`    Request ${i + 1}/${requestCount}: 🚫 Rate Limited`);
                }
                else {
                    console.log(`    Request ${i + 1}/${requestCount}: ❌ Error - ${errorMessage}`);
                }
            }
            if (i < requestCount - 1) {
                await new Promise(resolve => setTimeout(resolve, delayBetweenRequests));
            }
        }
        const endTime = Date.now();
        const totalDuration = endTime - startTime;
        console.log(`\n  📊 Sustained Load Results:`);
        console.log(`    Total Requests: ${requestCount}`);
        console.log(`    Successful: ${successCount} (${(successCount / requestCount * 100).toFixed(1)}%)`);
        console.log(`    Errors: ${errorCount} (${(errorCount / requestCount * 100).toFixed(1)}%)`);
        console.log(`    Rate Limited: ${rateLimitCount} (${(rateLimitCount / requestCount * 100).toFixed(1)}%)`);
        console.log(`    Total Duration: ${totalDuration}ms`);
        console.log(`    Average Request Time: ${(totalDuration / requestCount).toFixed(0)}ms`);
    }
    async testRetryBehavior() {
        console.log('\n🔄 Testing retry behavior...');
        try {
            console.log('  Testing retry mechanism with potential rate limiting...');
            const retryTestPromises = [];
            for (let i = 0; i < 5; i++) {
                retryTestPromises.push(this.tool.execCommand('listBooks', { count: 1 })
                    .then(() => ({ success: true, attempt: i }))
                    .catch(error => ({ success: false, attempt: i, error: error.message })));
            }
            const retryResults = await Promise.all(retryTestPromises);
            const retrySuccessful = retryResults.filter(r => r.success).length;
            console.log(`    ✅ Retry Test: ${retrySuccessful}/5 requests successful`);
            const retryErrors = retryResults.filter(r => !r.success);
            if (retryErrors.length > 0) {
                console.log(`    ⚠️  Retry Failures: ${retryErrors.length}`);
                retryErrors.forEach(error => {
                    console.log(`      - Attempt ${error.attempt}: ${error.error || 'Unknown error'}`);
                });
            }
        }
        catch (error) {
            console.log(`    ❌ Retry test failed: ${error.message}`);
        }
    }
}
exports.RateLimitingTester = RateLimitingTester;
if (require.main === module) {
    const tester = new RateLimitingTester();
    tester.runRateLimitingTests().catch(console.error);
}
//# sourceMappingURL=rate-limiting-test.js.map