fix test

Author: sfackler

tokio-postgres/src/cancel_query.rs

@@ -24,11 +24,10 @@ where
         }
     };
 
-    let tls = config
-        .hostname
-        .map(|s| tls.make_tls_connect(&s))
-        .transpose()
+    let tls = tls
+        .make_tls_connect(config.hostname.as_deref().unwrap_or(""))
         .map_err(|e| Error::tls(e.into()))?;
+    let has_hostname = config.hostname.is_some();
 
     let socket = connect_socket::connect_socket(
         &config.host,
@@ -39,5 +38,6 @@ where
     )
     .await?;
 
-    cancel_query_raw::cancel_query_raw(socket, ssl_mode, tls, process_id, secret_key).await
+    cancel_query_raw::cancel_query_raw(socket, ssl_mode, tls, has_hostname, process_id, secret_key)
+        .await
 }

tokio-postgres/src/cancel_query_raw.rs

@@ -8,15 +8,16 @@ use tokio::io::{AsyncRead, AsyncWrite, AsyncWriteExt};
 pub async fn cancel_query_raw<S, T>(
     stream: S,
     mode: SslMode,
-    tls: Option<T>,
+    tls: T,
+    has_hostname: bool,
     process_id: i32,
     secret_key: i32,
 ) -> Result<(), Error>
 where
     S: AsyncRead + AsyncWrite + Unpin,
     T: TlsConnect<S>,
 {
-    let mut stream = connect_tls::connect_tls(stream, mode, tls).await?;
+    let mut stream = connect_tls::connect_tls(stream, mode, tls, has_hostname).await?;
 
     let mut buf = BytesMut::new();
     frontend::cancel_request(process_id, secret_key, &mut buf);

tokio-postgres/src/cancel_token.rs

@@ -54,7 +54,8 @@ impl CancelToken {
         cancel_query_raw::cancel_query_raw(
             stream,
             self.ssl_mode,
-            Some(tls),
+            tls,
+            true,
             self.process_id,
             self.secret_key,
         )

tokio-postgres/src/config.rs

@@ -645,7 +645,7 @@ impl Config {
         S: AsyncRead + AsyncWrite + Unpin,
         T: TlsConnect<S>,
     {
-        connect_raw(stream, Some(tls), self).await
+        connect_raw(stream, tls, true, self).await
     }
 }
 

tokio-postgres/src/connect.rs

@@ -59,10 +59,8 @@ where
             Some(Host::Unix(_)) => None,
             None => None,
         };
-        let tls = hostname
-            .as_ref()
-            .map(|s| tls.make_tls_connect(s))
-            .transpose()
+        let tls = tls
+            .make_tls_connect(hostname.as_deref().unwrap_or(""))
             .map_err(|e| Error::tls(e.into()))?;
 
         // Try to use the value of hostaddr to establish the TCP connection,
@@ -92,7 +90,7 @@ async fn connect_once<T>(
     host: Host,
     hostname: Option<String>,
     port: u16,
-    tls: Option<T>,
+    tls: T,
     config: &Config,
 ) -> Result<(Client, Connection<Socket, T::Stream>), Error>
 where
@@ -110,7 +108,8 @@ where
         },
     )
     .await?;
-    let (mut client, mut connection) = connect_raw(socket, tls, config).await?;
+    let has_hostname = hostname.is_some();
+    let (mut client, mut connection) = connect_raw(socket, tls, has_hostname, config).await?;
 
     if let TargetSessionAttrs::ReadWrite = config.target_session_attrs {
         let rows = client.simple_query_raw("SHOW transaction_read_only");

tokio-postgres/src/connect_raw.rs

@@ -80,14 +80,15 @@ where
 
 pub async fn connect_raw<S, T>(
     stream: S,
-    tls: Option<T>,
+    tls: T,
+    has_hostname: bool,
     config: &Config,
 ) -> Result<(Client, Connection<S, T::Stream>), Error>
 where
     S: AsyncRead + AsyncWrite + Unpin,
     T: TlsConnect<S>,
 {
-    let stream = connect_tls(stream, config.ssl_mode, tls).await?;
+    let stream = connect_tls(stream, config.ssl_mode, tls, has_hostname).await?;
 
     let mut stream = StartupStream {
         inner: Framed::new(stream, PostgresCodec),

tokio-postgres/src/connect_tls.rs

@@ -10,19 +10,16 @@ use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt};
 pub async fn connect_tls<S, T>(
     mut stream: S,
     mode: SslMode,
-    tls: Option<T>,
+    tls: T,
+    has_hostname: bool,
 ) -> Result<MaybeTlsStream<S, T::Stream>, Error>
 where
     S: AsyncRead + AsyncWrite + Unpin,
     T: TlsConnect<S>,
 {
     match mode {
         SslMode::Disable => return Ok(MaybeTlsStream::Raw(stream)),
-        SslMode::Prefer
-            if tls
-                .as_ref()
-                .map_or(false, |tls| !tls.can_connect(ForcePrivateApi)) =>
-        {
+        SslMode::Prefer if !tls.can_connect(ForcePrivateApi) => {
             return Ok(MaybeTlsStream::Raw(stream))
         }
         SslMode::Prefer | SslMode::Require => {}
@@ -43,8 +40,11 @@ where
         }
     }
 
+    if !has_hostname {
+        return Err(Error::tls("no hostname provided for TLS handshake".into()));
+    }
+
     let stream = tls
-        .ok_or_else(|| Error::tls("no hostname provided for TLS handshake".into()))?
         .connect(stream)
         .await
         .map_err(|e| Error::tls(e.into()))?;