Merge pull request #2 from dbccccccc/test

fix 403!

Author: dbccccccc

pressure_test.py

@@ -1,7 +1,7 @@
 """
 Pressure Test for the OpenAI TTS API Server
 
-This script sends concurrent requests to the API server to test its performance under load.
+This script continuously sends requests to the API server until it encounters a failure.
 """
 
 import asyncio
@@ -112,8 +112,16 @@ async def send_request(session, url, voice, text_length, request_num, save_dir=N
             "response_size": 0
         }
 
-async def run_pressure_test(num_requests, concurrency, server_url, text_length="medium", save_audio=False):
-    """Run the pressure test with the specified parameters."""
+async def run_test(server_url, text_length="medium", save_audio=False, num_requests=None, concurrency=1):
+    """Run the test with specified parameters.
+    
+    Args:
+        server_url: URL of the TTS server
+        text_length: Length of test text (short, medium, long)
+        save_audio: Whether to save audio files
+        num_requests: Number of requests to send (None for continuous until failure)
+        concurrency: Number of concurrent requests to send
+    """
 
     if not server_url.endswith('/v1/audio/speech'):
         server_url = f"{server_url.rstrip('/')}/v1/audio/speech"
@@ -123,10 +131,15 @@ async def run_pressure_test(num_requests, concurrency, server_url, text_length="
     if save_audio:
         save_dir = Path('test_output')
         save_dir.mkdir(exist_ok=True)
-        
-    print(f"Starting pressure test with {num_requests} total requests, {concurrency} concurrent connections")
+    
+    mode = "fixed" if num_requests else "continuous"
+    
+    print(f"Starting {mode} test with {concurrency} concurrent requests")
     print(f"Server URL: {server_url}")
     print(f"Text length: {text_length}")
+    if num_requests:
+        print(f"Number of requests: {num_requests}")
+    print(f"Concurrency level: {concurrency}")
     if save_audio:
         print(f"Saving audio files to: {save_dir}")
     print("-" * 60)
@@ -135,40 +148,62 @@ async def run_pressure_test(num_requests, concurrency, server_url, text_length="
     start_time = time.time()
 
     async with aiohttp.ClientSession() as session:
-        tasks = []
-        for i in range(num_requests):
-            # Cycle through different voices
-            voice = VOICES[i % len(VOICES)]
-            
-            # Add a small delay between creating tasks to avoid overwhelming the server at startup
-            await asyncio.sleep(0.05)
+        if num_requests:
+            # Fixed number of requests mode
+            request_nums = list(range(1, num_requests + 1))
 
-            task = asyncio.create_task(send_request(session, server_url, voice, text_length, i + 1, save_dir))
-            tasks.append(task)
+            # Process requests in batches according to concurrency
+            for i in range(0, len(request_nums), concurrency):
+                batch = request_nums[i:i+concurrency]
+                tasks = []
+                
+                for req_num in batch:
+                    voice = VOICES[(req_num - 1) % len(VOICES)]
+                    tasks.append(send_request(session, server_url, voice, text_length, req_num, save_dir))
+                
+                batch_results = await asyncio.gather(*tasks)
+                results.extend(batch_results)
+                
+                # Check if any request in the batch failed
+                if any(not r["success"] for r in batch_results):
+                    print("Stopping test due to request failure")
+                    break
+        else:
+            # Continuous mode (until failure)
+            request_num = 1
+            failed = False
 
-            # If we've reached the concurrency limit, wait for some tasks to complete
-            if len(tasks) >= concurrency:
-                done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
-                results.extend([task.result() for task in done])
-                tasks = list(pending)  # Convert the pending set back to a list
-        
-        # Wait for any remaining tasks
-        if tasks:
-            done, _ = await asyncio.wait(tasks)
-            results.extend([task.result() for task in done])
+            while not failed:
+                tasks = []
+                
+                for i in range(concurrency):
+                    curr_req_num = request_num + i
+                    voice = VOICES[(curr_req_num - 1) % len(VOICES)]
+                    tasks.append(send_request(session, server_url, voice, text_length, curr_req_num, save_dir))
+                
+                batch_results = await asyncio.gather(*tasks)
+                results.extend(batch_results)
+                
+                # Check if any request in the batch failed
+                if any(not r["success"] for r in batch_results):
+                    failed = True
+                    print("Stopping test due to request failure")
+                    break
+                
+                request_num += concurrency
 
     end_time = time.time()
     total_duration = end_time - start_time
 
     print("\n" + "=" * 60)
-    print(f"Pressure Test Results ({text_length} text)")
+    print(f"Test Results ({text_length} text, {'continuous' if not num_requests else num_requests} requests, {concurrency} concurrency)")
     print("=" * 60)
 
     # Calculate and display statistics
     successful_reqs = [r for r in results if r["success"]]
     failed_reqs = [r for r in results if not r["success"]]
 
-    success_rate = len(successful_reqs) / num_requests * 100 if num_requests > 0 else 0
+    success_rate = len(successful_reqs) / len(results) * 100 if results else 0
 
     # Calculate response time statistics
     if successful_reqs:
@@ -183,46 +218,51 @@ async def run_pressure_test(num_requests, concurrency, server_url, text_length="
         avg_size = statistics.mean(sizes) / 1024  # KB
         total_size = sum(sizes) / (1024 * 1024)  # MB
 
-        print(f"Success Rate: {success_rate:.1f}% ({len(successful_reqs)}/{num_requests})")
+        print(f"Total Successful Requests: {len(successful_reqs)}")
+        print(f"Success Rate: {success_rate:.1f}%")
         print(f"Total Test Duration: {total_duration:.2f} seconds")
         print(f"Average Response Time: {avg_duration:.3f} seconds")
         print(f"Median Response Time: {median_duration:.3f} seconds")
         print(f"Min Response Time: {min_duration:.3f} seconds")
         print(f"Max Response Time: {max_duration:.3f} seconds")
         print(f"Average Response Size: {avg_size:.1f} KB")
         print(f"Total Data Transferred: {total_size:.2f} MB")
-        print(f"Requests per Second: {num_requests / total_duration:.2f}")
+        print(f"Requests per Second: {len(results) / total_duration:.2f}")
         print(f"Throughput: {(total_size * 8) / total_duration:.2f} Mbps")
     else:
-        print(f"Success Rate: 0% (0/{num_requests})")
+        print(f"Success Rate: 0%")
         print(f"Total Test Duration: {total_duration:.2f} seconds")
 
-    # Show error breakdown if there are failures
+    # Show error details for the failures
     if failed_reqs:
-        print("\nError Breakdown:")
-        error_counts = {}
-        for req in failed_reqs:
-            error = req.get("error", f"HTTP {req['status']}")
-            error_counts[error] = error_counts.get(error, 0) + 1
+        print("\nFailure Details:")
+        for i, failed_req in enumerate(failed_reqs[:5]):  # Show up to 5 failures
+            error = failed_req.get("error", f"HTTP {failed_req['status']}")
+            print(f"  Request Number: {failed_req['request_num']}")
+            print(f"  Voice: {failed_req['voice']}")
+            print(f"  Error: {error}")
+            print(f"  Duration: {failed_req['duration']:.2f} seconds")
+            if i < len(failed_reqs) - 1 and i < 4:  # Add separator except after the last one
+                print("  ---")
 
-        for error, count in error_counts.items():
-            print(f"  {error}: {count} occurrences")
+        if len(failed_reqs) > 5:
+            print(f"  ... and {len(failed_reqs) - 5} more failures")
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description="Pressure test for OpenAI TTS API Server")
-    parser.add_argument("-n", "--num-requests", type=int, default=10, help="Total number of requests to send")
-    parser.add_argument("-c", "--concurrency", type=int, default=2, help="Number of concurrent connections")
     parser.add_argument("-u", "--url", type=str, default="http://localhost:7000", help="Server URL")
     parser.add_argument("-t", "--text-length", type=str, choices=["short", "medium", "long"], default="medium", 
                         help="Length of text to use for testing")
     parser.add_argument("-s", "--save-audio", action="store_true", help="Save audio files to test_output directory")
+    parser.add_argument("-n", "--num-requests", type=int, help="Number of requests to send (default: continuous until failure)")
+    parser.add_argument("-c", "--concurrency", type=int, default=1, help="Number of concurrent requests (default: 1)")
 
     args = parser.parse_args()
 
-    asyncio.run(run_pressure_test(
-        args.num_requests, 
-        args.concurrency, 
+    asyncio.run(run_test(
         args.url, 
         args.text_length,
-        args.save_audio
+        args.save_audio,
+        args.num_requests,
+        args.concurrency
     ))