minor changes to tls mock server

Author: Krish

tests/mock_server/README.md

@@ -14,28 +14,46 @@ Python 3.5+ required.
 * Have the cert/key ready. The script now using `../resources/unittests.crt`, you can either just run the script within this directory, which will find the certificates and key from the related path, or you can use your own and change the code coordinately.
 * Run python. `python3 ./server.py`.
 
-#### Echo
+#### Endpoints
 
-* Minor changed based on the example to response the headers of requests back within the headers from `/echo`.
-* To test the server runs correctly, you can do `curl -k -v -H "foo:bar" https://localhost:3443/echo` and check the result.
+##### `/echo` - Echo endpoint (default)
 
-#### Download test
+Echoes back request headers and body as JSON.
 
-* To test download, when `:path` is `/downloadTest`, server will response a repeated string with length `self.download_test_length`, which is 2,500,000,000 now. It will be repeats of sting "This is CRT HTTP test."
-* To test the server runs correctly, you can do `curl -k -v -H "foo:bar" https://localhost:3443/downloadTest` and check the result.
+```bash
+curl -k -v -H "foo:bar" https://localhost:3443/echo
+```
 
-#### Slow Connection Test
+##### `/echo` with `x-repeat-data` header - Download test
 
-* Simulate a slow connection when `:path` is `/slowConnTest`. The speed is controlled by `out_bytes_per_second`. Default speed is 900 B/s, which will send 900 bytes of data and wait a sec to send new 900 bytes of data.
+Sends repeated test pattern of specified size (in bytes).
 
-#### Upload test
+```bash
+# Download 1MB of repeated data
+curl -k -v -H "x-repeat-data: 1000000" https://localhost:3443/echo
+```
 
-* To test upload, when `:method` is `POST` or `PUT`, server will response the length received from response body
-* To test the server runs correctly, you can do `curl -k -X POST -F'data=@upload_test.txt' https://localhost:3443/upload_test` where `upload_test.txt` is file to upload.
+##### `/echo` with `x-repeat-data` + `x-slow-response` headers - Slow connection test
+
+Sends repeated data throttled to ~900 bytes/sec (for timeout testing).
+
+```bash
+# Download 5MB slowly at default speed (900 bytes/sec)
+curl -k -v -H "x-repeat-data: 5000000" -H "x-slow-response: true" https://localhost:3443/echo
+```
+
+##### `/echo` with custom throughput - Custom speed test
+
+Override default throughput with `x-throughput-bps` header.
+
+```bash
+# Download 5MB at 500 bytes/sec
+curl -k -v -H "x-repeat-data: 5000000" -H "x-slow-response: true" -H "x-throughput-bps: 500" https://localhost:3443/echo
+```
 
-#### expect500
+##### Any other path
 
-* The server will always return `500` for `:status`, when the `:path` is `/expect500`
+Returns 404 Not Found.
 
 ### Non-TLS server
 

tests/mock_server/h2tls_mock_server.py

@@ -8,9 +8,22 @@
 
 A fully-functional HTTP/2 server using asyncio. Requires Python 3.5+.
 
