RSCBC-147: Fix http tests when running against cluster_run

Fix test_json_block_read in tests/http.rs to use the http port, not
just assume 8091.

Author: Peter-Searby

sdk/couchbase-core/tests/common/default_agent_options.rs

@@ -9,18 +9,7 @@ use {
 };
 
 pub async fn create_default_options(config: TestSetupConfig) -> AgentOptions {
-    let tls_config = if config.use_ssl {
-        #[cfg(feature = "native-tls")]
-        {
-            let mut builder = tokio_native_tls::native_tls::TlsConnector::builder();
-            builder.danger_accept_invalid_certs(true);
-            Some(builder.build().unwrap())
-        }
-        #[cfg(all(feature = "rustls-tls", not(feature = "native-tls")))]
-        Some(get_rustls_config())
-    } else {
-        None
-    };
+    let tls_config = create_tls_config(&config);
 
     AgentOptions::new(
         SeedConfig::new()
@@ -35,6 +24,23 @@ pub async fn create_default_options(config: TestSetupConfig) -> AgentOptions {
     .bucket_name(config.bucket.clone())
 }
 
+pub fn create_tls_config(
+    config: &TestSetupConfig,
+) -> std::option::Option<std::sync::Arc<tokio_rustls::rustls::ClientConfig>> {
+    if config.use_ssl {
+        #[cfg(feature = "native-tls")]
+        {
+            let mut builder = tokio_native_tls::native_tls::TlsConnector::builder();
+            builder.danger_accept_invalid_certs(true);
+            Some(builder.build().unwrap())
+        }
+        #[cfg(all(feature = "rustls-tls", not(feature = "native-tls")))]
+        Some(get_rustls_config())
+    } else {
+        None
+    }
+}
+
 pub async fn create_options_without_bucket(config: TestSetupConfig) -> AgentOptions {
     let tls_config = if config.use_ssl {
         #[cfg(feature = "native-tls")]

sdk/couchbase-core/tests/common/test_config.rs

@@ -48,6 +48,7 @@ pub struct TestSetupConfig {
     pub username: String,
     pub password: String,
     pub memd_addrs: Vec<Address>,
+    pub http_addrs: Vec<Address>,
     pub data_timeout: String,
     pub use_ssl: bool,
     pub bucket: String,
@@ -166,6 +167,7 @@ pub async fn create_test_config(test_config: &EnvTestConfig) -> TestSetupConfig
         username: test_config.username.clone(),
         password: test_config.password.clone(),
         memd_addrs: resolved_conn_spec.memd_hosts.clone(),
+        http_addrs: resolved_conn_spec.http_hosts.clone(),
         data_timeout: test_config.data_timeout.clone(),
         use_ssl: resolved_conn_spec.use_ssl,
         bucket: test_config.default_bucket.clone(),

sdk/couchbase-core/tests/http.rs

@@ -1,6 +1,7 @@
+use crate::common::default_agent_options::create_tls_config;
 use crate::common::test_config::setup_test;
 use bytes::Bytes;
-use couchbase_core::httpx::client::{Client, ClientConfig, ReqwestClient};
+use couchbase_core::httpx::client::{self, Client, ClientConfig, ReqwestClient};
 use couchbase_core::httpx::decoder::Decoder;
 use couchbase_core::httpx::raw_json_row_streamer::{RawJsonRowItem, RawJsonRowStreamer};
 use couchbase_core::httpx::request::{Auth, BasicAuth, Request};
@@ -47,22 +48,26 @@ pub struct QueryMetrics {
 #[test]
 fn test_row_streamer() {
     setup_test(async |config| {
-        let addrs = config.memd_addrs;
+        let scheme = if config.use_ssl { "https" } else { "http" };
+        let addrs = &config.http_addrs;
 
-        let host = addrs.first().unwrap().host.clone();
+        let addr = addrs.first().unwrap();
+        let host = &addr.host;
+        let port = addr.port;
 
-        let basic_auth = BasicAuth::new(config.username, config.password);
+        let basic_auth = BasicAuth::new(&config.username, &config.password);
 
         let request_body = json!({"statement": "select i from array_range(1, 10000) AS i;"});
-        let uri = format!("http://{host}:8093/query/service");
+        let uri = format!("{scheme}://{host}:{port}/_p/query/query/service");
 
         let request = Request::new(Method::POST, uri)
             .user_agent("rscbcorex".to_string())
             .auth(Auth::BasicAuth(basic_auth))
             .content_type("application/json".to_string())
             .body(Bytes::from(serde_json::to_vec(&request_body).unwrap()));
 
-        let client = ReqwestClient::new(ClientConfig::default()).unwrap();
+        let client_config = ClientConfig::default().tls_config(create_tls_config(&config));
+        let client = ReqwestClient::new(client_config).unwrap();
 
         let resp = timeout(Duration::from_secs(10), client.execute(request))
             .await
@@ -116,19 +121,23 @@ fn test_row_streamer() {
 #[test]
 fn test_json_block_read() {
     setup_test(async |config| {
-        let addrs = config.memd_addrs;
+        let scheme = if config.use_ssl { "https" } else { "http" };
+        let addrs = &config.http_addrs;
 
-        let host = addrs.first().unwrap().host.clone();
+        let addr = addrs.first().unwrap();
+        let host = &addr.host;
+        let port = addr.port;
 
-        let basic_auth = BasicAuth::new(config.username, config.password);
-        let uri = format!("http://{host}:8091/pools/default/terseClusterInfo");
+        let basic_auth = BasicAuth::new(&config.username, &config.password);
+        let uri = format!("{scheme}://{host}:{port}/pools/default/terseClusterInfo");
 
         let request = Request::new(Method::GET, uri)
             .user_agent("rscbcorex".to_string())
             .auth(Auth::BasicAuth(basic_auth))
             .content_type("application/json".to_string());
 
-        let client = ReqwestClient::new(ClientConfig::default()).expect("could not create client");
+        let client_config = ClientConfig::default().tls_config(create_tls_config(&config));
+        let client = ReqwestClient::new(client_config).expect("could not create client");
 
         let res = timeout(Duration::from_secs(10), client.execute(request))
             .await