@joystick.js/db-canary 0.0.0-canary.2300 → 0.0.0-canary.2302

package/tests/performance/bulk_insert_benchmarks.test.js

@@ -112,7 +112,7 @@ test.beforeEach(async () => {
   if (existsSync(TEST_DB_PATH)) {
     rmSync(TEST_DB_PATH, { recursive: true, force: true });
   }
-  initialize_database(TEST_DB_PATH);
+  await initialize_database(TEST_DB_PATH);
 });
 
 /**
@@ -207,7 +207,7 @@ test('benchmark: 1K documents - optimized vs original', async t => {
   
   // Clean up for optimized test
   await cleanup_database(true);
-  initialize_database(TEST_DB_PATH);
+  await initialize_database(TEST_DB_PATH);
   
   // Test optimized implementation
   const optimized_result = await bulk_insert_with_metrics(TEST_DATABASE, TEST_COLLECTION, documents);
@@ -377,14 +377,14 @@ test('benchmark: document size impact - small vs medium vs large', async t => {
   const small_result = await bulk_insert_with_metrics(TEST_DATABASE, TEST_COLLECTION, small_docs);
   
   await cleanup_database(true);
-  initialize_database(TEST_DB_PATH);
+  await initialize_database(TEST_DB_PATH);
   
   // Medium documents
   const medium_docs = generate_benchmark_documents(document_count, { document_size: 'medium' });
   const medium_result = await bulk_insert_with_metrics(TEST_DATABASE, TEST_COLLECTION, medium_docs);
   
   await cleanup_database(true);
-  initialize_database(TEST_DB_PATH);
+  await initialize_database(TEST_DB_PATH);
   
   // Large documents
   const large_docs = generate_benchmark_documents(document_count, { document_size: 'large' });
@@ -415,7 +415,7 @@ test('benchmark: memory efficiency with streaming vs batch processing', async t
   });
   
   await cleanup_database(true);
-  initialize_database(TEST_DB_PATH);
+  await initialize_database(TEST_DB_PATH);
   
   // Test batch processing
   const batch_result = await bulk_insert_with_metrics(TEST_DATABASE, TEST_COLLECTION, documents, {
@@ -448,7 +448,7 @@ test('benchmark: optimization features impact', async t => {
   });
   
   await cleanup_database(true);
-  initialize_database(TEST_DB_PATH);
+  await initialize_database(TEST_DB_PATH);
   
   // Test with all optimizations enabled
   const optimized_result = await bulk_insert_with_metrics(TEST_DATABASE, TEST_COLLECTION, documents, {
@@ -540,7 +540,7 @@ test('benchmark: performance regression detection', async t => {
     // Clean up for next iteration
     if (i < iterations - 1) {
       await cleanup_database(true);
-      initialize_database(TEST_DB_PATH);
+      await initialize_database(TEST_DB_PATH);
     }
   }
   

package/tests/performance/bulk_insert_enterprise_scale_test.js

@@ -8,6 +8,7 @@ import { rmSync, existsSync } from 'fs';
 import { initialize_database, cleanup_database } from '../../src/server/lib/query_engine.js';
 import { bulk_insert_with_metrics } from '../../src/server/lib/bulk_insert_optimizer.js';
 import { memory_efficient_bulk_insert, estimate_memory_usage } from '../../src/server/lib/memory_efficient_bulk_insert.js';
+import { wait_for_condition } from '../../test_helpers.js';
 
 const TEST_DB_PATH = './test_data/bulk_enterprise_test';
 const TEST_DATABASE = 'enterprise_db';
@@ -45,12 +46,33 @@ const enhanced_enterprise_cleanup = async () => {
     if (global.gc) {
       for (let i = 0; i < 10; i++) {
         global.gc();
-        await new Promise(resolve => setTimeout(resolve, 50));
+        // Brief pause between GC cycles for memory stabilization
+        await wait_for_condition(
+          () => true, // Just a short pause
+          100,
+          25,
+          'garbage collection pause'
+        );
       }
     }
     
-    // Extended wait for LMDB resources to be fully released
-    await new Promise(resolve => setTimeout(resolve, 1000));
+    // Wait for LMDB resources to be fully released with condition check
+    await wait_for_condition(
+      async () => {
+        try {
+          // Check if database path is accessible (indicates cleanup complete)
+          if (existsSync(TEST_DB_PATH)) {
+            return false; // Still exists, not fully cleaned
+          }
+          return true; // Path cleaned up
+        } catch {
+          return true; // Error accessing means likely cleaned up
+        }
+      },
+      5000,
+      100,
+      'LMDB resource cleanup'
+    );
     
     // Additional system-level cleanup
     if (process.platform !== 'win32') {
@@ -75,7 +97,13 @@ test.beforeEach(async () => {
   if (global.gc) {
     for (let i = 0; i < 5; i++) {
       global.gc();
-      await new Promise(resolve => setTimeout(resolve, 100));
+      // Brief pause between GC cycles
+      await wait_for_condition(
+        () => true,
+        200,
+        50,
+        'pre-test garbage collection pause'
+      );
     }
   }
   
@@ -83,10 +111,15 @@ test.beforeEach(async () => {
     rmSync(TEST_DB_PATH, { recursive: true, force: true });
   }
   
-  // Wait for filesystem operations to complete
-  await new Promise(resolve => setTimeout(resolve, 200));
+  // Wait for filesystem operations to complete with condition check
+  await wait_for_condition(
+    () => !existsSync(TEST_DB_PATH),
+    3000,
+    50,
+    'filesystem cleanup completion'
+  );
   
-  initialize_database(TEST_DB_PATH);
+  await initialize_database(TEST_DB_PATH);
 });
 
 /**
@@ -97,17 +130,13 @@ test.afterEach(async () => {
 });
 
 test('5M documents - enterprise scale bulk insert test with memory efficiency', async t => {
-  console.log('\n🚀 Starting 5M Document Enterprise Scale Test (Memory-Efficient)...');
+  t.timeout(600000); // 10 minutes
+  
+  console.log('\n🚀 Starting 5M Document Enterprise Scale Test...');
   
   const memory_estimate = estimate_memory_usage(5000000, 'minimal', 600);
   console.log(`Memory estimate: ${memory_estimate.estimated_peak_memory_mb}MB peak`);
   
-  console.log(`📊 Test Configuration:`);
-  console.log(`   Documents: 5,000,000`);
-  console.log(`   Estimated Size: ${memory_estimate.total_data_size_mb}MB`);
-  console.log(`   Optimization: Memory-efficient streaming approach`);
-  console.log(`   Memory Management: 600 doc generation batches, 200 doc insert batches`);
-  
   const start_time = Date.now();
   
   const result = await memory_efficient_bulk_insert(TEST_DATABASE, TEST_COLLECTION, 5000000, {
@@ -119,98 +148,51 @@ test('5M documents - enterprise scale bulk insert test with memory efficiency',
   const total_duration = Date.now() - start_time;
   const duration_seconds = total_duration / 1000;
   
-  console.log(`\n✅ 5M DOCUMENT TEST RESULTS (Memory-Efficient):`);
+  console.log(`\n✅ 5M DOCUMENT TEST RESULTS:`);
   console.log(`   Duration: ${duration_seconds.toFixed(2)} seconds`);
   console.log(`   Throughput: ${result.performance.documents_per_second.toLocaleString()} docs/sec`);
   console.log(`   Memory Delta: ${result.performance.memory_usage.delta_heap_mb}MB`);
   console.log(`   Peak Memory: ${result.performance.memory_usage.peak_heap_mb}MB`);
-  console.log(`   Success Rate: 100%`);
   
-  // Validate results
   t.true(result.acknowledged);
   t.is(result.inserted_count, 5000000);
   t.is(result.inserted_ids.length, 5000000);
   
-  // Performance targets for 5M documents
   t.true(duration_seconds < 300, `Duration ${duration_seconds}s exceeds 5 minute limit`);
   t.true(result.performance.documents_per_second >= 15000, `Throughput ${result.performance.documents_per_second} below 15K docs/sec target`);
   t.true(result.performance.memory_usage.peak_heap_mb < 1536, `Memory ${result.performance.memory_usage.peak_heap_mb}MB exceeds 1.5GB limit`);
-  
-  // Performance classification
-  if (duration_seconds <= 30) {
-    console.log(`   🏆 PERFORMANCE: EXCELLENT (≤30s)`);
-  } else if (duration_seconds <= 60) {
-    console.log(`   🥇 PERFORMANCE: VERY GOOD (≤60s)`);
-  } else if (duration_seconds <= 120) {
-    console.log(`   🥈 PERFORMANCE: GOOD (≤2min)`);
-  } else {
-    console.log(`   🥉 PERFORMANCE: ACCEPTABLE (≤5min)`);
-  }
-  
-  console.log(`\n📈 5M DOCUMENT VALIDATION (Memory-Efficient):`);
-  console.log(`   ✅ No crashes or memory issues`);
-  console.log(`   ✅ Memory efficiency: ${result.performance.memory_usage.peak_heap_mb < 1024 ? 'EXCELLENT (<1GB)' : result.performance.memory_usage.peak_heap_mb < 1536 ? 'GOOD (<1.5GB)' : 'ACCEPTABLE'}`);
-  console.log(`   ✅ Consistent throughput throughout operation`);
-  console.log(`   ✅ All 5M documents inserted successfully`);
 });
 
 test('10M documents - maximum enterprise scale bulk insert test with memory efficiency', async t => {
-  console.log('\n🚀 Starting 10M Document MAXIMUM Enterprise Scale Test (Memory-Efficient)...');
+  t.timeout(900000); // 15 minutes
+  
+  console.log('\n🚀 Starting 10M Document MAXIMUM Enterprise Scale Test...');
   
   const memory_estimate = estimate_memory_usage(10000000, 'minimal', 500);
   console.log(`Memory estimate: ${memory_estimate.estimated_peak_memory_mb}MB peak`);
-  console.log(`Recommended batch size: ${memory_estimate.recommended_batch_size}`);
-  
-  console.log(`📊 Test Configuration:`);
-  console.log(`   Documents: 10,000,000`);
-  console.log(`   Estimated Size: ${memory_estimate.total_data_size_mb}MB`);
-  console.log(`   Optimization: Memory-efficient streaming approach`);
-  console.log(`   Memory Management: 2000 doc generation batches, 500 doc insert batches`);
-  console.log(`   TARGET: Complete in under 15 minutes (900s)`);
   
   const start_time = Date.now();
   
   const result = await memory_efficient_bulk_insert(TEST_DATABASE, TEST_COLLECTION, 10000000, {
-    generation_batch_size: 2000, // Larger generation batches for better performance
-    insert_batch_size: 500,      // Larger insert batches for better performance
-    document_template: 'minimal' // Minimal documents to reduce memory
+    generation_batch_size: 2000,
+    insert_batch_size: 500,
+    document_template: 'minimal'
   });
   
   const total_duration = Date.now() - start_time;
   const duration_seconds = total_duration / 1000;
   
-  console.log(`\n✅ 10M DOCUMENT TEST RESULTS (Memory-Efficient):`);
+  console.log(`\n✅ 10M DOCUMENT TEST RESULTS:`);
   console.log(`   Duration: ${duration_seconds.toFixed(2)} seconds`);
   console.log(`   Throughput: ${result.performance.documents_per_second.toLocaleString()} docs/sec`);
   console.log(`   Memory Delta: ${result.performance.memory_usage.delta_heap_mb}MB`);
   console.log(`   Peak Memory: ${result.performance.memory_usage.peak_heap_mb}MB`);
-  console.log(`   Success Rate: 100%`);
   
-  // Validate results
   t.true(result.acknowledged);
   t.is(result.inserted_count, 10000000);
   t.is(result.inserted_ids.length, 10000000);
   
-  // Performance targets for 10M documents (main requirement) - realistic for memory-efficient approach
   t.true(duration_seconds <= 900, `Duration ${duration_seconds}s exceeds 900s (15min) target`);
   t.true(result.performance.documents_per_second >= 15000, `Throughput ${result.performance.documents_per_second} below 15K docs/sec target`);
   t.true(result.performance.memory_usage.peak_heap_mb < 2048, `Memory ${result.performance.memory_usage.peak_heap_mb}MB exceeds 2GB limit`);
-  
-  // Performance classification
-  if (duration_seconds <= 300) {
-    console.log(`   🏆 PERFORMANCE: EXCELLENT (≤5min)`);
-  } else if (duration_seconds <= 600) {
-    console.log(`   🥇 PERFORMANCE: VERY GOOD (≤10min)`);
-  } else if (duration_seconds <= 900) {
-    console.log(`   🥈 PERFORMANCE: GOOD (≤15min)`);
-  } else {
-    console.log(`   ❌ PERFORMANCE: BELOW TARGET (>15min)`);
-  }
-  
-  console.log(`\n📈 10M DOCUMENT VALIDATION (MAIN REQUIREMENT - Memory-Efficient):`);
-  console.log(`   ✅ No crashes or memory issues`);
-  console.log(`   ✅ Memory efficiency: ${result.performance.memory_usage.peak_heap_mb < 1024 ? 'EXCELLENT (<1GB)' : result.performance.memory_usage.peak_heap_mb < 1536 ? 'VERY GOOD (<1.5GB)' : result.performance.memory_usage.peak_heap_mb < 2048 ? 'GOOD (<2GB)' : 'ACCEPTABLE'}`);
-  console.log(`   ✅ Target: 10M docs in under 15min - ${duration_seconds <= 900 ? 'MET' : 'NOT MET'}`);
-  console.log(`   ✅ All 10M documents inserted successfully`);
-  console.log(`   ✅ Enterprise scale capability proven with memory efficiency`);
 });

package/tests/performance/isolated_100000_test.js

@@ -0,0 +1,184 @@
+
+import { rmSync, existsSync } from 'fs';
+import { initialize_database, cleanup_database } from '../../src/server/lib/query_engine.js';
+import { bulk_insert_with_metrics } from '../../src/server/lib/bulk_insert_optimizer.js';
+
+const TEST_DB_PATH = './test_data/isolated_100000_test';
+const TEST_DATABASE = 'isolated_db_100000';
+const TEST_COLLECTION = 'isolated_collection';
+
+// Generate minimal test documents
+const generate_documents = (count) => {
+  const documents = [];
+  const test_id = Date.now().toString(36);
+  
+  for (let i = 0; i < count; i++) {
+    documents.push({
+      _id: `iso_${test_id}_${i.toString().padStart(8, '0')}`,
+      idx: i,
+      cat: i % 50,
+      val: i % 1000,
+      ts: Date.now() + i
+    });
+  }
+  
+  return documents;
+};
+
+// Aggressive memory management
+const force_cleanup = async () => {
+  await cleanup_database(true);
+  
+  // Force multiple GC cycles
+  if (global.gc) {
+    for (let i = 0; i < 5; i++) {
+      global.gc();
+      await new Promise(resolve => setTimeout(resolve, 50));
+    }
+  }
+  
+  // Wait for LMDB resources to be released
+  await new Promise(resolve => setTimeout(resolve, 200));
+};
+
+// Main test execution
+const run_test = async () => {
+  try {
+    console.log('🚀 Starting Process Isolation Validation Test (100,000 documents)');
+    
+    // Clean setup
+    if (existsSync(TEST_DB_PATH)) {
+      rmSync(TEST_DB_PATH, { recursive: true, force: true });
+    }
+    
+    // Initial memory state
+    const initial_memory = process.memoryUsage();
+    console.log(`Initial Memory: ${Math.round(initial_memory.heapUsed / (1024 * 1024))}MB heap used`);
+    
+    await initialize_database(TEST_DB_PATH);
+    
+    // Generate documents
+    console.log('Generating documents...');
+    const documents = generate_documents(100000);
+    
+    // Run test with optimal settings for isolation
+    const start_time = Date.now();
+    const result = await bulk_insert_with_metrics(TEST_DATABASE, TEST_COLLECTION, documents, {
+      disable_indexing: true,
+      pre_allocate_map_size: true,
+      sort_keys: true,
+      stream_processing: true,
+      batch_size: 500 // Smaller batches for very large datasets
+    });
+    
+    const total_duration = Date.now() - start_time;
+    const duration_seconds = total_duration / 1000;
+    
+    // Output results in parseable format
+    console.log(`\n✅ PROCESS ISOLATION VALIDATION TEST RESULTS:`);
+    console.log(`Duration: ${duration_seconds.toFixed(2)} seconds`);
+    console.log(`Throughput: ${result.performance.documents_per_second.toLocaleString()} docs/sec`);
+    console.log(`Memory Delta: ${result.performance.memory_usage.delta_heap_mb}MB`);
+    console.log(`Peak Memory: ${result.performance.memory_usage.peak_heap_mb}MB`);
+    console.log(`Success Rate: 100%`);
+    
+    // Validate results
+    if (!result.acknowledged) {
+      throw new Error('Insert not acknowledged');
+    }
+    if (result.inserted_count !== 100000) {
+      throw new Error(`Expected ${100000} inserts, got ${result.inserted_count}`);
+    }
+    
+    // Performance validation
+    const max_duration = 120;
+    const min_throughput = 20000;
+    const max_memory = 1024;
+    
+    if (duration_seconds > max_duration) {
+      throw new Error(`Duration ${duration_seconds}s exceeds ${max_duration}s limit`);
+    }
+    if (result.performance.documents_per_second < min_throughput) {
+      throw new Error(`Throughput ${result.performance.documents_per_second} below ${min_throughput} docs/sec target`);
+    }
+    if (result.performance.memory_usage.peak_heap_mb > max_memory) {
+      throw new Error(`Memory ${result.performance.memory_usage.peak_heap_mb}MB exceeds ${max_memory}MB limit`);
+    }
+    
+    console.log(`\n📈 PROCESS ISOLATION VALIDATION TEST VALIDATION:`);
+    console.log(`✅ Performance targets met`);
+    console.log(`✅ Memory usage within limits`);
+    console.log(`✅ All ${100000} documents inserted successfully`);
+    
+    // Cleanup
+    await force_cleanup();
+    
+    const final_memory = process.memoryUsage();
+    console.log(`Final Memory: ${Math.round(final_memory.heapUsed / (1024 * 1024))}MB heap used`);
+    
+    console.log('\n🎉 Test completed successfully');
+    process.exit(0);
+    
+  } catch (error) {
+    console.error(`\n❌ Test failed: ${error.message}`);
+    console.error(error.stack);
+    
+    try {
+      await force_cleanup();
+    } catch (cleanupError) {
+      console.error('Cleanup error:', cleanupError.message);
+    }
+    
+    process.exit(1);
+  }
+};
+
+// Handle process signals
+process.on('SIGTERM', async () => {
+  console.log('Received SIGTERM, cleaning up...');
+  try {
+    await force_cleanup();
+  } catch (error) {
+    console.error('Cleanup error:', error.message);
+  }
+  process.exit(1);
+});
+
+process.on('SIGINT', async () => {
+  console.log('Received SIGINT, cleaning up...');
+  try {
+    await force_cleanup();
+  } catch (error) {
+    console.error('Cleanup error:', error.message);
+  }
+  process.exit(1);
+});
+
+// Add uncaught exception handlers
+process.on('uncaughtException', async (error) => {
+  console.error('\n💥 Uncaught Exception:', error.message);
+  console.error(error.stack);
+  
+  try {
+    await force_cleanup();
+  } catch (cleanupError) {
+    console.error('Cleanup error:', cleanupError.message);
+  }
+  
+  process.exit(1);
+});
+
+process.on('unhandledRejection', async (reason, promise) => {
+  console.error('\n💥 Unhandled Rejection at:', promise, 'reason:', reason);
+  
+  try {
+    await force_cleanup();
+  } catch (cleanupError) {
+    console.error('Cleanup error:', cleanupError.message);
+  }
+  
+  process.exit(1);
+});
+
+// Run the test
+run_test();

package/tests/port_allocation_validation.test.js

@@ -0,0 +1,223 @@
+import test from 'ava';
+import { 
+  allocate_test_port, 
+  allocate_test_port_range,
+  release_test_port, 
+  release_test_port_range,
+  is_port_available,
+  get_port_allocation_stats,
+  cleanup_stale_port_allocations 
+} from './test_helpers.js';
+
+test.serial('port allocation system - basic allocation and release', async (t) => {
+  const test_name = 'basic_port_test';
+  
+  // Allocate a port
+  const port = await allocate_test_port(test_name);
+  
+  // Verify port is allocated
+  t.true(Number.isInteger(port));
+  t.true(port >= 10000);
+  t.true(port <= 65000);
+  
+  // Port should be available to bind to (allocation only reserves it internally)
+  const is_available = await is_port_available(port);
+  t.true(is_available);
+  
+  // Get allocation stats
+  const stats = get_port_allocation_stats();
+  t.true(stats.total_allocated >= 1);
+  t.true(stats.allocated_ports.includes(port));
+  
+  // Try to allocate the same port again - should get a different port
+  const second_port = await allocate_test_port(`${test_name}_2`);
+  t.not(second_port, port);
+  
+  // Release ports
+  await release_test_port(port, test_name);
+  await release_test_port(second_port, `${test_name}_2`);
+  
+  // Verify ports are released
+  const stats_after = get_port_allocation_stats();
+  t.false(stats_after.allocated_ports.includes(port));
+  t.false(stats_after.allocated_ports.includes(second_port));
+});
+
+test.serial('port allocation system - range allocation', async (t) => {
+  const test_name = 'range_port_test';
+  const port_count = 3;
+  
+  // Allocate port range
+  const ports = await allocate_test_port_range(test_name, port_count);
+  
+  // Verify we got the right number of ports
+  t.is(ports.length, port_count);
+  
+  // Verify all ports are unique
+  const unique_ports = new Set(ports);
+  t.is(unique_ports.size, port_count);
+  
+  // Verify all ports are in valid range
+  for (const port of ports) {
+    t.true(Number.isInteger(port));
+    t.true(port >= 10000);
+    t.true(port <= 65000);
+  }
+  
+  // Verify all ports are allocated
+  const stats = get_port_allocation_stats();
+  for (const port of ports) {
+    t.true(stats.allocated_ports.includes(port));
+  }
+  
+  // Release all ports
+  await release_test_port_range(ports, test_name);
+  
+  // Verify all ports are released
+  const stats_after = get_port_allocation_stats();
+  for (const port of ports) {
+    t.false(stats_after.allocated_ports.includes(port));
+  }
+});
+
+test.serial('port allocation system - concurrent allocation', async (t) => {
+  const concurrent_tests = 5;
+  const allocation_promises = [];
+  
+  // Start multiple concurrent allocations
+  for (let i = 0; i < concurrent_tests; i++) {
+    const test_name = `concurrent_test_${i}`;
+    allocation_promises.push(allocate_test_port(test_name));
+  }
+  
+  // Wait for all allocations to complete
+  const allocated_ports = await Promise.all(allocation_promises);
+  
+  // Verify we got unique ports
+  const unique_ports = new Set(allocated_ports);
+  t.is(unique_ports.size, concurrent_tests);
+  
+  // Verify all ports are in valid range
+  for (const port of allocated_ports) {
+    t.true(Number.isInteger(port));
+    t.true(port >= 10000);
+    t.true(port <= 65000);
+  }
+  
+  // Release all ports concurrently
+  const release_promises = [];
+  for (let i = 0; i < concurrent_tests; i++) {
+    const test_name = `concurrent_test_${i}`;
+    release_promises.push(release_test_port(allocated_ports[i], test_name));
+  }
+  
+  await Promise.all(release_promises);
+  
+  // Verify all ports are released
+  const stats = get_port_allocation_stats();
+  for (const port of allocated_ports) {
+    t.false(stats.allocated_ports.includes(port));
+  }
+});
+
+test.serial('port allocation system - preferred port allocation', async (t) => {
+  const test_name = 'preferred_port_test';
+  const preferred_port = 15000; // Specific port in our range
+  
+  // Try to allocate preferred port
+  const allocated_port = await allocate_test_port(test_name, { preferred_port });
+  
+  // Should get the preferred port if it's available
+  t.is(allocated_port, preferred_port);
+  
+  // Try to allocate the same preferred port again (should fail and get different port)
+  const second_allocated = await allocate_test_port(`${test_name}_2`, { preferred_port });
+  t.not(second_allocated, preferred_port);
+  
+  // Clean up
+  await release_test_port(allocated_port, test_name);
+  await release_test_port(second_allocated, `${test_name}_2`);
+});
+
+test.serial('port allocation system - port range offset', async (t) => {
+  const test_name = 'offset_port_test';
+  const offset = 100;
+  
+  // Allocate with offset
+  const port = await allocate_test_port(test_name, { port_range_offset: offset });
+  
+  t.true(Number.isInteger(port));
+  t.true(port >= 10000);
+  
+  // Clean up
+  await release_test_port(port, test_name);
+});
+
+test.serial('port allocation system - error handling', async (t) => {
+  // Test allocation failure simulation (by allocating many ports)
+  const test_name = 'error_handling_test';
+  
+  try {
+    // This should work normally
+    const port = await allocate_test_port(test_name);
+    t.true(Number.isInteger(port));
+    await release_test_port(port, test_name);
+  } catch (error) {
+    // If we get here, the system might be under heavy load
+    t.true(error.message.includes('Unable to allocate available port'));
+  }
+});
+
+test.serial('port allocation system - stale cleanup', async (t) => {
+  const test_name = 'stale_cleanup_test';
+  
+  // Allocate a port
+  const port = await allocate_test_port(test_name);
+  
+  // Get stats before cleanup
+  const stats_before = get_port_allocation_stats();
+  const allocated_before = stats_before.total_allocated;
+  
+  // Run stale cleanup (should not clean anything since port was just allocated)
+  const cleanup_result = await cleanup_stale_port_allocations({ max_age_ms: 100 });
+  
+  // Port should still be allocated
+  const stats_after = get_port_allocation_stats();
+  t.is(stats_after.total_allocated, allocated_before);
+  
+  // Clean up properly
+  await release_test_port(port, test_name);
+});
+
+test.serial('port allocation system - statistics accuracy', async (t) => {
+  const test_name = 'stats_test';
+  
+  // Get baseline stats
+  const baseline_stats = get_port_allocation_stats();
+  
+  // Allocate some ports
+  const port1 = await allocate_test_port(`${test_name}_1`);
+  const port2 = await allocate_test_port(`${test_name}_2`);
+  
+  // Check stats increased
+  const after_alloc_stats = get_port_allocation_stats();
+  t.is(after_alloc_stats.total_allocated, baseline_stats.total_allocated + 2);
+  t.true(after_alloc_stats.allocated_ports.includes(port1));
+  t.true(after_alloc_stats.allocated_ports.includes(port2));
+  
+  // Release one port
+  await release_test_port(port1, `${test_name}_1`);
+  
+  // Check stats decreased
+  const after_release_stats = get_port_allocation_stats();
+  t.is(after_release_stats.total_allocated, baseline_stats.total_allocated + 1);
+  t.false(after_release_stats.allocated_ports.includes(port1));
+  t.true(after_release_stats.allocated_ports.includes(port2));
+  
+  // Clean up remaining port
+  await release_test_port(port2, `${test_name}_2`);
+  
+  // Check final stats
+  const final_stats = get_port_allocation_stats();
+  t.is(final_stats.total_allocated, baseline_stats.total_allocated);
+});