koa-classic-server 1.2.0 → 2.0.0

package/__tests__/performance.test.js

@@ -0,0 +1,301 @@
+/**
+ * Performance Benchmark Tests
+ *
+ * These tests measure current performance to establish a baseline.
+ * After optimizations, run these tests again to measure improvements.
+ *
+ * Usage:
+ *   npm run test:performance
+ *
+ * To save results:
+ *   npm run test:performance > benchmark-results-v1.2.0.txt
+ */
+
+const Koa = require('koa');
+const supertest = require('supertest');
+const koaClassicServer = require('../index.cjs');
+const path = require('path');
+const fs = require('fs');
+
+const BENCHMARK_DIR = path.join(__dirname, '../benchmark-data');
+
+// Check if benchmark data exists
+if (!fs.existsSync(BENCHMARK_DIR)) {
+    console.error('\n❌ Benchmark data not found!');
+    console.error('Please run: node scripts/setup-benchmark.js\n');
+    process.exit(1);
+}
+
+// Helper to measure execution time
+function measureTime(fn) {
+    const start = process.hrtime.bigint();
+    const result = fn();
+    const end = process.hrtime.bigint();
+    const durationMs = Number(end - start) / 1000000; // Convert to ms
+    return { result, durationMs };
+}
+
+async function measureTimeAsync(fn) {
+    const start = process.hrtime.bigint();
+    const result = await fn();
+    const end = process.hrtime.bigint();
+    const durationMs = Number(end - start) / 1000000;
+    return { result, durationMs };
+}
+
+// Helper to run multiple iterations and get statistics
+async function benchmark(name, fn, iterations = 10) {
+    const times = [];
+
+    for (let i = 0; i < iterations; i++) {
+        const { durationMs } = await measureTimeAsync(fn);
+        times.push(durationMs);
+    }
+
+    const avg = times.reduce((a, b) => a + b, 0) / times.length;
+    const min = Math.min(...times);
+    const max = Math.max(...times);
+    const median = times.sort((a, b) => a - b)[Math.floor(times.length / 2)];
+
+    return { name, avg, min, max, median, times };
+}
+
+describe('Performance Benchmarks - BASELINE (v1.2.0)', () => {
+    let app;
+    let server;
+    let request;
+
+    beforeAll(() => {
+        app = new Koa();
+        app.use(koaClassicServer(BENCHMARK_DIR));
+        server = app.listen();
+        request = supertest(server);
+    });
+
+    afterAll(() => {
+        server.close();
+    });
+
+    describe('File Serving Performance', () => {
+        test('Benchmark: Small file (1KB) - 100 iterations', async () => {
+            const stats = await benchmark(
+                'Small file (1KB)',
+                async () => {
+                    const res = await request.get('/small-files/file-1.txt');
+                    expect(res.status).toBe(200);
+                },
+                100
+            );
+
+            console.log('\n📊 Small File (1KB) Benchmark:');
+            console.log(`   Average: ${stats.avg.toFixed(2)}ms`);
+            console.log(`   Median:  ${stats.median.toFixed(2)}ms`);
+            console.log(`   Min:     ${stats.min.toFixed(2)}ms`);
+            console.log(`   Max:     ${stats.max.toFixed(2)}ms`);
+
+            expect(stats.avg).toBeLessThan(50); // Should be fast
+        }, 30000);
+
+        test('Benchmark: Medium file (100KB) - 50 iterations', async () => {
+            const stats = await benchmark(
+                'Medium file (100KB)',
+                async () => {
+                    const res = await request.get('/medium-files/file-1.txt');
+                    expect(res.status).toBe(200);
+                },
+                50
+            );
+
+            console.log('\n📊 Medium File (100KB) Benchmark:');
+            console.log(`   Average: ${stats.avg.toFixed(2)}ms`);
+            console.log(`   Median:  ${stats.median.toFixed(2)}ms`);
+            console.log(`   Min:     ${stats.min.toFixed(2)}ms`);
+            console.log(`   Max:     ${stats.max.toFixed(2)}ms`);
+
+            expect(stats.avg).toBeLessThan(100);
+        }, 30000);
+
+        test('Benchmark: Large file (1MB) - 20 iterations', async () => {
+            const stats = await benchmark(
+                'Large file (1MB)',
+                async () => {
+                    const res = await request.get('/large-files/file-1.txt');
+                    expect(res.status).toBe(200);
+                },
+                20
+            );
+
+            console.log('\n📊 Large File (1MB) Benchmark:');
+            console.log(`   Average: ${stats.avg.toFixed(2)}ms`);
+            console.log(`   Median:  ${stats.median.toFixed(2)}ms`);
+            console.log(`   Min:     ${stats.min.toFixed(2)}ms`);
+            console.log(`   Max:     ${stats.max.toFixed(2)}ms`);
+
+            expect(stats.avg).toBeLessThan(500);
+        }, 30000);
+    });
+
+    describe('Directory Listing Performance', () => {
+        test('Benchmark: Small directory (100 files) - 50 iterations', async () => {
+            const stats = await benchmark(
+                'Directory listing (100 files)',
+                async () => {
+                    const res = await request.get('/small-files/');
+                    expect(res.status).toBe(200);
+                    expect(res.text).toContain('file-1.txt');
+                },
+                50
+            );
+
+            console.log('\n📊 Small Directory (100 files) Benchmark:');
+            console.log(`   Average: ${stats.avg.toFixed(2)}ms`);
+            console.log(`   Median:  ${stats.median.toFixed(2)}ms`);
+            console.log(`   Min:     ${stats.min.toFixed(2)}ms`);
+            console.log(`   Max:     ${stats.max.toFixed(2)}ms`);
+        }, 30000);
+
+        test('Benchmark: Large directory (1,000 files) - 20 iterations', async () => {
+            const stats = await benchmark(
+                'Directory listing (1,000 files)',
+                async () => {
+                    const res = await request.get('/large-directory/');
+                    expect(res.status).toBe(200);
+                    expect(res.text).toContain('item-0001.txt');
+                },
+                20
+            );
+
+            console.log('\n📊 Large Directory (1,000 files) Benchmark:');
+            console.log(`   Average: ${stats.avg.toFixed(2)}ms`);
+            console.log(`   Median:  ${stats.median.toFixed(2)}ms`);
+            console.log(`   Min:     ${stats.min.toFixed(2)}ms`);
+            console.log(`   Max:     ${stats.max.toFixed(2)}ms`);
+
+            // This is expected to be slow with current sync implementation
+            console.log(`   ⚠️  WARNING: This will be MUCH faster after async optimization`);
+        }, 60000);
+
+        test('Benchmark: Very large directory (10,000 files) - 5 iterations', async () => {
+            const stats = await benchmark(
+                'Directory listing (10,000 files)',
+                async () => {
+                    const res = await request.get('/very-large-directory/');
+                    expect(res.status).toBe(200);
+                    expect(res.text).toContain('item-00001.txt');
+                },
+                5
+            );
+
+            console.log('\n📊 Very Large Directory (10,000 files) Benchmark:');
+            console.log(`   Average: ${stats.avg.toFixed(2)}ms`);
+            console.log(`   Median:  ${stats.median.toFixed(2)}ms`);
+            console.log(`   Min:     ${stats.min.toFixed(2)}ms`);
+            console.log(`   Max:     ${stats.max.toFixed(2)}ms`);
+            console.log(`   ⚠️  WARNING: Event loop BLOCKED during this operation!`);
+            console.log(`   ⚠️  Expected to drop to ~${(stats.avg * 0.3).toFixed(2)}ms after optimization`);
+        }, 120000);
+    });
+
+    describe('Concurrent Request Performance', () => {
+        test('Benchmark: 10 concurrent small file requests', async () => {
+            const start = process.hrtime.bigint();
+
+            const promises = Array.from({ length: 10 }, (_, i) =>
+                request.get(`/small-files/file-${i + 1}.txt`)
+            );
+
+            const results = await Promise.all(promises);
+
+            const end = process.hrtime.bigint();
+            const totalTime = Number(end - start) / 1000000;
+
+            console.log('\n📊 10 Concurrent Small Files:');
+            console.log(`   Total time: ${totalTime.toFixed(2)}ms`);
+            console.log(`   Avg per request: ${(totalTime / 10).toFixed(2)}ms`);
+
+            results.forEach(res => expect(res.status).toBe(200));
+        }, 10000);
+
+        test('Benchmark: 5 concurrent directory listings (100 files each)', async () => {
+            const start = process.hrtime.bigint();
+
+            const promises = Array.from({ length: 5 }, () =>
+                request.get('/small-files/')
+            );
+
+            const results = await Promise.all(promises);
+
+            const end = process.hrtime.bigint();
+            const totalTime = Number(end - start) / 1000000;
+
+            console.log('\n📊 5 Concurrent Directory Listings (100 files):');
+            console.log(`   Total time: ${totalTime.toFixed(2)}ms`);
+            console.log(`   Avg per request: ${(totalTime / 5).toFixed(2)}ms`);
+            console.log(`   ⚠️  With current sync code, these run SEQUENTIALLY`);
+            console.log(`   ⚠️  After async optimization, will run in PARALLEL`);
+
+            results.forEach(res => expect(res.status).toBe(200));
+        }, 30000);
+    });
+
+    describe('404 Not Found Performance', () => {
+        test('Benchmark: Non-existent file - 50 iterations', async () => {
+            const stats = await benchmark(
+                '404 Not Found',
+                async () => {
+                    const res = await request.get('/does-not-exist-12345.txt');
+                    expect(res.status).toBe(404);
+                },
+                50
+            );
+
+            console.log('\n📊 404 Not Found Benchmark:');
+            console.log(`   Average: ${stats.avg.toFixed(2)}ms`);
+            console.log(`   Median:  ${stats.median.toFixed(2)}ms`);
+            console.log(`   Min:     ${stats.min.toFixed(2)}ms`);
+            console.log(`   Max:     ${stats.max.toFixed(2)}ms`);
+        }, 10000);
+    });
+
+    describe('Memory Usage (Informational)', () => {
+        test('Memory usage during large directory listing', async () => {
+            // Force garbage collection if available
+            if (global.gc) {
+                global.gc();
+            }
+
+            const memBefore = process.memoryUsage();
+
+            // Request large directory
+            const res = await request.get('/very-large-directory/');
+            expect(res.status).toBe(200);
+
+            const memAfter = process.memoryUsage();
+
+            const heapUsedDiff = (memAfter.heapUsed - memBefore.heapUsed) / 1024 / 1024;
+            const externalDiff = (memAfter.external - memBefore.external) / 1024 / 1024;
+
+            console.log('\n📊 Memory Usage (10,000 files directory):');
+            console.log(`   Heap used increase: ${heapUsedDiff.toFixed(2)} MB`);
+            console.log(`   External increase: ${externalDiff.toFixed(2)} MB`);
+            console.log(`   Response size: ${(res.text.length / 1024 / 1024).toFixed(2)} MB`);
+            console.log(`   ⚠️  Expected to reduce by ~30-40% after optimization`);
+        }, 30000);
+    });
+});
+
+// Summary report
+afterAll(() => {
+    console.log('\n' + '='.repeat(70));
+    console.log('📋 BASELINE BENCHMARK SUMMARY');
+    console.log('='.repeat(70));
+    console.log('\nThese results represent the CURRENT performance (v1.2.0)');
+    console.log('After implementing optimizations, run this test again to see improvements.\n');
+    console.log('Expected improvements after optimization:');
+    console.log('  ✓ Small files:        10-20% faster (async operations)');
+    console.log('  ✓ Large directories:  50-70% faster (async + array join)');
+    console.log('  ✓ Concurrent requests: 5-10x faster (non-blocking event loop)');
+    console.log('  ✓ Memory usage:       30-40% reduction (array join vs concatenation)');
+    console.log('  ✓ With HTTP caching:  80-95% faster (304 responses)');
+    console.log('='.repeat(70) + '\n');
+});

