Merge branch 'main' into refact/hide-json-models

Author: jgsogo

.github/dependabot.yml

@@ -4,4 +4,4 @@ updates:
     directory: "/"
     # Check for updates every Monday
     schedule:
-      interval: "weekly"
+      interval: "weekly"

.github/workflows/main.yml

@@ -20,7 +20,7 @@ jobs:
       run: cargo build --verbose --workspace
     # Tests: we only run library and documentation tests (integration tests are using the remote server!)
     - name: Run tests (unittests)
-      run: cargo test --lib --verbose --workspace
+      run: cargo test --verbose --workspace
     - name: Run tests (documentation tests)
       run: cargo test --doc --verbose --workspace
 

Cargo.toml

@@ -18,6 +18,9 @@ exclude = [
     "README.tpl",
 ]
 
+[features]
+http_client = []
+
 [dependencies]
 reqwest = { version = "0.12.9", features = ["json", "blocking"] }
 serde = { version = "1.0.216", features = ["derive"] }
@@ -28,6 +31,7 @@ url = "2.5.4"
 thiserror = "2.0.7"
 
 [dev-dependencies]
+appconfiguration = {path = ".", features = ["http_client"]}
 dotenvy = "0.15.7"
 rstest = "0.23.0"
 

src/client/app_configuration_http.rs

@@ -18,8 +18,8 @@ use crate::client::feature_snapshot::FeatureSnapshot;
 pub use crate::client::property_proxy::PropertyProxy;
 use crate::client::property_snapshot::PropertySnapshot;
 use crate::errors::{ConfigurationAccessError, Error, Result};
-use crate::TokenProvider;
-use crate::{ServerClientImpl, ServiceAddress};
+use crate::network::{ServiceAddress, TokenProvider};
+use crate::ServerClientImpl;
 use std::net::TcpStream;
 use std::sync::{Arc, Mutex};
 use std::thread;

src/client/app_configuration_ibm_cloud.rs

@@ -17,8 +17,8 @@ use crate::client::feature_snapshot::FeatureSnapshot;
 pub use crate::client::property_proxy::PropertyProxy;
 use crate::client::property_snapshot::PropertySnapshot;
 use crate::errors::Result;
+use crate::network::ServiceAddress;
 use crate::IBMCloudTokenProvider;
-use crate::ServiceAddress;
 
 use super::AppConfigurationClientHttp;
 use super::{AppConfigurationClient, ConfigurationId};