-This example demonstrates handling requests with bodies, as well as handling
-those without. In particular, it demonstrates the fact that DataReceived may
-be called multiple times, and that applications must handle that possibility.
+Supported endpoints:
+
+1. GET /echo (default)
+   - Echoes back request headers and body as JSON
+
+2. GET /echo with x-repeat-data header
+   - x-repeat-data: <bytes> - Sends repeated test pattern of specified size
+   - Example: x-repeat-data: 1000000 (sends 1MB)
+
+3. GET /echo with x-repeat-data + x-slow-response headers
+   - x-slow-response: true - Throttles response to ~900 bytes/sec (for timeout testing)
+   - x-throughput-bps: <number> - Optional: Override throughput (default 900)
+   - Example: x-repeat-data: 5000000, x-slow-response: true, x-throughput-bps: 500
+
+4. Any other path
+   - Returns 404 Not Found
 """
 import asyncio
 import io
@@ -100,6 +113,47 @@ def request_received(self, headers: List[Tuple[str, str]], stream_id: int):
         self.stream_data[stream_id] = request_data
 
     def handle_request_echo(self, stream_id: int, request_data: RequestData):
+        """
+        Handle /echo endpoint with optional special headers:
+        - x-repeat-data: <bytes> - Triggers send_repeat_data() with specified length
+        - x-slow-response: true - Triggers send_slow_repeat_data() instead (requires x-repeat-data)
+        - x-throughput-bps: <number> - Override throughput for slow response (default 900)
+        
+        Without special headers, echoes request headers and body as JSON.
+        """
+        headers_dict = dict(self.raw_headers)
+        
+        # Check for x-repeat-data header
+        repeat_data_header = headers_dict.get('x-repeat-data')
+        if repeat_data_header:
+            try:
+                length = int(repeat_data_header)
+                response_headers = [(':status', '200')]
+                self.conn.send_headers(stream_id, response_headers, end_stream=False)
+                
+                # Check for slow response
+                if headers_dict.get('x-slow-response') == 'true':
+                    # Check for custom throughput
+                    throughput_header = headers_dict.get('x-throughput-bps')
+                    if throughput_header:
+                        self.out_bytes_per_second = int(throughput_header)
+                    asyncio.ensure_future(self.send_slow_repeat_data(length, stream_id))
+                else:
+                    asyncio.ensure_future(self.send_repeat_data(length, stream_id))
+                return
+            except ValueError:
+                pass  # Fall through to echo behavior
+        
+        # Check for upload test (don't echo body, just return byte count)
+        if headers_dict.get('x-upload-test') == 'true':
+            body_bytes = request_data.data.getvalue()
+            data = json.dumps({"bytes": len(body_bytes)}, indent=4).encode("utf8")
+            response_headers = [(':status', '200'), ('content-length', str(len(data)))]
+            self.conn.send_headers(stream_id, response_headers, end_stream=False)
+            asyncio.ensure_future(self.send_data(data, stream_id))
+            return
+        
+        # Default echo behavior
         response_headers = [(':status', '200')]
         # Filter out headers that shouldn't be echoed back
         skip_headers = {'content-length', 'content-encoding', 'transfer-encoding'}
@@ -108,9 +162,12 @@ def handle_request_echo(self, stream_id: int, request_data: RequestData):
             if i[0][0] != ':' and i[0].lower() not in skip_headers:
                 response_headers.append(i)
 
-        body = request_data.data.getvalue().decode('utf-8')
+        body_bytes = request_data.data.getvalue()
+        
+        body = body_bytes.decode('utf-8')
+
         data = json.dumps(
-            {"body": body}, indent=4
+            {"body": body, "bytes": len(body_bytes)}, indent=4,
         ).encode("utf8")
 
         # Add correct content-length for our response
@@ -198,7 +255,9 @@ async def send_data(self, data, stream_id):
 
     async def send_repeat_data(self, length, stream_id):
         """
-        Send data with length according to the flow control rules.
+        Send repeated test pattern data of specified length.
+        Respects HTTP/2 flow control rules.
+        Triggered by x-repeat-data header on /echo endpoint.
         """
         while length > 0:
             while self.conn.local_flow_control_window(stream_id) < 1:
@@ -232,7 +291,9 @@ async def send_repeat_data(self, length, stream_id):
 
     async def send_slow_repeat_data(self, length, stream_id):
         """
-        Send data with length slowly (less than 1000 bytes per second)
+        Send repeated test pattern data slowly (throttled to out_bytes_per_second, default 900).
+        Used for timeout and slow connection testing.
+        Triggered by x-repeat-data + x-slow-response headers on /echo endpoint.
         """
         while length > 0:
             while self.conn.local_flow_control_window(stream_id) < 1: