Move to Localhost servers for HTTP tests. (#355)

Co-authored-by: Krish <>

Author: azkrishpy

.builder/actions/localhost_test.py

@@ -0,0 +1,60 @@
+import Builder
+import subprocess
+import socket
+import sys
+import time
+import os
+
+
+class LocalhostTest(Builder.Action):
+
+    def start(self, env):
+        python = sys.executable
+        venv_path = os.path.join(env.root_dir,'aws-common-runtime','aws-c-http','tests','mock_server', '.venv')
+
+        result = env.shell.exec(python, '-m', 'venv', venv_path)
+        if result.returncode != 0:
+            print("Could not start a virtual environment. The localhost integration tests will fail.", file=sys.stderr)
+            return
+        
+        python = os.path.join(venv_path, "bin", "python")
+        
+        result = env.shell.exec(python, '-m', 'pip', 'install', 'h11', 'h2', 'trio')
+        if result.returncode != 0:
+            print("Could not install python HTTP dependencies. The localhost integration tests will fail.", file=sys.stderr)
+            return
+        
+        server_dir = os.path.join(env.root_dir,'aws-common-runtime','aws-c-http','tests','mock_server')
+        
+        p1 = subprocess.Popen([python, "h2tls_mock_server.py"], cwd=server_dir)
+        p2 = subprocess.Popen([python, "h2non_tls_server.py"], cwd=server_dir)
+        env = os.environ.copy()
+        env['HTTP_PORT'] = '8091'
+        env['HTTPS_PORT'] = '8092'
+        p3 = subprocess.Popen([python, "h11mock_server.py"], cwd=server_dir, env=env)
+        
+        # Wait for servers to be ready, more information about mock servers on README.md
+        ports = [3443, 3280, 8092, 8091]
+        for port in ports:
+            for attempt in range(30):
+                try:
+                    with socket.create_connection(("localhost", port), timeout=1):
+                        print(f"Server on port {port} is ready")
+                        break
+                except (socket.error, ConnectionRefusedError, OSError):
+                    if attempt == 29:
+                        print(f"ERROR: Server on port {port} failed to start", file=sys.stderr)
+                    time.sleep(1)
+
+    def run(self, env):
+        self.start(env)
+        env.shell.setenv('AWS_CRT_MEMORY_TRACING', '2')
+
+        if os.system("env AWS_CRT_LOCALHOST=true swift test --filter 'HTTPTests|HTTP2ClientConnectionTests'"):
+            # Failed
+            actions.append("exit 1")
+        
+        # kill servers
+        env.shell.exec("pkill", "-f", "h2tls_mock_server.py")
+        env.shell.exec("pkill", "-f", "h2non_tls_server.py")
+        env.shell.exec("pkill", "-f", "h11mock_server.py")

.github/workflows/ci.yml

@@ -181,3 +181,37 @@ jobs:
       # note: using "@main" because "@${{env.BUILDER_VERSION}}" doesn't work
       # https://github.com/actions/runner/issues/480
       uses: awslabs/aws-crt-builder/.github/actions/check-submodules@main
+
+  localhost-test-linux:
+    runs-on: ubuntu-24.04 # latest
+    steps:
+    - uses: aws-actions/configure-aws-credentials@v4
+      with:
+        role-to-assume: ${{ env.CRT_CI_ROLE }}
+        aws-region: ${{ env.AWS_DEFAULT_REGION }}
+    - name: Checkout
+      uses: actions/checkout@v4
+      with:
+        submodules: true
+    - name: Build and test
+      run: |
+        python3 -c "from urllib.request import urlretrieve; urlretrieve('${{ env.BUILDER_HOST }}/${{ env.BUILDER_SOURCE }}/${{ env.BUILDER_VERSION }}/builder.pyz?run=${{ env.RUN }}', 'builder.pyz')"
+        python builder.pyz build -p ${{ env.PACKAGE_NAME }} --variant=localhost
+
+
+  localhost-test-macos:
+    runs-on: macos-14 # latest
+    steps:
+    - uses: aws-actions/configure-aws-credentials@v4
+      with:
+        role-to-assume: ${{ env.CRT_CI_ROLE }}
+        aws-region: ${{ env.AWS_DEFAULT_REGION }}
+    - name: Checkout
+      uses: actions/checkout@v4
+      with:
+        submodules: true
+    - name: Build and test
+      run: |
+        python3 -c "from urllib.request import urlretrieve; urlretrieve('${{ env.BUILDER_HOST }}/${{ env.BUILDER_SOURCE }}/${{ env.BUILDER_VERSION }}/builder.pyz?run=${{ env.RUN }}', 'builder')"
+        chmod a+x builder
+        ./builder build -p ${{ env.PACKAGE_NAME }} --variant=localhost

Package.swift

@@ -57,6 +57,9 @@ awsCCommonPlatformExcludes.append("source/arch/arm")
 #if !os(Windows)
   awsCCommonPlatformExcludes.append("source/windows")
 #endif
+#if !os(Linux)
+  awsCCommonPlatformExcludes.append("source/linux")
+#endif
 let cSettingsCommon: [CSetting] = [
   .headerSearchPath("source/external/libcbor"),
   .define("DEBUG_BUILD", .when(configuration: .debug)),

README.md

@@ -25,6 +25,41 @@ To format the code:
 swift format --in-place --recursive .
 ```
 
+## Testing
+
+Running Localhost tests:
+Localhost tests are run using mock servers from aws-c-http. Use the following instructions from root to run the localhost.
+Tests that use localhost within swift: HTTPTests, HTTP2ClientConnectionTests
+
+```sh
+cd aws-common-runtime/aws-c-http/tests/mockserver
+# install dependencies
+python -m pip install h11 h2 trio
+# for http/1.1 server
+HTTP_PORT=8091 HTTPS_PORT=8092 python h11mock_server.py
+# for http/2 non tls server
+python h2non_tls_server.py
+# for http/2 tls server. 
+python h2tls_mock_server.py
+# enable localhost env variable for tests to detect localhost server.
+export AWS_CRT_LOCALHOST=true
+```
+
+We use 4 different ports for running mock servers:
+- 3280 and 3443 for HTTP/2 (without TLS and with TLS respectively)
+- 8091 and 8092 for HTTP/1.1 (without TLS and with TLS respectively)
+
+To use different ports for HTTP/1.1 server, initialize with different values for HTTP_PORT and HTTPS_PORT. 
+Also, change the following lines in HTTPTests.swift.
+```swift
+  var httpPort: Int {
+    ProcessInfo.processInfo.environment["AWS_CRT_LOCALHOST"] != nil ? 8091 : 80
+  }
+  var httpsPort: Int {
+    ProcessInfo.processInfo.environment["AWS_CRT_LOCALHOST"] != nil ? 8092 : 443
+  }
+```
+
 ### Contributor's Guide
 **Required Reading:**
 - [Development Guide](docs/dev_guide.md)

Test/AwsCommonRuntimeKitTests/XCBaseTestCase.swift

@@ -69,6 +69,13 @@ extension XCTestCase {
     #endif
   }
 
+  // Look into README to run localhost server tests and how to startup the local server.
+  func skipIfLocalhostUnavailable() throws {
+    guard let _ = ProcessInfo.processInfo.environment["AWS_CRT_LOCALHOST"] else {
+      throw XCTSkip("Localhost server has not been started.")
+    }
+  }
+
   func awaitExpectationResult(_ expectations: [XCTestExpectation], _ timeout: TimeInterval = 5)
     async -> XCTWaiter.Result
   {
@@ -89,6 +96,7 @@ extension XCTestCase {
       wait(for: expectations, timeout: timeout)
     #endif
   }
+
   func skipIfPlatformDoesntSupportTLS() throws {
     // Skipped for secitem support as the unit tests requires enetitlement setup to have acces to
     // the data protection keychain.

Test/AwsCommonRuntimeKitTests/http/HTTP2ClientConnectionTests.swift

@@ -7,19 +7,23 @@ import XCTest
 class HTTP2ClientConnectionTests: XCBaseTestCase {
 
   let expectedVersion = HTTPVersion.version_2
-  let host = "postman-echo.com"
+  let host = "localhost"
+  let port: Int = 3443
 
   func testGetHTTP2RequestVersion() async throws {
+    try skipIfLocalhostUnavailable()
+    try? Logger.initialize(target: LogTarget.standardOutput, level: LogLevel.trace)
     let connectionManager = try await HTTPClientTestFixture.getHttpConnectionManager(
-      endpoint: host, alpnList: ["h2", "http/1.1"])
+      endpoint: host, port: port, alpnList: ["h2", "http/1.1"])
     let connection = try await connectionManager.acquireConnection()
     XCTAssertEqual(connection.httpVersion, HTTPVersion.version_2)
   }
 
   // Test that the binding works not the actual functionality. C part has tests for functionality
   func testHTTP2UpdateSetting() async throws {
+    try skipIfLocalhostUnavailable()
     let connectionManager = try await HTTPClientTestFixture.getHttpConnectionManager(
-      endpoint: host, alpnList: ["h2", "http/1.1"])
+      endpoint: host, port: port, alpnList: ["h2", "http/1.1"])
     let connection = try await connectionManager.acquireConnection()
     if let connection = connection as? HTTP2ClientConnection {
       try await connection.updateSetting(setting: HTTP2Settings(enablePush: false))
@@ -30,8 +34,9 @@ class HTTP2ClientConnectionTests: XCBaseTestCase {
 
   // Test that the binding works not the actual functionality. C part has tests for functionality
   func testHTTP2UpdateSettingEmpty() async throws {
+    try skipIfLocalhostUnavailable()
     let connectionManager = try await HTTPClientTestFixture.getHttpConnectionManager(
-      endpoint: host, alpnList: ["h2", "http/1.1"])
+      endpoint: host, port: port, alpnList: ["h2", "http/1.1"])
     let connection = try await connectionManager.acquireConnection()
     if let connection = connection as? HTTP2ClientConnection {
       try await connection.updateSetting(setting: HTTP2Settings())
@@ -42,8 +47,9 @@ class HTTP2ClientConnectionTests: XCBaseTestCase {
 
   // Test that the binding works not the actual functionality. C part has tests for functionality
   func testHTTP2SendPing() async throws {
+    try skipIfLocalhostUnavailable()
     let connectionManager = try await HTTPClientTestFixture.getHttpConnectionManager(
-      endpoint: host, alpnList: ["h2", "http/1.1"])
+      endpoint: host, port: port, alpnList: ["h2", "http/1.1"])
     let connection = try await connectionManager.acquireConnection()
     if let connection = connection as? HTTP2ClientConnection {
       var time = try await connection.sendPing()
@@ -57,8 +63,9 @@ class HTTP2ClientConnectionTests: XCBaseTestCase {
 
   // Test that the binding works not the actual functionality. C part has tests for functionality
   func testHTTP2SendGoAway() async throws {
+    try skipIfLocalhostUnavailable()
     let connectionManager = try await HTTPClientTestFixture.getHttpConnectionManager(
-      endpoint: host, alpnList: ["h2", "http/1.1"])
+      endpoint: host, port: port, alpnList: ["h2", "http/1.1"])
     let connection = try await connectionManager.acquireConnection()
     if let connection = connection as? HTTP2ClientConnection {
       connection.sendGoAway(error: .internalError, allowMoreStreams: false)
@@ -68,12 +75,13 @@ class HTTP2ClientConnectionTests: XCBaseTestCase {
   }
 
   func testGetHttpsRequest() async throws {
+    try skipIfLocalhostUnavailable()
     let connectionManager = try await HTTPClientTestFixture.getHttpConnectionManager(
-      endpoint: host, alpnList: ["h2", "http/1.1"])
+      endpoint: host, port: port, alpnList: ["h2", "http/1.1"])
     let response = try await HTTPClientTestFixture.sendHTTPRequest(
       method: "GET",
       endpoint: host,
-      path: "/get",
+      path: "/echo",
       connectionManager: connectionManager,
       expectedVersion: expectedVersion,
       requestVersion: .version_2)
@@ -91,12 +99,13 @@ class HTTP2ClientConnectionTests: XCBaseTestCase {
   }
 
   func testGetHttpsRequestWithHTTP1_1Request() async throws {
+    try skipIfLocalhostUnavailable()
     let connectionManager = try await HTTPClientTestFixture.getHttpConnectionManager(
-      endpoint: host, alpnList: ["h2", "http/1.1"])
+      endpoint: host, port: port, alpnList: ["h2", "http/1.1"])
     let response = try await HTTPClientTestFixture.sendHTTPRequest(
       method: "GET",
       endpoint: host,
-      path: "/get",
+      path: "/echo",
       connectionManager: connectionManager,
       expectedVersion: expectedVersion,
       requestVersion: .version_1_1)

Test/AwsCommonRuntimeKitTests/http/HTTPClientTestFixture.swift

@@ -136,6 +136,7 @@ class HTTPClientTestFixture: XCBaseTestCase {
   ) async throws -> HTTPClientConnectionManager {
     let tlsContextOptions = TLSContextOptions()
     tlsContextOptions.setAlpnList(alpnList)
+    tlsContextOptions.setVerifyPeer(false)
     let tlsContext = try TLSContext(options: tlsContextOptions, mode: .client)
     var tlsConnectionOptions = TLSConnectionOptions(context: tlsContext)
     tlsConnectionOptions.serverName = endpoint