Actually use additional connection parameters (vapor#473)

Author: MahdiBM

Sources/PostgresNIO/New/PostgresChannelHandler.swift

@@ -390,7 +390,8 @@ final class PostgresChannelHandler: ChannelDuplexHandler {
                 let authContext = AuthContext(
                     username: username,
                     password: self.configuration.password,
-                    database: self.configuration.database
+                    database: self.configuration.database,
+                    additionalParameters: self.configuration.options.additionalStartupParameters
                 )
                 let action = self.state.provideAuthenticationContext(authContext)
                 return self.run(action, with: context)

Tests/IntegrationTests/AsyncTests.swift

@@ -84,6 +84,36 @@ final class AsyncPostgresConnectionTests: XCTestCase {
         }
     }
 
+    func testAdditionalParametersTakeEffect() async throws {
+        let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+        defer { XCTAssertNoThrow(try eventLoopGroup.syncShutdownGracefully()) }
+        let eventLoop = eventLoopGroup.next()
+
+        let query: PostgresQuery = """
+            SELECT
+                current_setting('application_name');
+            """
+
+        let applicationName = "postgres-nio-test"
+        var options = PostgresConnection.Configuration.Options()
+        options.additionalStartupParameters = [
+            ("application_name", applicationName)
+        ]
+
+        try await withTestConnection(on: eventLoop, options: options) { connection in
+            let rows = try await connection.query(query, logger: .psqlTest)
+            var counter = 0
+
+            for try await element in rows.decode(String.self) {
+                XCTAssertEqual(element, applicationName)
+                
+                counter += 1
+            }
+
+            XCTAssertGreaterThanOrEqual(counter, 1)
+        }
+    }
+
     func testSelectTimeoutWhileLongRunningQuery() async throws {
         let eventLoopGroup = MultiThreadedEventLoopGroup(numberOfThreads: 1)
         defer { XCTAssertNoThrow(try eventLoopGroup.syncShutdownGracefully()) }
@@ -452,11 +482,12 @@ extension XCTestCase {
 
     func withTestConnection<Result>(
         on eventLoop: EventLoop,
+        options: PostgresConnection.Configuration.Options? = nil,
         file: StaticString = #filePath,
         line: UInt = #line,
         _ closure: (PostgresConnection) async throws -> Result
     ) async throws -> Result  {
-        let connection = try await PostgresConnection.test(on: eventLoop).get()
+        let connection = try await PostgresConnection.test(on: eventLoop, options: options).get()
 
         do {
             let result = try await closure(connection)

Tests/IntegrationTests/Utilities.swift

@@ -24,17 +24,20 @@ extension PostgresConnection {
         }
     }
 
-    static func test(on eventLoop: EventLoop) -> EventLoopFuture<PostgresConnection> {
+    static func test(on eventLoop: EventLoop, options: Configuration.Options? = nil) -> EventLoopFuture<PostgresConnection> {
         let logger = Logger(label: "postgres.connection.test")
-        let config = PostgresConnection.Configuration(
+        var config = PostgresConnection.Configuration(
             host: env("POSTGRES_HOSTNAME") ?? "localhost",
             port: env("POSTGRES_PORT").flatMap(Int.init(_:)) ?? 5432,
             username: env("POSTGRES_USER") ?? "test_username",
             password: env("POSTGRES_PASSWORD") ?? "test_password",
             database: env("POSTGRES_DB") ?? "test_database",
             tls: .disable
         )
-
+        if let options {
+            config.options = options
+        }
+        
         return PostgresConnection.connect(on: eventLoop, configuration: config, id: 0, logger: logger)
     }
 

Tests/PostgresNIOTests/New/PostgresConnectionTests.swift

@@ -38,6 +38,48 @@ class PostgresConnectionTests: XCTestCase {
         }
     }
 
+    func testOptionsAreSentOnTheWire() async throws {
+        let eventLoop = NIOAsyncTestingEventLoop()
+        let channel = await NIOAsyncTestingChannel(handlers: [
+            ReverseByteToMessageHandler(PSQLFrontendMessageDecoder()),
+            ReverseMessageToByteHandler(PSQLBackendMessageEncoder()),
+        ], loop: eventLoop)
+        try await channel.connect(to: .makeAddressResolvingHost("localhost", port: 5432))
+
+        let configuration = {
+            var config = PostgresConnection.Configuration(
+                establishedChannel: channel,
+                username: "username",
+                password: "postgres",
+                database: "database"
+            )
+            config.options.additionalStartupParameters = [
+                ("DateStyle", "ISO, MDY"),
+                ("application_name", "postgres-nio-test"),
+                ("server_encoding", "UTF8"),
+                ("integer_datetimes", "on"),
+                ("client_encoding", "UTF8"),
+                ("TimeZone", "Etc/UTC"),
+                ("is_superuser", "on"),
+                ("server_version", "13.1 (Debian 13.1-1.pgdg100+1)"),
+                ("session_authorization", "postgres"),
+                ("IntervalStyle", "postgres"),
+                ("standard_conforming_strings", "on")
+            ]
+            return config
+        }()
+
+        async let connectionPromise = PostgresConnection.connect(on: eventLoop, configuration: configuration, id: 1, logger: .psqlTest)
+        let message = try await channel.waitForOutboundWrite(as: PostgresFrontendMessage.self)
+        XCTAssertEqual(message, .startup(.versionThree(parameters: .init(user: "username", database: "database", options: configuration.options.additionalStartupParameters, replication: .false))))
+        try await channel.writeInbound(PostgresBackendMessage.authentication(.ok))
+        try await channel.writeInbound(PostgresBackendMessage.backendKeyData(.init(processID: 1234, secretKey: 5678)))
+        try await channel.writeInbound(PostgresBackendMessage.readyForQuery(.idle))
+
+        let connection = try await connectionPromise
+        try await connection.close()
+    }
+
     func testSimpleListen() async throws {
         let (connection, channel) = try await self.makeTestConnectionWithAsyncTestingChannel()