package/benchmark-results-baseline-v1.2.0.txt

@@ -0,0 +1,354 @@
+
+> koa-classic-server@1.2.0 test:performance
+> jest __tests__/performance.test.js --runInBand
+
+  console.log
+    
+    📊 Small File (1KB) Benchmark:
+
+      at Object.log (__tests__/performance.test.js:90:21)
+
+  console.log
+       Average: 2.93ms
+
+      at Object.log (__tests__/performance.test.js:91:21)
+
+  console.log
+       Median:  2.54ms
+
+      at Object.log (__tests__/performance.test.js:92:21)
+
+  console.log
+       Min:     1.99ms
+
+      at Object.log (__tests__/performance.test.js:93:21)
+
+  console.log
+       Max:     26.87ms
+
+      at Object.log (__tests__/performance.test.js:94:21)
+
+  console.log
+    
+    📊 Medium File (100KB) Benchmark:
+
+      at Object.log (__tests__/performance.test.js:109:21)
+
+  console.log
+       Average: 3.59ms
+
+      at Object.log (__tests__/performance.test.js:110:21)
+
+  console.log
+       Median:  3.51ms
+
+      at Object.log (__tests__/performance.test.js:111:21)
+
+  console.log
+       Min:     2.46ms
+
+      at Object.log (__tests__/performance.test.js:112:21)
+
+  console.log
+       Max:     8.36ms
+
+      at Object.log (__tests__/performance.test.js:113:21)
+
+  console.log
+    
+    📊 Large File (1MB) Benchmark:
+
+      at Object.log (__tests__/performance.test.js:128:21)
+
+  console.log
+       Average: 9.03ms
+
+      at Object.log (__tests__/performance.test.js:129:21)
+
+  console.log
+       Median:  8.35ms
+
+      at Object.log (__tests__/performance.test.js:130:21)
+
+  console.log
+       Min:     5.46ms
+
+      at Object.log (__tests__/performance.test.js:131:21)
+
+  console.log
+       Max:     13.81ms
+
+      at Object.log (__tests__/performance.test.js:132:21)
+
+  console.log
+    
+    📊 Small Directory (100 files) Benchmark:
+
+      at Object.log (__tests__/performance.test.js:150:21)
+
+  console.log
+       Average: 2.65ms
+
+      at Object.log (__tests__/performance.test.js:151:21)
+
+  console.log
+       Median:  2.54ms
+
+      at Object.log (__tests__/performance.test.js:152:21)
+
+  console.log
+       Min:     2.22ms
+
+      at Object.log (__tests__/performance.test.js:153:21)
+
+  console.log
+       Max:     4.69ms
+
+      at Object.log (__tests__/performance.test.js:154:21)
+
+  console.log
+    
+    📊 Large Directory (1,000 files) Benchmark:
+
+      at Object.log (__tests__/performance.test.js:168:21)
+
+  console.log
+       Average: 9.23ms
+
+      at Object.log (__tests__/performance.test.js:169:21)
+
+  console.log
+       Median:  9.14ms
+
+      at Object.log (__tests__/performance.test.js:170:21)
+
+  console.log
+       Min:     8.26ms
+
+      at Object.log (__tests__/performance.test.js:171:21)
+
+  console.log
+       Max:     11.64ms
+
+      at Object.log (__tests__/performance.test.js:172:21)
+
+  console.log
+       ⚠️  WARNING: This will be MUCH faster after async optimization
+
+      at Object.log (__tests__/performance.test.js:175:21)
+
+  console.log
+    
+    📊 Very Large Directory (10,000 files) Benchmark:
+
+      at Object.log (__tests__/performance.test.js:189:21)
+
+  console.log
+       Average: 102.37ms
+
+      at Object.log (__tests__/performance.test.js:190:21)
+
+  console.log
+       Median:  95.13ms
+
+      at Object.log (__tests__/performance.test.js:191:21)
+
+  console.log
+       Min:     90.91ms
+
+      at Object.log (__tests__/performance.test.js:192:21)
+
+  console.log
+       Max:     120.85ms
+
+      at Object.log (__tests__/performance.test.js:193:21)
+
+  console.log
+       ⚠️  WARNING: Event loop BLOCKED during this operation!
+
+      at Object.log (__tests__/performance.test.js:194:21)
+
+  console.log
+       ⚠️  Expected to drop to ~30.71ms after optimization
+
+      at Object.log (__tests__/performance.test.js:195:21)
+
+  console.log
+    
+    📊 10 Concurrent Small Files:
+
+      at Object.log (__tests__/performance.test.js:212:21)
+
+  console.log
+       Total time: 15.50ms
+
+      at Object.log (__tests__/performance.test.js:213:21)
+
+  console.log
+       Avg per request: 1.55ms
+
+      at Object.log (__tests__/performance.test.js:214:21)
+
+  console.log
+    
+    📊 5 Concurrent Directory Listings (100 files):
+
+      at Object.log (__tests__/performance.test.js:231:21)
+
+  console.log
+       Total time: 11.30ms
+
+      at Object.log (__tests__/performance.test.js:232:21)
+
+  console.log
+       Avg per request: 2.26ms
+
+      at Object.log (__tests__/performance.test.js:233:21)
+
+  console.log
+       ⚠️  With current sync code, these run SEQUENTIALLY
+
+      at Object.log (__tests__/performance.test.js:234:21)
+
+  console.log
+       ⚠️  After async optimization, will run in PARALLEL
+
+      at Object.log (__tests__/performance.test.js:235:21)
+
+  console.log
+    
+    📊 404 Not Found Benchmark:
+
+      at Object.log (__tests__/performance.test.js:252:21)
+
+  console.log
+       Average: 1.26ms
+
+      at Object.log (__tests__/performance.test.js:253:21)
+
+  console.log
+       Median:  1.24ms
+
+      at Object.log (__tests__/performance.test.js:254:21)
+
+  console.log
+       Min:     1.05ms
+
+      at Object.log (__tests__/performance.test.js:255:21)
+
+  console.log
+       Max:     2.17ms
+
+      at Object.log (__tests__/performance.test.js:256:21)
+
+  console.log
+    
+    📊 Memory Usage (10,000 files directory):
+
+      at Object.log (__tests__/performance.test.js:278:21)
+
+  console.log
+       Heap used increase: 1.16 MB
+
+      at Object.log (__tests__/performance.test.js:279:21)
+
+  console.log
+       External increase: 2.57 MB
+
+      at Object.log (__tests__/performance.test.js:280:21)
+
+  console.log
+       Response size: 1.29 MB
+
+      at Object.log (__tests__/performance.test.js:281:21)
+
+  console.log
+       ⚠️  Expected to reduce by ~30-40% after optimization
+
+      at Object.log (__tests__/performance.test.js:282:21)
+
+  console.log
+    
+    ======================================================================
+
+      at Object.log (__tests__/performance.test.js:289:13)
+
+  console.log
+    📋 BASELINE BENCHMARK SUMMARY
+
+      at Object.log (__tests__/performance.test.js:290:13)
+
+  console.log
+    ======================================================================
+
+      at Object.log (__tests__/performance.test.js:291:13)
+
+  console.log
+    
+    These results represent the CURRENT performance (v1.2.0)
+
+      at Object.log (__tests__/performance.test.js:292:13)
+
+  console.log
+    After implementing optimizations, run this test again to see improvements.
+
+      at Object.log (__tests__/performance.test.js:293:13)
+
+  console.log
+    Expected improvements after optimization:
+
+      at Object.log (__tests__/performance.test.js:294:13)
+
+  console.log
+      ✓ Small files:        10-20% faster (async operations)
+
+      at Object.log (__tests__/performance.test.js:295:13)
+
+  console.log
+      ✓ Large directories:  50-70% faster (async + array join)
+
+      at Object.log (__tests__/performance.test.js:296:13)
+
+  console.log
+      ✓ Concurrent requests: 5-10x faster (non-blocking event loop)
+
+      at Object.log (__tests__/performance.test.js:297:13)
+
+  console.log
+      ✓ Memory usage:       30-40% reduction (array join vs concatenation)
+
+      at Object.log (__tests__/performance.test.js:298:13)
+
+  console.log
+      ✓ With HTTP caching:  80-95% faster (304 responses)
+
+      at Object.log (__tests__/performance.test.js:299:13)
+
+  console.log
+    ======================================================================
+
+      at Object.log (__tests__/performance.test.js:300:13)
+
+PASS __tests__/performance.test.js
+  Performance Benchmarks - BASELINE (v1.2.0)
+    File Serving Performance
+      ✓ Benchmark: Small file (1KB) - 100 iterations (318 ms)
+      ✓ Benchmark: Medium file (100KB) - 50 iterations (184 ms)
+      ✓ Benchmark: Large file (1MB) - 20 iterations (183 ms)
+    Directory Listing Performance
+      ✓ Benchmark: Small directory (100 files) - 50 iterations (135 ms)
+      ✓ Benchmark: Large directory (1,000 files) - 20 iterations (188 ms)
+      ✓ Benchmark: Very large directory (10,000 files) - 5 iterations (515 ms)
+    Concurrent Request Performance
+      ✓ Benchmark: 10 concurrent small file requests (18 ms)
+      ✓ Benchmark: 5 concurrent directory listings (100 files each) (14 ms)
+    404 Not Found Performance
+      ✓ Benchmark: Non-existent file - 50 iterations (66 ms)
+    Memory Usage (Informational)
+      ✓ Memory usage during large directory listing (88 ms)
+
+Test Suites: 1 passed, 1 total
+Tests:       10 passed, 10 total
+Snapshots:   0 total
+Time:        3.227 s, estimated 4 s
+Ran all test suites matching /__tests__\/performance.test.js/i.