@@ -91,17 +91,18 @@ impl AppConfigurationClient for AppConfigurationClientIBMCloud {
 mod tests {
 
     use super::*;
+    use crate::network::http_client::ServiceAddressProtocol;
 
     #[test]
     fn test_ibm_service_address() {
         let service_address = AppConfigurationClientIBMCloud::create_service_address("region");
 
         assert_eq!(
-            service_address.base_url(crate::ServiceAddressProtocol::Https),
+            service_address.base_url(ServiceAddressProtocol::Http),
             "https://region.apprapp.cloud.ibm.com/apprapp"
         );
         assert_eq!(
-            service_address.base_url(crate::ServiceAddressProtocol::Wss),
+            service_address.base_url(ServiceAddressProtocol::Ws),
             "wss://region.apprapp.cloud.ibm.com/apprapp"
         );
     }

src/client/mod.rs

@@ -24,6 +24,6 @@ pub(crate) mod property_proxy;
 pub(crate) mod property_snapshot;
 
 pub use app_configuration_client::{AppConfigurationClient, ConfigurationId};
-pub(crate) use app_configuration_http::AppConfigurationClientHttp;
+pub use app_configuration_http::AppConfigurationClientHttp;
 pub use app_configuration_ibm_cloud::AppConfigurationClientIBMCloud;
 pub use app_configuration_offline::AppConfigurationOffline;

src/lib.rs

@@ -99,9 +99,12 @@ pub use entity::Entity;
 pub use errors::{Error, Result};
 pub use feature::Feature;
 pub(crate) use network::{IBMCloudTokenProvider, ServerClientImpl};
-pub use network::{ServiceAddress, ServiceAddressProtocol, TokenProvider};
 pub use property::Property;
 pub use value::Value;
 
+#[cfg(feature = "http_client")]
+pub use client::AppConfigurationClientHttp;
+#[cfg(feature = "http_client")]
+pub use network::{ServiceAddress, TokenProvider};
 #[cfg(test)]
 mod tests;

src/network/http_client.rs

@@ -29,24 +29,25 @@ use tungstenite::connect;
 use url::Url;
 
 pub enum ServiceAddressProtocol {
-    Https,
-    Wss,
+    Http,
+    Ws,
 }
 
 impl std::fmt::Display for ServiceAddressProtocol {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            ServiceAddressProtocol::Https => write!(f, "https://"),
-            ServiceAddressProtocol::Wss => write!(f, "wss://"),
+            ServiceAddressProtocol::Http => write!(f, "http"),
+            ServiceAddressProtocol::Ws => write!(f, "ws"),
         }
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct ServiceAddress {
     host: String,
     port: Option<u16>,
     endpoint: Option<String>,
+    use_ssl: bool,
 }
 
 impl ServiceAddress {
@@ -55,10 +56,20 @@ impl ServiceAddress {
             host,
             port,
             endpoint,
+            use_ssl: true,
+        }
+    }
+
+    pub fn new_without_ssl(host: String, port: Option<u16>, endpoint: Option<String>) -> Self {
+        Self {
+            host,
+            port,
+            endpoint,
+            use_ssl: false,
         }
     }
 
-    pub fn base_url(&self, protocol: ServiceAddressProtocol) -> String {
+    pub(crate) fn base_url(&self, protocol: ServiceAddressProtocol) -> String {
         let port = if let Some(port) = self.port {
             format!(":{port}")
         } else {
@@ -70,8 +81,8 @@ impl ServiceAddress {
         } else {
             "".to_string()
         };
-
-        format!("{protocol}{}{port}{endpoint}", self.host)
+        let ssl_suffix = if self.use_ssl { "s" } else { "" };
+        format!("{protocol}{ssl_suffix}://{}{port}{endpoint}", self.host)
     }
 }
 
@@ -102,7 +113,7 @@ impl ServerClientImpl {
     pub fn get_configuration(&self, collection: &ConfigurationId) -> Result<ConfigurationJson> {
         let url = format!(
             "{}/feature/v1/instances/{}/config",
-            self.service_address.base_url(ServiceAddressProtocol::Https),
+            self.service_address.base_url(ServiceAddressProtocol::Http),
             collection.guid
         );
         let client = Client::new();
@@ -119,7 +130,9 @@ impl ServerClientImpl {
             .send();
 
         match r {
-            Ok(response) => response.json().map_err(Error::ReqwestError),
+            Ok(response) => response.json().map_err(|_| {
+                Error::ProtocolError("Failed to deserialize JSON from server response".to_string())
+            }),
             Err(e) => {
                 // TODO: Identify if token expired, get new one and retry
                 if false {
@@ -137,7 +150,7 @@ impl ServerClientImpl {
     ) -> Result<(WebSocket<MaybeTlsStream<TcpStream>>, Response)> {
         let ws_url = format!(
             "{}/wsfeature",
-            self.service_address.base_url(ServiceAddressProtocol::Wss)
+            self.service_address.base_url(ServiceAddressProtocol::Ws)
         );
         let mut ws_url = Url::parse(&ws_url)
             .map_err(|e| Error::Other(format!("Cannot parse '{}' as URL: {}", ws_url, e)))?;
@@ -171,3 +184,52 @@ impl ServerClientImpl {
         Ok(connect(request)?)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_non_ssl_base_url() {
+        let address = ServiceAddress::new_without_ssl(
+            "ibm.com".to_string(),
+            None,
+            Some("endpoint".to_string()),
+        );
+        assert_eq!(
+            address.base_url(ServiceAddressProtocol::Http),
+            "http://ibm.com/endpoint"
+        );
+        assert_eq!(
+            address.base_url(ServiceAddressProtocol::Ws),
+            "ws://ibm.com/endpoint"
+        );
+    }
+
+    #[test]
+    fn test_ssl_base_url() {
+        let address =
+            ServiceAddress::new("ibm.com".to_string(), None, Some("endpoint".to_string()));
+        assert_eq!(
+            address.base_url(ServiceAddressProtocol::Http),
+            "https://ibm.com/endpoint"
+        );
+        assert_eq!(
+            address.base_url(ServiceAddressProtocol::Ws),
+            "wss://ibm.com/endpoint"
+        );
+    }
+
+    #[test]
+    fn test_url_with_port() {
+        let address = ServiceAddress::new_without_ssl("ibm.com".to_string(), Some(12345), None);
+        assert_eq!(
+            address.base_url(ServiceAddressProtocol::Http),
+            "http://ibm.com:12345"
+        );
+        assert_eq!(
+            address.base_url(ServiceAddressProtocol::Ws),
+            "ws://ibm.com:12345"
+        );
+    }
+}

src/network/mod.rs

@@ -12,10 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-mod http_client;
+pub(crate) mod http_client;
 mod token_provider;
 
 pub(crate) use http_client::ServerClientImpl;
-pub use http_client::{ServiceAddress, ServiceAddressProtocol};
+pub use http_client::ServiceAddress;
 pub(crate) use token_provider::IBMCloudTokenProvider;
 pub use token_provider::TokenProvider;