chore: reduce visibility of fields + renaming

Author: yannham

libdd-http-client/src/lib.rs

@@ -37,7 +37,7 @@
 //! let client = HttpClient::new("http://localhost:8080".to_string(), Duration::from_secs(5))?;
 //! let request = HttpRequest::new(HttpMethod::Get, "http://localhost:8080/ping".to_string());
 //! let response = client.send(request).await?;
-//! println!("Status: {}", response.status_code);
+//! println!("Status: {}", response.status_code());
 //! # Ok(())
 //! # }
 //! ```

libdd-http-client/src/request.rs

@@ -28,13 +28,13 @@ pub enum HttpMethod {
 #[derive(Debug, Clone)]
 pub struct MultipartPart {
     /// The field name for this part.
-    pub name: String,
+    pub(crate) name: String,
     /// The part's data.
-    pub data: bytes::Bytes,
+    pub(crate) data: bytes::Bytes,
     /// Optional filename for this part.
-    pub filename: Option<String>,
+    pub(crate) filename: Option<String>,
     /// Optional MIME content type (e.g. `"application/json"`).
-    pub content_type: Option<String>,
+    pub(crate) content_type: Option<String>,
 }
 
 impl MultipartPart {
@@ -49,42 +49,68 @@ impl MultipartPart {
     }
 
     /// Set the filename for this part.
-    pub fn filename(mut self, filename: impl Into<String>) -> Self {
+    #[inline]
+    pub fn with_filename(mut self, filename: impl Into<String>) -> Self {
         self.filename = Some(filename.into());
         self
     }
 
     /// Set the MIME content type for this part.
-    pub fn content_type(mut self, content_type: impl Into<String>) -> Self {
+    #[inline]
+    pub fn with_content_type(mut self, content_type: impl Into<String>) -> Self {
         self.content_type = Some(content_type.into());
         self
     }
+
+    /// Returns the field name for this part.
+    #[inline]
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    /// Returns the raw bytes of this part.
+    #[inline]
+    pub fn data(&self) -> &bytes::Bytes {
+        &self.data
+    }
+
+    /// Returns the filename, if any.
+    #[inline]
+    pub fn filename(&self) -> Option<&str> {
+        self.filename.as_deref()
+    }
+
+    /// Returns the MIME content type, if any.
+    #[inline]
+    pub fn content_type(&self) -> Option<&str> {
+        self.content_type.as_deref()
+    }
 }
 
 /// An outgoing HTTP request.
 #[derive(Debug, Clone)]
 pub struct HttpRequest {
     /// HTTP method.
-    pub method: HttpMethod,
+    pub(crate) method: HttpMethod,
 
     /// Absolute URL string (e.g. `"http://localhost:8080/v0.4/traces"`).
-    pub url: String,
+    pub(crate) url: String,
 
     /// Request headers as a list of (name, value) pairs.
     ///
     /// Vec preserves insertion order and allows duplicate header names,
     /// both of which are valid in HTTP.
-    pub headers: Vec<(String, String)>,
+    pub(crate) headers: Vec<(String, String)>,
 
     /// Request body bytes. Empty for requests with no body.
-    pub body: bytes::Bytes,
+    pub(crate) body: bytes::Bytes,
 
     /// Per-request timeout. Overrides the client-level timeout if set.
-    pub timeout: Option<Duration>,
+    pub(crate) timeout: Option<Duration>,
 
     /// Multipart form-data parts. When non-empty, the request is sent as
     /// multipart/form-data and `body` is ignored.
-    pub multipart_parts: Vec<MultipartPart>,
+    pub(crate) multipart_parts: Vec<MultipartPart>,
 }
 
 impl HttpRequest {
@@ -101,10 +127,86 @@ impl HttpRequest {
         }
     }
 
-    /// Add a multipart part to this request. When any parts are present, the
-    /// request is sent as multipart/form-data and `body` is ignored.
-    pub fn add_multipart_part(&mut self, part: MultipartPart) {
+    /// Append a header to this request.
+    #[inline]
+    pub fn with_header(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
+        self.headers.push((name.into(), value.into()));
+        self
+    }
+
+    /// Set the request body.
+    #[inline]
+    pub fn with_body(mut self, body: impl Into<bytes::Bytes>) -> Self {
+        self.body = body.into();
+        self
+    }
+
+    /// Set the per-request timeout, overriding the client-level timeout.
+    #[inline]
+    pub fn with_timeout(mut self, timeout: Duration) -> Self {
+        self.timeout = Some(timeout);
+        self
+    }
+
+    /// Append a multipart part to this request.
+    #[inline]
+    pub fn with_multipart_part(mut self, part: MultipartPart) -> Self {
         self.multipart_parts.push(part);
+        self
+    }
+
+    /// Returns the HTTP method.
+    #[inline]
+    pub fn method(&self) -> HttpMethod {
+        self.method
+    }
+
+    /// Returns the request URL.
+    #[inline]
+    pub fn url(&self) -> &str {
+        &self.url
+    }
+
+    /// Returns the request headers.
+    #[inline]
+    pub fn headers(&self) -> &[(String, String)] {
+        &self.headers
+    }
+
+    /// Returns the request body.
+    #[inline]
+    pub fn body(&self) -> &bytes::Bytes {
+        &self.body
+    }
+
+    /// Returns the per-request timeout override, if set.
+    #[inline]
+    pub fn timeout(&self) -> Option<Duration> {
+        self.timeout
+    }
+
+    /// Returns the multipart parts.
+    #[inline]
+    pub fn multipart_parts(&self) -> &[MultipartPart] {
+        &self.multipart_parts
+    }
+
+    /// Returns a mutable reference to the headers list.
+    #[inline]
+    pub fn headers_mut(&mut self) -> &mut Vec<(String, String)> {
+        &mut self.headers
+    }
+
+    /// Returns a mutable reference to the request body.
+    #[inline]
+    pub fn body_mut(&mut self) -> &mut bytes::Bytes {
+        &mut self.body
+    }
+
+    /// Returns a mutable reference to the multipart parts list.
+    #[inline]
+    pub fn multipart_parts_mut(&mut self) -> &mut Vec<MultipartPart> {
+        &mut self.multipart_parts
     }
 }
 
@@ -126,7 +228,7 @@ mod tests {
     fn request_with_headers_and_body() {
         let mut req = HttpRequest::new(HttpMethod::Post, "http://localhost/data".to_owned());
         req.headers
-            .push(("Content-Type".to_string(), "application/json".to_owned()));
+            .push(("Content-Type".to_owned(), "application/json".to_owned()));
         req.body = bytes::Bytes::from_static(b"{\"key\":\"value\"}");
         req.timeout = Some(Duration::from_secs(10));
 
@@ -140,4 +242,16 @@ mod tests {
         assert_eq!(HttpMethod::Get, HttpMethod::Get);
         assert_ne!(HttpMethod::Get, HttpMethod::Post);
     }
+
+    #[test]
+    fn test_multipart_part_builder() {
+        let part = MultipartPart::new("name", bytes::Bytes::from_static(b"data"))
+            .with_filename("test.txt")
+            .with_content_type("text/plain");
+
+        assert_eq!(part.name, "name");
+        assert_eq!(part.data.as_ref(), b"data");
+        assert_eq!(part.filename.as_deref(), Some("test.txt"));
+        assert_eq!(part.content_type.as_deref(), Some("text/plain"));
+    }
 }

libdd-http-client/src/response.rs

@@ -7,13 +7,31 @@
 #[derive(Debug)]
 pub struct HttpResponse {
     /// HTTP status code (e.g. 200, 404, 503).
-    pub status_code: u16,
-
+    pub(crate) status_code: u16,
     /// Response headers as a list of (name, value) pairs.
-    pub headers: Vec<(String, String)>,
-
+    pub(crate) headers: Vec<(String, String)>,
     /// Response body bytes.
-    pub body: bytes::Bytes,
+    pub(crate) body: bytes::Bytes,
+}
+
+impl HttpResponse {
+    /// Returns the HTTP status code.
+    #[inline]
+    pub fn status_code(&self) -> u16 {
+        self.status_code
+    }
+
+    /// Returns the response headers as a slice of (name, value) pairs.
+    #[inline]
+    pub fn headers(&self) -> &[(String, String)] {
+        &self.headers
+    }
+
+    /// Returns the response body bytes.
+    #[inline]
+    pub fn body(&self) -> &bytes::Bytes {
+        &self.body
+    }
 }
 
 #[cfg(test)]

libdd-http-client/tests/connection_pool.rs

@@ -23,7 +23,8 @@ async fn test_multiple_requests_reuse_client() {
         let req = HttpRequest::new(HttpMethod::Get, server.url("/ping"));
         let response = client.send(req).await.unwrap();
         assert_eq!(
-            response.status_code, 200,
+            response.status_code(),
+            200,
             "request {i} should have succeeded"
         );
     }
@@ -54,9 +55,9 @@ async fn test_concurrent_requests_succeed() {
 
     let (r1, r2, r3) = tokio::join!(client.send(req1), client.send(req2), client.send(req3));
 
-    assert_eq!(r1.unwrap().status_code, 200);
-    assert_eq!(r2.unwrap().status_code, 200);
-    assert_eq!(r3.unwrap().status_code, 200);
+    assert_eq!(r1.unwrap().status_code(), 200);
+    assert_eq!(r2.unwrap().status_code(), 200);
+    assert_eq!(r3.unwrap().status_code(), 200);
 
     mock.assert_calls_async(3).await;
 }

libdd-http-client/tests/http_round_trip.rs

@@ -19,15 +19,14 @@ async fn test_post_round_trip() {
 
     let client = HttpClient::new(server.url("/"), Duration::from_secs(5)).unwrap();
 
-    let mut req = HttpRequest::new(HttpMethod::Post, server.url("/v0.4/traces"));
-    req.headers
-        .push(("Content-Type".to_owned(), "application/msgpack".to_owned()));
-    req.body = bytes::Bytes::from_static(b"test payload");
+    let req = HttpRequest::new(HttpMethod::Post, server.url("/v0.4/traces"))
+        .with_header("Content-Type", "application/msgpack")
+        .with_body(bytes::Bytes::from_static(b"test payload"));
 
     let response = client.send(req).await.unwrap();
 
-    assert_eq!(response.status_code, 200);
-    assert_eq!(response.body.as_ref(), b"ok");
+    assert_eq!(response.status_code(), 200);
+    assert_eq!(response.body().as_ref(), b"ok");
 
     mock.assert_async().await;
 }
@@ -51,8 +50,8 @@ async fn test_get_round_trip() {
     let req = HttpRequest::new(HttpMethod::Get, server.url("/info"));
     let response = client.send(req).await.unwrap();
 
-    assert_eq!(response.status_code, 200);
-    assert_eq!(response.body.as_ref(), br#"{"version":"1.0"}"#);
+    assert_eq!(response.status_code(), 200);
+    assert_eq!(response.body().as_ref(), br#"{"version":"1.0"}"#);
 
     mock.assert_async().await;
 }
@@ -74,7 +73,10 @@ async fn test_response_headers_returned() {
     let req = HttpRequest::new(HttpMethod::Get, server.url("/headers"));
     let response = client.send(req).await.unwrap();
 
-    let custom_header = response.headers.iter().find(|(name, _)| name == "x-custom");
+    let custom_header = response
+        .headers()
+        .iter()
+        .find(|(name, _)| name == "x-custom");
     assert!(
         custom_header.is_some(),
         "expected x-custom header in response"
@@ -132,8 +134,8 @@ async fn test_4xx_returns_ok_when_errors_disabled() {
     let req = HttpRequest::new(HttpMethod::Get, server.url("/not-found"));
     let response = client.send(req).await.unwrap();
 
-    assert_eq!(response.status_code, 404);
-    assert_eq!(response.body.as_ref(), b"not found");
+    assert_eq!(response.status_code(), 404);
+    assert_eq!(response.body().as_ref(), b"not found");
 }
 
 #[cfg_attr(miri, ignore)]

libdd-http-client/tests/multipart_test.rs

@@ -19,19 +19,19 @@ async fn test_multipart_upload() {
 
     let client = HttpClient::new(server.url("/"), Duration::from_secs(5)).unwrap();
 
-    let mut req = HttpRequest::new(HttpMethod::Post, server.url("/upload"));
-    req.add_multipart_part(
-        MultipartPart::new("metadata", br#"{"case_id":"123"}"#.as_slice())
-            .content_type("application/json"),
-    );
-    req.add_multipart_part(
-        MultipartPart::new("file", b"binary data here".as_slice())
-            .filename("data.bin")
-            .content_type("application/octet-stream"),
-    );
+    let req = HttpRequest::new(HttpMethod::Post, server.url("/upload"))
+        .with_multipart_part(
+            MultipartPart::new("metadata", br#"{"case_id":"123"}"#.as_slice())
+                .with_content_type("application/json"),
+        )
+        .with_multipart_part(
+            MultipartPart::new("file", b"binary data here".as_slice())
+                .with_filename("data.bin")
+                .with_content_type("application/octet-stream"),
+        );
 
     let response = client.send(req).await.unwrap();
-    assert_eq!(response.status_code, 200);
+    assert_eq!(response.status_code(), 200);
 
     mock.assert_async().await;
 }
@@ -52,23 +52,11 @@ async fn test_multipart_sets_content_type() {
 
     let client = HttpClient::new(server.url("/"), Duration::from_secs(5)).unwrap();
 
-    let mut req = HttpRequest::new(HttpMethod::Post, server.url("/upload"));
-    req.add_multipart_part(MultipartPart::new("field", b"value".as_slice()));
+    let req = HttpRequest::new(HttpMethod::Post, server.url("/upload"))
+        .with_multipart_part(MultipartPart::new("field", b"value".as_slice()));
 
     let response = client.send(req).await.unwrap();
-    assert_eq!(response.status_code, 200);
+    assert_eq!(response.status_code(), 200);
 
     mock.assert_async().await;
 }
-
-#[test]
-fn test_multipart_part_builder() {
-    let part = MultipartPart::new("name", bytes::Bytes::from_static(b"data"))
-        .filename("test.txt")
-        .content_type("text/plain");
-
-    assert_eq!(part.name, "name");
-    assert_eq!(part.data.as_ref(), b"data");
-    assert_eq!(part.filename.as_deref(), Some("test.txt"));
-    assert_eq!(part.content_type.as_deref(), Some("text/plain"));
-}