From bc7e2d06ca035dfae7f1d54c8e6fcf7ce8a8cb80 Mon Sep 17 00:00:00 2001 From: David Nadoba Date: Tue, 14 Dec 2021 16:51:19 +0100 Subject: [PATCH 1/6] add end to end tets save progress save progress 2 --- .../AsyncAwaitEndToEndTests+XCTest.swift | 44 ++ .../AsyncAwaitEndToEndTests.swift | 416 ++++++++++++++++++ Tests/LinuxMain.swift | 1 + 3 files changed, 461 insertions(+) create mode 100644 Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests+XCTest.swift create mode 100644 Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift diff --git a/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests+XCTest.swift b/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests+XCTest.swift new file mode 100644 index 000000000..c258534bc --- /dev/null +++ b/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests+XCTest.swift @@ -0,0 +1,44 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the AsyncHTTPClient open source project +// +// Copyright (c) 2018-2019 Apple Inc. and the AsyncHTTPClient project authors +// Licensed under Apache License v2.0 +// +// See LICENSE.txt for license information +// See CONTRIBUTORS.txt for the list of AsyncHTTPClient project authors +// +// SPDX-License-Identifier: Apache-2.0 +// +//===----------------------------------------------------------------------===// +// +// AsyncAwaitEndToEndTests+XCTest.swift +// +import XCTest + +/// +/// NOTE: This file was generated by generate_linux_tests.rb +/// +/// Do NOT edit this file directly as it will be regenerated automatically when needed. +/// + +extension AsyncAwaitEndToEndTests { + static var allTests: [(String, (AsyncAwaitEndToEndTests) -> () throws -> Void)] { + return [ + ("testSimpleGet", testSimpleGet), + ("testSimplePost", testSimplePost), + ("testPostWithByteBuffer", testPostWithByteBuffer), + ("testPostWithSequenceOfUInt8", testPostWithSequenceOfUInt8), + ("testPostWithCollectionOfUInt8", testPostWithCollectionOfUInt8), + ("testPostWithRandomAccessCollectionOfUInt8", testPostWithRandomAccessCollectionOfUInt8), + ("testPostWithAsyncSequenceOfByteBuffers", testPostWithAsyncSequenceOfByteBuffers), + ("testPostWithAsyncSequenceOfUInt8", testPostWithAsyncSequenceOfUInt8), + ("testPostWithFragmentedAsyncSequenceOfByteBuffers", testPostWithFragmentedAsyncSequenceOfByteBuffers), + ("testPostWithFragmentedAsyncSequenceOfLargeByteBuffers", testPostWithFragmentedAsyncSequenceOfLargeByteBuffers), + ("testCanceling", testCanceling), + ("testDeadline", testDeadline), + ("testConnectTimeout", testConnectTimeout), + ("testInvalidURL", testInvalidURL), + ] + } +} diff --git a/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift b/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift new file mode 100644 index 000000000..7caf3fb34 --- /dev/null +++ b/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift @@ -0,0 +1,416 @@ +//===----------------------------------------------------------------------===// +// +// This source file is part of the AsyncHTTPClient open source project +// +// Copyright (c) 2021 Apple Inc. and the AsyncHTTPClient project authors +// Licensed under Apache License v2.0 +// +// See LICENSE.txt for license information +// See CONTRIBUTORS.txt for the list of AsyncHTTPClient project authors +// +// SPDX-License-Identifier: Apache-2.0 +// +//===----------------------------------------------------------------------===// + +@testable import AsyncHTTPClient +import Logging +import NIOCore +import NIOPosix +import XCTest + +private func makeDefaultHTTPClient( + eventLoopGroupProvider: HTTPClient.EventLoopGroupProvider = .createNew +) -> HTTPClient { + var config = HTTPClient.Configuration() + config.tlsConfiguration = .clientDefault + config.tlsConfiguration?.certificateVerification = .none + config.httpVersion = .automatic + return HTTPClient( + eventLoopGroupProvider: eventLoopGroupProvider, + configuration: config, + backgroundActivityLogger: Logger(label: "HTTPClient", factory: StreamLogHandler.standardOutput(label:)) + ) +} + +final class AsyncAwaitEndToEndTests: XCTestCase { + func testSimpleGet() { + #if compiler(>=5.5) && canImport(_Concurrency) + guard #available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *) else { return } + XCTAsyncTest { + let bin = HTTPBin(.http2(compress: false)) + defer { XCTAssertNoThrow(try bin.shutdown()) } + let client = makeDefaultHTTPClient() + defer { XCTAssertNoThrow(try client.syncShutdown()) } + let logger = Logger(label: "HTTPClient", factory: StreamLogHandler.standardOutput(label:)) + let request = HTTPClientRequest(url: "https://localhost:\(bin.port)/get") + + guard let response = await XCTAssertNoThrowWithResult( + try await client.execute(request, deadline: .now() + .seconds(10), logger: logger) + ) else { + return + } + + XCTAssertEqual(response.status, .ok) + XCTAssertEqual(response.version, .http2) + } + #endif + } + + func testSimplePost() { + #if compiler(>=5.5) && canImport(_Concurrency) + guard #available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *) else { return } + XCTAsyncTest { + let bin = HTTPBin(.http2(compress: false)) + defer { XCTAssertNoThrow(try bin.shutdown()) } + let client = makeDefaultHTTPClient() + defer { XCTAssertNoThrow(try client.syncShutdown()) } + let logger = Logger(label: "HTTPClient", factory: StreamLogHandler.standardOutput(label:)) + let request = HTTPClientRequest(url: "https://localhost:\(bin.port)/get") + + guard let response = await XCTAssertNoThrowWithResult( + try await client.execute(request, deadline: .now() + .seconds(10), logger: logger) + ) else { + return + } + + XCTAssertEqual(response.status, .ok) + XCTAssertEqual(response.version, .http2) + } + #endif + } + + func testPostWithByteBuffer() { + #if compiler(>=5.5) && canImport(_Concurrency) + guard #available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *) else { return } + XCTAsyncTest { + let bin = HTTPBin(.http2(compress: false)) { _ in HTTPEchoHandler() } + defer { XCTAssertNoThrow(try bin.shutdown()) } + let client = makeDefaultHTTPClient() + defer { XCTAssertNoThrow(try client.syncShutdown()) } + let logger = Logger(label: "HTTPClient", factory: StreamLogHandler.standardOutput(label:)) + var request = HTTPClientRequest(url: "https://localhost:\(bin.port)/") + request.method = .POST + request.body = .byteBuffer(ByteBuffer(string: "1234")) + + guard let response = await XCTAssertNoThrowWithResult( + try await client.execute(request, deadline: .now() + .seconds(10), logger: logger) + ) else { return } + XCTAssertEqual(response.headers["content-length"], ["4"]) + guard let body = await XCTAssertNoThrowWithResult( + try await response.body.collect() + ) else { return } + XCTAssertEqual(body, ByteBuffer(string: "1234")) + } + #endif + } + + func testPostWithSequenceOfUInt8() { + #if compiler(>=5.5) && canImport(_Concurrency) + guard #available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *) else { return } + XCTAsyncTest { + let bin = HTTPBin(.http2(compress: false)) { _ in HTTPEchoHandler() } + defer { XCTAssertNoThrow(try bin.shutdown()) } + let client = makeDefaultHTTPClient() + defer { XCTAssertNoThrow(try client.syncShutdown()) } + let logger = Logger(label: "HTTPClient", factory: StreamLogHandler.standardOutput(label:)) + var request = HTTPClientRequest(url: "https://localhost:\(bin.port)/") + request.method = .POST + request.body = .bytes(length: nil, AnySequence("1234".utf8)) + + guard let response = await XCTAssertNoThrowWithResult( + try await client.execute(request, deadline: .now() + .seconds(10), logger: logger) + ) else { return } + XCTAssertEqual(response.headers["content-length"], []) + guard let body = await XCTAssertNoThrowWithResult( + try await response.body.collect() + ) else { return } + XCTAssertEqual(body, ByteBuffer(string: "1234")) + } + #endif + } + + func testPostWithCollectionOfUInt8() { + #if compiler(>=5.5) && canImport(_Concurrency) + guard #available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *) else { return } + XCTAsyncTest { + let bin = HTTPBin(.http2(compress: false)) { _ in HTTPEchoHandler() } + defer { XCTAssertNoThrow(try bin.shutdown()) } + let client = makeDefaultHTTPClient() + defer { XCTAssertNoThrow(try client.syncShutdown()) } + let logger = Logger(label: "HTTPClient", factory: StreamLogHandler.standardOutput(label:)) + var request = HTTPClientRequest(url: "https://localhost:\(bin.port)/") + request.method = .POST + request.body = .bytes(length: nil, AnyCollection("1234".utf8)) + + guard let response = await XCTAssertNoThrowWithResult( + try await client.execute(request, deadline: .now() + .seconds(10), logger: logger) + ) else { return } + XCTAssertEqual(response.headers["content-length"], []) + guard let body = await XCTAssertNoThrowWithResult( + try await response.body.collect() + ) else { return } + XCTAssertEqual(body, ByteBuffer(string: "1234")) + } + #endif + } + + func testPostWithRandomAccessCollectionOfUInt8() { + #if compiler(>=5.5) && canImport(_Concurrency) + guard #available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *) else { return } + XCTAsyncTest { + let bin = HTTPBin(.http2(compress: false)) { _ in HTTPEchoHandler() } + defer { XCTAssertNoThrow(try bin.shutdown()) } + let client = makeDefaultHTTPClient() + defer { XCTAssertNoThrow(try client.syncShutdown()) } + let logger = Logger(label: "HTTPClient", factory: StreamLogHandler.standardOutput(label:)) + var request = HTTPClientRequest(url: "https://localhost:\(bin.port)/") + request.method = .POST + request.body = .bytes(ByteBuffer(string: "1234").readableBytesView) + + guard let response = await XCTAssertNoThrowWithResult( + try await client.execute(request, deadline: .now() + .seconds(10), logger: logger) + ) else { return } + XCTAssertEqual(response.headers["content-length"], ["4"]) + guard let body = await XCTAssertNoThrowWithResult( + try await response.body.collect() + ) else { return } + XCTAssertEqual(body, ByteBuffer(string: "1234")) + } + #endif + } + + func testPostWithAsyncSequenceOfByteBuffers() { + #if compiler(>=5.5) && canImport(_Concurrency) + guard #available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *) else { return } + XCTAsyncTest { + let bin = HTTPBin(.http2(compress: false)) { _ in HTTPEchoHandler() } + defer { XCTAssertNoThrow(try bin.shutdown()) } + let client = makeDefaultHTTPClient() + defer { XCTAssertNoThrow(try client.syncShutdown()) } + let logger = Logger(label: "HTTPClient", factory: StreamLogHandler.standardOutput(label:)) + var request = HTTPClientRequest(url: "https://localhost:\(bin.port)/") + request.method = .POST + request.body = .stream(length: nil, [ + ByteBuffer(string: "1"), + ByteBuffer(string: "2"), + ByteBuffer(string: "34"), + ].asAsyncSequence()) + + guard let response = await XCTAssertNoThrowWithResult( + try await client.execute(request, deadline: .now() + .seconds(10), logger: logger) + ) else { return } + XCTAssertEqual(response.headers["content-length"], []) + guard let body = await XCTAssertNoThrowWithResult( + try await response.body.collect() + ) else { return } + XCTAssertEqual(body, ByteBuffer(string: "1234")) + } + #endif + } + + func testPostWithAsyncSequenceOfUInt8() { + #if compiler(>=5.5) && canImport(_Concurrency) + guard #available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *) else { return } + XCTAsyncTest { + let bin = HTTPBin(.http2(compress: false)) { _ in HTTPEchoHandler() } + defer { XCTAssertNoThrow(try bin.shutdown()) } + let client = makeDefaultHTTPClient() + defer { XCTAssertNoThrow(try client.syncShutdown()) } + let logger = Logger(label: "HTTPClient", factory: StreamLogHandler.standardOutput(label:)) + var request = HTTPClientRequest(url: "https://localhost:\(bin.port)/") + request.method = .POST + request.body = .stream(length: nil, "1234".utf8.asAsyncSequence()) + + guard let response = await XCTAssertNoThrowWithResult( + try await client.execute(request, deadline: .now() + .seconds(10), logger: logger) + ) else { return } + XCTAssertEqual(response.headers["content-length"], []) + guard let body = await XCTAssertNoThrowWithResult( + try await response.body.collect() + ) else { return } + XCTAssertEqual(body, ByteBuffer(string: "1234")) + } + #endif + } + + func testPostWithFragmentedAsyncSequenceOfByteBuffers() { + #if compiler(>=5.5) && canImport(_Concurrency) + guard #available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *) else { return } + XCTAsyncTest { + let bin = HTTPBin(.http2(compress: false)) { _ in HTTPEchoHandler() } + defer { XCTAssertNoThrow(try bin.shutdown()) } + let client = makeDefaultHTTPClient() + defer { XCTAssertNoThrow(try client.syncShutdown()) } + let logger = Logger(label: "HTTPClient", factory: StreamLogHandler.standardOutput(label:)) + var request = HTTPClientRequest(url: "https://localhost:\(bin.port)/") + request.method = .POST + let streamWriter = AsyncSequenceWriter() + request.body = .stream(length: nil, streamWriter) + + guard let response = await XCTAssertNoThrowWithResult( + try await client.execute(request, deadline: .now() + .seconds(10), logger: logger) + ) else { return } + XCTAssertEqual(response.headers["content-length"], []) + + let fragments = [ + ByteBuffer(string: "1"), + ByteBuffer(string: "2"), + ByteBuffer(string: "34"), + ] + let bodyIterator = response.body.makeAsyncIterator() + for expectedFragment in fragments { + streamWriter.write(expectedFragment) + guard let actualFragment = await XCTAssertNoThrowWithResult( + try await bodyIterator.next() + ) else { return } + XCTAssertEqual(expectedFragment, actualFragment) + } + + streamWriter.end() + guard let lastResult = await XCTAssertNoThrowWithResult( + try await bodyIterator.next() + ) else { return } + XCTAssertEqual(lastResult, nil) + } + #endif + } + + func testPostWithFragmentedAsyncSequenceOfLargeByteBuffers() { + #if compiler(>=5.5) && canImport(_Concurrency) + guard #available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *) else { return } + XCTAsyncTest { + let bin = HTTPBin(.http2(compress: false)) { _ in HTTPEchoHandler() } + defer { XCTAssertNoThrow(try bin.shutdown()) } + let client = makeDefaultHTTPClient() + defer { XCTAssertNoThrow(try client.syncShutdown()) } + let logger = Logger(label: "HTTPClient", factory: StreamLogHandler.standardOutput(label:)) + var request = HTTPClientRequest(url: "https://localhost:\(bin.port)/") + request.method = .POST + let streamWriter = AsyncSequenceWriter() + request.body = .stream(length: nil, streamWriter) + + guard let response = await XCTAssertNoThrowWithResult( + try await client.execute(request, deadline: .now() + .seconds(10), logger: logger) + ) else { return } + XCTAssertEqual(response.headers["content-length"], []) + + let fragments = [ + ByteBuffer(string: String(repeating: "a", count: 4000)), + ByteBuffer(string: String(repeating: "b", count: 4000)), + ByteBuffer(string: String(repeating: "c", count: 4000)), + ByteBuffer(string: String(repeating: "d", count: 4000)), + ] + let bodyIterator = response.body.makeAsyncIterator() + for expectedFragment in fragments { + streamWriter.write(expectedFragment) + guard let actualFragment = await XCTAssertNoThrowWithResult( + try await bodyIterator.next() + ) else { return } + XCTAssertEqual(expectedFragment, actualFragment) + } + + streamWriter.end() + guard let lastResult = await XCTAssertNoThrowWithResult( + try await bodyIterator.next() + ) else { return } + XCTAssertEqual(lastResult, nil) + } + #endif + } + + func testCanceling() throws { + try XCTSkipIf(true, "test times out because of a swift concurrency bug: https://bugs.swift.org/browse/SR-15592") + #if compiler(>=5.5) && canImport(_Concurrency) + guard #available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *) else { return } + XCTAsyncTest(timeout: 5) { + let client = makeDefaultHTTPClient() + defer { XCTAssertNoThrow(try client.syncShutdown()) } + let logger = Logger(label: "HTTPClient", factory: StreamLogHandler.standardOutput(label:)) + var request = HTTPClientRequest(url: "https://localhost:45678/offline") + request.method = .POST + let streamWriter = AsyncSequenceWriter() + request.body = .stream(length: nil, streamWriter) + + let task = Task { [request] in + try await client.execute(request, deadline: .now() + .seconds(2), logger: logger) + } + task.cancel() + await XCTAssertThrowsError(try await task.value) { error in + XCTAssertEqual(error as? HTTPClientError, .cancelled) + } + } + #endif + } + + func testDeadline() throws { + try XCTSkipIf(true, "deadline is currently not correctly implemented. We only use it to timeout connection establishment. will be fixed in a follow up PR") + #if compiler(>=5.5) && canImport(_Concurrency) + guard #available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *) else { return } + XCTAsyncTest(timeout: 5) { + let bin = HTTPBin(.http2(compress: false)) + defer { XCTAssertNoThrow(try bin.shutdown()) } + let client = makeDefaultHTTPClient() + defer { XCTAssertNoThrow(try client.syncShutdown()) } + let logger = Logger(label: "HTTPClient", factory: StreamLogHandler.standardOutput(label:)) + let request = HTTPClientRequest(url: "https://localhost:\(bin.port)/wait") + + let task = Task { [request] in + try await client.execute(request, deadline: .now() + .seconds(1), logger: logger) + } + await XCTAssertThrowsError(try await task.value) { + XCTAssertEqual($0 as? HTTPClientError, HTTPClientError.readTimeout) + } + } + #endif + } + + func testConnectTimeout() { + #if compiler(>=5.5) && canImport(_Concurrency) + guard #available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *) else { return } + XCTAsyncTest(timeout: 5) { + let logger = Logger(label: "HTTPClient", factory: StreamLogHandler.standardOutput(label:)) + var config = HTTPClient.Configuration() + config.timeout.connect = .milliseconds(200) + let client = HTTPClient( + eventLoopGroupProvider: .createNew, + configuration: config, + backgroundActivityLogger: logger + ) + defer { XCTAssertNoThrow(try client.syncShutdown()) } + + let request = HTTPClientRequest(url: "https://localohst:9126") + + await XCTAssertThrowsError(try await client.execute(request, deadline: .now() + .seconds(2), logger: logger)) { + XCTAssertEqual($0 as? HTTPClientError, .connectTimeout) + } + } + #endif + } + + func testInvalidURL() { + #if compiler(>=5.5) && canImport(_Concurrency) + guard #available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *) else { return } + XCTAsyncTest(timeout: 5) { + let client = makeDefaultHTTPClient() + defer { XCTAssertNoThrow(try client.syncShutdown()) } + let logger = Logger(label: "HTTPClient", factory: StreamLogHandler.standardOutput(label:)) + let request = HTTPClientRequest(url: "") // invalid URL + + await XCTAssertThrowsError(try await client.execute(request, deadline: .now() + .seconds(2), logger: logger)) { + XCTAssertEqual($0 as? HTTPClientError, .invalidURL) + } + } + #endif + } +} + +#if compiler(>=5.5) && canImport(_Concurrency) +extension AsyncSequence where Element == ByteBuffer { + func collect() async throws -> ByteBuffer { + try await self.reduce(into: ByteBuffer()) { accumulatingBuffer, nextBuffer in + var nextBuffer = nextBuffer + accumulatingBuffer.writeBuffer(&nextBuffer) + } + } +} +#endif diff --git a/Tests/LinuxMain.swift b/Tests/LinuxMain.swift index b4440351d..cebced614 100644 --- a/Tests/LinuxMain.swift +++ b/Tests/LinuxMain.swift @@ -26,6 +26,7 @@ import XCTest @testable import AsyncHTTPClientTests XCTMain([ + testCase(AsyncAwaitEndToEndTests.allTests), testCase(HTTP1ClientChannelHandlerTests.allTests), testCase(HTTP1ConnectionStateMachineTests.allTests), testCase(HTTP1ConnectionTests.allTests), From 41e0578f94aa65705b371761672e50e3700ab44d Mon Sep 17 00:00:00 2001 From: David Nadoba Date: Wed, 15 Dec 2021 20:10:42 +0100 Subject: [PATCH 2/6] Fix testConnectTimeout --- .../AsyncAwaitEndToEndTests.swift | 33 ++++++++++++++++--- 1 file changed, 28 insertions(+), 5 deletions(-) diff --git a/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift b/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift index 7caf3fb34..6ed3600ed 100644 --- a/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift +++ b/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift @@ -368,6 +368,22 @@ final class AsyncAwaitEndToEndTests: XCTestCase { #if compiler(>=5.5) && canImport(_Concurrency) guard #available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *) else { return } XCTAsyncTest(timeout: 5) { + let group = MultiThreadedEventLoopGroup(numberOfThreads: 1) + defer { XCTAssertNoThrow(try group.syncShutdownGracefully()) } + + var maybeServer: Channel? + XCTAssertNoThrow(maybeServer = try ServerBootstrap(group: group) + .childChannelInitializer { channel in + channel.pipeline.addHandler(NeverrespondServerHandler()) + } + .bind(to: .init(ipAddress: "127.0.0.1", port: 0)) + .wait() + ) + guard let server = maybeServer else { return } + + defer { XCTAssertNoThrow(try server.close().wait()) } + + let logger = Logger(label: "HTTPClient", factory: StreamLogHandler.standardOutput(label:)) var config = HTTPClient.Configuration() config.timeout.connect = .milliseconds(200) @@ -377,11 +393,18 @@ final class AsyncAwaitEndToEndTests: XCTestCase { backgroundActivityLogger: logger ) defer { XCTAssertNoThrow(try client.syncShutdown()) } - - let request = HTTPClientRequest(url: "https://localohst:9126") - - await XCTAssertThrowsError(try await client.execute(request, deadline: .now() + .seconds(2), logger: logger)) { - XCTAssertEqual($0 as? HTTPClientError, .connectTimeout) + let port = server.localAddress!.port! + + let request = HTTPClientRequest(url: "https://localhost:\(port)") + + await XCTAssertThrowsError(try await client.execute(request, deadline: .now() + .seconds(1), logger: logger)) { error in + guard let httpError = error as? HTTPClientError else { + return XCTFail("wrong error \(error)") + } + XCTAssertTrue( + [HTTPClientError.connectTimeout, .tlsHandshakeTimeout].contains(httpError), + "wrong http error \(httpError)" + ) } } #endif From 5d0d4031380c47805badd03a548bac0276fd16c7 Mon Sep 17 00:00:00 2001 From: David Nadoba Date: Wed, 15 Dec 2021 20:13:20 +0100 Subject: [PATCH 3/6] enable testCanceling on linux --- Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift b/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift index 6ed3600ed..7c1a25adf 100644 --- a/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift +++ b/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift @@ -319,7 +319,10 @@ final class AsyncAwaitEndToEndTests: XCTestCase { } func testCanceling() throws { - try XCTSkipIf(true, "test times out because of a swift concurrency bug: https://bugs.swift.org/browse/SR-15592") + #if os(Linux) + #else + try XCTSkipIf(true, "test times out because of a swift concurrency bug on macOS: https://bugs.swift.org/browse/SR-15592") + #endif #if compiler(>=5.5) && canImport(_Concurrency) guard #available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *) else { return } XCTAsyncTest(timeout: 5) { From 8dd88fb83d6d12cdc7442b242ed5470c984ea08f Mon Sep 17 00:00:00 2001 From: David Nadoba Date: Thu, 16 Dec 2021 08:38:26 +0100 Subject: [PATCH 4/6] SwiftFormat --- Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift b/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift index 7c1a25adf..268a65ea7 100644 --- a/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift +++ b/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift @@ -385,8 +385,7 @@ final class AsyncAwaitEndToEndTests: XCTestCase { guard let server = maybeServer else { return } defer { XCTAssertNoThrow(try server.close().wait()) } - - + let logger = Logger(label: "HTTPClient", factory: StreamLogHandler.standardOutput(label:)) var config = HTTPClient.Configuration() config.timeout.connect = .milliseconds(200) From 11233c455d82390c12d2c1bc9eb114367546234b Mon Sep 17 00:00:00 2001 From: David Nadoba Date: Thu, 16 Dec 2021 14:12:33 +0100 Subject: [PATCH 5/6] fix review comments --- .../AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift b/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift index 268a65ea7..549a5a988 100644 --- a/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift +++ b/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift @@ -383,8 +383,8 @@ final class AsyncAwaitEndToEndTests: XCTestCase { .wait() ) guard let server = maybeServer else { return } - - defer { XCTAssertNoThrow(try server.close().wait()) } + let port = server.localAddress!.port! + XCTAssertNoThrow(try server.close().wait()) let logger = Logger(label: "HTTPClient", factory: StreamLogHandler.standardOutput(label:)) var config = HTTPClient.Configuration() @@ -395,7 +395,6 @@ final class AsyncAwaitEndToEndTests: XCTestCase { backgroundActivityLogger: logger ) defer { XCTAssertNoThrow(try client.syncShutdown()) } - let port = server.localAddress!.port! let request = HTTPClientRequest(url: "https://localhost:\(port)") @@ -403,10 +402,7 @@ final class AsyncAwaitEndToEndTests: XCTestCase { guard let httpError = error as? HTTPClientError else { return XCTFail("wrong error \(error)") } - XCTAssertTrue( - [HTTPClientError.connectTimeout, .tlsHandshakeTimeout].contains(httpError), - "wrong http error \(httpError)" - ) + XCTAssertEqual(httpError, .connectTimeout) } } #endif From 3619f063b78e2ace711b8381968a3c7ddff0a4f3 Mon Sep 17 00:00:00 2001 From: David Nadoba Date: Thu, 16 Dec 2021 16:31:05 +0100 Subject: [PATCH 6/6] Remove testConnectTimeout test --- .../AsyncAwaitEndToEndTests+XCTest.swift | 1 - .../AsyncAwaitEndToEndTests.swift | 41 ------------------- 2 files changed, 42 deletions(-) diff --git a/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests+XCTest.swift b/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests+XCTest.swift index c258534bc..031f5eba5 100644 --- a/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests+XCTest.swift +++ b/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests+XCTest.swift @@ -37,7 +37,6 @@ extension AsyncAwaitEndToEndTests { ("testPostWithFragmentedAsyncSequenceOfLargeByteBuffers", testPostWithFragmentedAsyncSequenceOfLargeByteBuffers), ("testCanceling", testCanceling), ("testDeadline", testDeadline), - ("testConnectTimeout", testConnectTimeout), ("testInvalidURL", testInvalidURL), ] } diff --git a/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift b/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift index 549a5a988..94723496b 100644 --- a/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift +++ b/Tests/AsyncHTTPClientTests/AsyncAwaitEndToEndTests.swift @@ -367,47 +367,6 @@ final class AsyncAwaitEndToEndTests: XCTestCase { #endif } - func testConnectTimeout() { - #if compiler(>=5.5) && canImport(_Concurrency) - guard #available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *) else { return } - XCTAsyncTest(timeout: 5) { - let group = MultiThreadedEventLoopGroup(numberOfThreads: 1) - defer { XCTAssertNoThrow(try group.syncShutdownGracefully()) } - - var maybeServer: Channel? - XCTAssertNoThrow(maybeServer = try ServerBootstrap(group: group) - .childChannelInitializer { channel in - channel.pipeline.addHandler(NeverrespondServerHandler()) - } - .bind(to: .init(ipAddress: "127.0.0.1", port: 0)) - .wait() - ) - guard let server = maybeServer else { return } - let port = server.localAddress!.port! - XCTAssertNoThrow(try server.close().wait()) - - let logger = Logger(label: "HTTPClient", factory: StreamLogHandler.standardOutput(label:)) - var config = HTTPClient.Configuration() - config.timeout.connect = .milliseconds(200) - let client = HTTPClient( - eventLoopGroupProvider: .createNew, - configuration: config, - backgroundActivityLogger: logger - ) - defer { XCTAssertNoThrow(try client.syncShutdown()) } - - let request = HTTPClientRequest(url: "https://localhost:\(port)") - - await XCTAssertThrowsError(try await client.execute(request, deadline: .now() + .seconds(1), logger: logger)) { error in - guard let httpError = error as? HTTPClientError else { - return XCTFail("wrong error \(error)") - } - XCTAssertEqual(httpError, .connectTimeout) - } - } - #endif - } - func testInvalidURL() { #if compiler(>=5.5) && canImport(_Concurrency) guard #available(macOS 12.0, iOS 15.0, watchOS 8.0, tvOS 15.0, *) else { return }