Support options on AsyncTestingChannel and EmbeddedChannel (#3308)

Support options on AsyncTestingChannel and EmbeddedChannel

Fixes #3305 

### Motivation:

The channels are intended for testing purposes so while most options
have no practical use setting and getting them can be useful for
testing.

For example a traceroute implementation will set TTL to the current hop
number. Testing such an implementation requires the channels to pretend
to support the TTL option.

### Modifications:

Added option storage to AsyncTestingChannel and EmbedededChannel and
made `getOptionSync` and `setOptionSync` read and write from that
storage.

### Result:

EmbeddedChannel and AsyncTestingChannel support changing their options.

---------

Co-authored-by: Cory Benfield <[email protected]>

Author: klaaspieter

Sources/NIOEmbedded/AsyncTestingChannel.swift

@@ -205,15 +205,20 @@ public final class NIOAsyncTestingChannel: Channel {
     nonisolated(unsafe) var channelcore: EmbeddedChannelCore!
     nonisolated(unsafe) private var _pipeline: ChannelPipeline!
 
-    private struct State {
+    @usableFromInline
+    internal struct State: Sendable {
         var isWritable: Bool
         var localAddress: SocketAddress?
         var remoteAddress: SocketAddress?
+
+        @usableFromInline
+        var options: [(option: any ChannelOption, value: any Sendable)]
     }
 
     /// Guards any of the getters/setters that can be accessed from any thread.
-    private let stateLock = NIOLockedValueBox(
-        State(isWritable: true, localAddress: nil, remoteAddress: nil)
+    @usableFromInline
+    internal let _stateLock = NIOLockedValueBox(
+        State(isWritable: true, localAddress: nil, remoteAddress: nil, options: [])
     )
 
     /// - see: `Channel._channelCore`
@@ -229,10 +234,10 @@ public final class NIOAsyncTestingChannel: Channel {
     /// - see: `Channel.isWritable`
     public var isWritable: Bool {
         get {
-            self.stateLock.withLockedValue { $0.isWritable }
+            self._stateLock.withLockedValue { $0.isWritable }
         }
         set {
-            self.stateLock.withLockedValue {
+            self._stateLock.withLockedValue {
                 $0.isWritable = newValue
             }
         }
@@ -241,10 +246,10 @@ public final class NIOAsyncTestingChannel: Channel {
     /// - see: `Channel.localAddress`
     public var localAddress: SocketAddress? {
         get {
-            self.stateLock.withLockedValue { $0.localAddress }
+            self._stateLock.withLockedValue { $0.localAddress }
         }
         set {
-            self.stateLock.withLockedValue {
+            self._stateLock.withLockedValue {
                 $0.localAddress = newValue
             }
         }
@@ -253,15 +258,20 @@ public final class NIOAsyncTestingChannel: Channel {
     /// - see: `Channel.remoteAddress`
     public var remoteAddress: SocketAddress? {
         get {
-            self.stateLock.withLockedValue { $0.remoteAddress }
+            self._stateLock.withLockedValue { $0.remoteAddress }
         }
         set {
-            self.stateLock.withLockedValue {
+            self._stateLock.withLockedValue {
                 $0.remoteAddress = newValue
             }
         }
     }
 
+    /// The `ChannelOption`s set on this channel.
+    /// - see: `NIOAsyncTestingChannel.setOption`
+    public var options: [(option: any ChannelOption, value: any Sendable)] {
+        self._stateLock.withLockedValue { $0.options }
+    }
     /// Create a new instance.
     ///
     /// During creation it will automatically also register itself on the ``NIOAsyncTestingEventLoop``.
@@ -572,12 +582,12 @@ public final class NIOAsyncTestingChannel: Channel {
 
     @inlinable
     internal func setOptionSync<Option: ChannelOption>(_ option: Option, value: Option.Value) {
+        addOption(option, value: value)
+
         if option is ChannelOptions.Types.AllowRemoteHalfClosureOption {
             self.allowRemoteHalfClosure = value as! Bool
             return
         }
-        // No other options supported
-        fatalError("option not supported")
     }
 
     /// - see: `Channel.getOption`
@@ -606,7 +616,32 @@ public final class NIOAsyncTestingChannel: Channel {
 
             return result as! Option.Value
         }
-        fatalError("option \(option) not supported")
+
+        guard let value = self.optionValue(for: option) else {
+            fatalError("option \(option) not supported")
+        }
+
+        return value
+    }
+
+    @inlinable
+    internal func optionValue<Option: ChannelOption>(for option: Option) -> Option.Value? {
+        self.options.first(where: { $0.option is Option })?.value as? Option.Value
+    }
+
+    @inlinable
+    internal func addOption<Option: ChannelOption>(_ option: Option, value: Option.Value) {
+        // override the option if it exists
+        self._stateLock.withLockedValue { state in
+            var options = state.options
+            let optionIndex = options.firstIndex(where: { $0.option is Option })
+            if let optionIndex = optionIndex {
+                options[optionIndex] = (option, value)
+            } else {
+                options.append((option, value))
+            }
+            state.options = options
+        }
     }
 
     /// Fires the (outbound) `bind` event through the `ChannelPipeline`. If the event hits the ``NIOAsyncTestingChannel`` which

Sources/NIOEmbedded/Embedded.swift

@@ -795,6 +795,13 @@ public final class EmbeddedChannel: Channel {
     /// - see: `Channel.isWritable`
     public var isWritable: Bool = true
 
+    @usableFromInline
+    internal var _options: [(option: any ChannelOption, value: any Sendable)] = []
+
+    /// The `ChannelOption`s set on this channel.
+    /// - see: `Embedded.setOption`
+    public var options: [(option: any ChannelOption, value: any Sendable)] { self._options }
+
     /// Synchronously closes the `EmbeddedChannel`.
     ///
     /// Errors in the `EmbeddedChannel` can be consumed using `throwIfErrorCaught`.
@@ -1023,12 +1030,13 @@ public final class EmbeddedChannel: Channel {
     @inlinable
     internal func setOptionSync<Option: ChannelOption>(_ option: Option, value: Option.Value) {
         self.embeddedEventLoop.checkCorrectThread()
+
+        self.addOption(option, value: value)
+
         if option is ChannelOptions.Types.AllowRemoteHalfClosureOption {
             self.allowRemoteHalfClosure = value as! Bool
             return
         }
-        // No other options supported
-        fatalError("option not supported")
     }
 
     /// - see: `Channel.getOption`
@@ -1055,7 +1063,26 @@ public final class EmbeddedChannel: Channel {
 
             return result as! Option.Value
         }
-        fatalError("option \(option) not supported")
+
+        guard let value = optionValue(for: option) else {
+            fatalError("option \(option) not supported")
+        }
+
+        return value
+    }
+
+    @inlinable
+    internal func addOption<Option: ChannelOption>(_ option: Option, value: Option.Value) {
+        if let optionIndex = self._options.firstIndex(where: { $0.option is Option }) {
+            self._options[optionIndex] = (option: option, value: value)
+        } else {
+            self._options.append((option: option, value: value))
+        }
+    }
+
+    @inlinable
+    internal func optionValue<Option: ChannelOption>(for option: Option) -> Option.Value? {
+        self.options.first(where: { $0.option is Option })?.value as? Option.Value
     }
 
     /// Fires the (outbound) `bind` event through the `ChannelPipeline`. If the event hits the `EmbeddedChannel` which

Tests/NIOEmbeddedTests/AsyncTestingChannelTests.swift

@@ -681,6 +681,19 @@ class AsyncTestingChannelTests: XCTestCase {
         try await XCTAsyncAssertEqual(buf, try await channel.waitForOutboundWrite(as: ByteBuffer.self))
         try await XCTAsyncAssertTrue(try await channel.finish().isClean)
     }
+
+    func testGetSetOption() async throws {
+        let channel = NIOAsyncTestingChannel()
+        let option = ChannelOptions.socket(IPPROTO_IP, IP_TTL)
+        let _ = try await channel.setOption(option, value: 1).get()
+
+        let optionValue1 = try await channel.getOption(option).get()
+        XCTAssertEqual(1, optionValue1)
+
+        let _ = try await channel.setOption(option, value: 2).get()
+        let optionValue2 = try await channel.getOption(option).get()
+        XCTAssertEqual(2, optionValue2)
+    }
 }
 
 @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)

Tests/NIOEmbeddedTests/EmbeddedChannelTest.swift

@@ -692,4 +692,17 @@ class EmbeddedChannelTest: XCTestCase {
         XCTAssertEqual(buf, try channel.readOutbound(as: ByteBuffer.self))
         XCTAssertTrue(try channel.finish().isClean)
     }
+
+    func testGetSetOption() throws {
+        let channel = EmbeddedChannel()
+        let option = ChannelOptions.socket(IPPROTO_IP, IP_TTL)
+        let _ = channel.setOption(option, value: 1)
+
+        let optionValue1 = try channel.getOption(option).wait()
+        XCTAssertEqual(1, optionValue1)
+
+        let _ = channel.setOption(option, value: 2)
+        let optionValue2 = try channel.getOption(option).wait()
+        XCTAssertEqual(2, optionValue2)
+    }
 }