Refacto on follow location types.

Author: jcamiel

packages/hurl/src/cli/options/mod.rs

@@ -32,7 +32,7 @@ use std::str::FromStr;
 use std::time::Duration;
 
 use hurl::http;
-use hurl::http::{Header, HeaderVec, RequestedHttpVersion};
+use hurl::http::{CredentialForwarding, FollowLocation, Header, HeaderVec, RequestedHttpVersion};
 use hurl::pretty::PrettyMode;
 use hurl::runner::Output;
 use hurl::util::logger;
@@ -341,6 +341,11 @@ impl CliOptions {
         let digest = self.digest;
         let follow_location = self.follow_location;
         let follow_location_trusted = self.follow_location_trusted;
+        let follow_location = match (follow_location, follow_location_trusted) {
+            (true, true) => FollowLocation::Follow(CredentialForwarding::AllHosts),
+            (true, false) => FollowLocation::Follow(CredentialForwarding::OnlyInitialHost),
+            (false, _) => FollowLocation::No,
+        };
         let from_entry = self.from_entry;
 
         // TODO: do we want to manage the headers with no content? There are two type of no-content
@@ -409,7 +414,6 @@ impl CliOptions {
             .context_dir(&context_dir)
             .cookie_input_file(cookie_input_file)
             .follow_location(follow_location)
-            .follow_location_trusted(follow_location_trusted)
             .from_entry(from_entry)
             .headers(headers)
             .http_version(http_version)

packages/hurl/src/http/client.rs

@@ -41,7 +41,9 @@ use super::header::{
 use super::ip::IpAddr;
 use super::options::{ClientOptions, Verbosity};
 use super::param::Param;
-use super::request::{IpResolve, Request, RequestedHttpVersion};
+use super::request::{
+    CredentialForwarding, FollowLocation, IpResolve, Request, RequestedHttpVersion,
+};
 use super::request_cookie::RequestCookie;
 use super::request_spec::{Body, FileParam, Method, MultipartParam, RequestSpec};
 use super::response::{HttpVersion, Response};
@@ -100,7 +102,7 @@ impl Client {
         loop {
             let call = self.execute(&request_spec, &options, logger)?;
             // If we don't follow redirection, we can early exit here.
-            if !options.follow_location {
+            if matches!(options.follow_location, FollowLocation::No) {
                 calls.push(call);
                 break;
             }
@@ -135,7 +137,7 @@ impl Client {
             if should_strip_credentials_on_redirect(
                 original_url,
                 &redirect_url,
-                options.follow_location_trusted,
+                options.follow_location,
             ) {
                 headers.retain(|h| !h.name_eq(AUTHORIZATION));
                 headers.retain(|h| !h.name_eq(COOKIE));
@@ -860,9 +862,12 @@ impl Client {
 fn should_strip_credentials_on_redirect(
     original_url: &Url,
     redirect_url: &Url,
-    follow_location_trusted: bool,
+    follow_location: FollowLocation,
 ) -> bool {
-    if follow_location_trusted {
+    if matches!(
+        follow_location,
+        FollowLocation::Follow(CredentialForwarding::AllHosts)
+    ) {
         return false;
     }
     // Different origin != strip credentials
@@ -1108,48 +1113,48 @@ mod tests {
         let url3 = Url::from_str("https://example.com").unwrap();
         let url4 = Url::from_str("http://other.com").unwrap();
 
-        let follow_location_trusted = false;
+        let follow_location = FollowLocation::Follow(CredentialForwarding::OnlyInitialHost);
         assert!(should_strip_credentials_on_redirect(
             &url1,
             &url2,
-            follow_location_trusted
+            follow_location
         ));
         assert!(should_strip_credentials_on_redirect(
             &url1,
             &url3,
-            follow_location_trusted
+            follow_location
         ));
         assert!(should_strip_credentials_on_redirect(
             &url1,
             &url4,
-            follow_location_trusted
+            follow_location
         ));
         assert!(should_strip_credentials_on_redirect(
             &url1,
             &url3,
-            follow_location_trusted
+            follow_location
         ));
 
-        let follow_location_trusted = true;
+        let follow_location = FollowLocation::Follow(CredentialForwarding::AllHosts);
         assert!(!should_strip_credentials_on_redirect(
             &url1,
             &url2,
-            follow_location_trusted
+            follow_location
         ));
         assert!(!should_strip_credentials_on_redirect(
             &url1,
             &url3,
-            follow_location_trusted
+            follow_location
         ));
         assert!(!should_strip_credentials_on_redirect(
             &url1,
             &url4,
-            follow_location_trusted
+            follow_location
         ));
         assert!(!should_strip_credentials_on_redirect(
             &url1,
             &url3,
-            follow_location_trusted
+            follow_location
         ));
     }
 

packages/hurl/src/http/curl_cmd.rs

@@ -28,7 +28,7 @@ use super::cookie_store::CookieStore;
 use super::header::{Header, HeaderVec, CONTENT_TYPE};
 use super::options::ClientOptions;
 use super::param::Param;
-use super::request::{IpResolve, RequestedHttpVersion};
+use super::request::{CredentialForwarding, FollowLocation, IpResolve, RequestedHttpVersion};
 use super::request_spec::{Body, FileParam, Method, MultipartParam, RequestSpec};
 
 /// Represents a curl command, with arguments.
@@ -93,7 +93,7 @@ impl CurlCmd {
 }
 
 /// Returns the curl args corresponding to the HTTP method, from a request spec.
-fn method_params(request_spec: &RequestSpec, follow_location: bool) -> Vec<String> {
+fn method_params(request_spec: &RequestSpec, follow_location: FollowLocation) -> Vec<String> {
     let has_body = !request_spec.multipart.is_empty()
         || !request_spec.form.is_empty()
         || !request_spec.body.bytes().is_empty();
@@ -294,7 +294,7 @@ fn encode_bytes(bytes: &[u8]) -> String {
 
 impl Method {
     /// Returns the curl args for HTTP method, given the request has a body or not.
-    fn curl_args(&self, has_body: bool, follow_location: bool) -> Vec<String> {
+    fn curl_args(&self, has_body: bool, follow_location: FollowLocation) -> Vec<String> {
         match self.0.as_str() {
             "GET" => {
                 if has_body {
@@ -317,7 +317,7 @@ impl Method {
                 // method of the redirection steps.
                 if has_body {
                     vec![]
-                } else if follow_location {
+                } else if matches!(follow_location, FollowLocation::Follow(_)) {
                     vec!["--data".to_string(), "''".to_string()]
                 } else {
                     vec!["--request".to_string(), "POST".to_string()]
@@ -442,10 +442,14 @@ impl ClientOptions {
             IpResolve::IpV4 => arguments.push("--ipv4".to_string()),
             IpResolve::IpV6 => arguments.push("--ipv6".to_string()),
         }
-        if self.follow_location_trusted {
-            arguments.push("--location-trusted".to_string());
-        } else if self.follow_location {
-            arguments.push("--location".to_string());
+        match self.follow_location {
+            FollowLocation::Follow(CredentialForwarding::OnlyInitialHost) => {
+                arguments.push("--location".to_string());
+            }
+            FollowLocation::Follow(CredentialForwarding::AllHosts) => {
+                arguments.push("--location-trusted".to_string());
+            }
+            FollowLocation::No => {}
         }
         if let Some(max_filesize) = self.max_filesize {
             arguments.push("--max-filesize".to_string());
@@ -682,8 +686,7 @@ mod tests {
             connects_to: vec!["example.com:443:host-47.example.com:443".to_string()],
             cookie_input_file: Some("cookie_file".to_string()),
             digest: false,
-            follow_location: true,
-            follow_location_trusted: false,
+            follow_location: FollowLocation::Follow(CredentialForwarding::OnlyInitialHost),
             headers,
             http_version: RequestedHttpVersion::Http10,
             insecure: true,

packages/hurl/src/http/mod.rs

@@ -30,7 +30,9 @@ pub use self::header::{
 };
 pub(crate) use self::options::{ClientOptions, Verbosity};
 pub(crate) use self::param::Param;
-pub use self::request::{IpResolve, Request, RequestedHttpVersion};
+pub use self::request::{
+    CredentialForwarding, FollowLocation, IpResolve, Request, RequestedHttpVersion,
+};
 pub(crate) use self::request_cookie::RequestCookie;
 pub(crate) use self::request_spec::{Body, FileParam, Method, MultipartParam, RequestSpec};
 pub use self::response::{HttpVersion, Response};

packages/hurl/src/http/options.rs

@@ -20,7 +20,7 @@ use std::time::Duration;
 use hurl_core::types::{BytesPerSec, Count};
 
 use super::header::HeaderVec;
-use super::request::{IpResolve, RequestedHttpVersion};
+use super::request::{FollowLocation, IpResolve, RequestedHttpVersion};
 
 #[derive(Debug, Clone)]
 pub struct ClientOptions {
@@ -38,8 +38,7 @@ pub struct ClientOptions {
     pub connects_to: Vec<String>,
     pub cookie_input_file: Option<String>,
     pub digest: bool,
-    pub follow_location: bool,
-    pub follow_location_trusted: bool,
+    pub follow_location: FollowLocation,
     pub headers: HeaderVec,
     pub http_version: RequestedHttpVersion,
     pub insecure: bool,
@@ -88,8 +87,7 @@ impl Default for ClientOptions {
             connects_to: vec![],
             cookie_input_file: None,
             digest: false,
-            follow_location: false,
-            follow_location_trusted: false,
+            follow_location: FollowLocation::default(),
             headers: HeaderVec::new(),
             http_version: RequestedHttpVersion::default(),
             insecure: false,

packages/hurl/src/http/request.rs

@@ -71,6 +71,26 @@ pub enum IpResolve {
     IpV6,
 }
 
+/// Do the HTTP client follow redirection, or not?
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
+pub enum FollowLocation {
+    /// No redirection is followed
+    #[default]
+    No,
+    /// Redirection is followed, credentials are passed only to the initial host, or all hosts
+    /// depending on the credential forwarding mode.
+    Follow(CredentialForwarding),
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
+pub enum CredentialForwarding {
+    /// Credentials are only forwarded to the initial host
+    #[default]
+    OnlyInitialHost,
+    /// Credentials are forwarded to all hosts involved in the redirection
+    AllHosts,
+}
+
 impl Request {
     /// Creates a new request.
     pub fn new(method: &str, url: Url, headers: HeaderVec, body: Vec<u8>) -> Self {

packages/hurl/src/runner/entry.rs

@@ -257,7 +257,6 @@ impl ClientOptions {
             cookie_input_file: runner_options.cookie_input_file.clone(),
             digest: runner_options.digest,
             follow_location: runner_options.follow_location,
-            follow_location_trusted: runner_options.follow_location_trusted,
             headers: runner_options.headers.clone(),
             http_version: runner_options.http_version,
             ip_resolve: runner_options.ip_resolve,

packages/hurl/src/runner/hurl_file.rs

@@ -25,7 +25,7 @@ use hurl_core::input::Input;
 use hurl_core::parser;
 use hurl_core::types::{Count, Index};
 
-use crate::http::{Call, Client};
+use crate::http::{Call, Client, CredentialForwarding, FollowLocation};
 use crate::util::logger::{ErrorFormat, Logger, LoggerOptions};
 use crate::util::term::{Stderr, Stdout, WriteMode};
 
@@ -51,6 +51,7 @@ use super::variable::VariableSet;
 ///
 /// ```
 /// use std::collections::HashMap;
+/// use hurl::http::{CredentialForwarding, FollowLocation};
 /// use hurl::runner;
 /// use hurl::runner::{Value, RunnerOptionsBuilder, VariableSet};
 /// use hurl::util::logger::{LoggerOptionsBuilder, Verbosity};
@@ -66,7 +67,7 @@ use super::variable::VariableSet;
 ///
 /// // Define runner and logger options
 /// let runner_opts = RunnerOptionsBuilder::new()
-///     .follow_location(true)
+///     .follow_location(FollowLocation::Follow(CredentialForwarding::AllHosts))
 ///     .build();
 /// let logger_opts = LoggerOptionsBuilder::new()
 ///     .verbosity(Some(Verbosity::Verbose))
@@ -471,7 +472,15 @@ fn get_non_default_options(options: &RunnerOptions) -> Vec<(&'static str, String
     }
 
     if options.follow_location != default_options.follow_location {
-        non_default_options.push(("follow redirect", options.follow_location.to_string()));
+        match options.follow_location {
+            FollowLocation::No => {}
+            FollowLocation::Follow(CredentialForwarding::OnlyInitialHost) => {
+                non_default_options.push(("follow redirect", "true".to_string()));
+            }
+            FollowLocation::Follow(CredentialForwarding::AllHosts) => {
+                non_default_options.push(("follow redirect", "true (trusted)".to_string()));
+            }
+        }
     }
 
     if options.insecure != default_options.insecure {

packages/hurl/src/runner/options.rs

@@ -21,7 +21,7 @@ use hurl_core::ast::{
 };
 use hurl_core::types::{BytesPerSec, Count, DurationUnit};
 
-use crate::http::{Header, IpResolve, RequestedHttpVersion};
+use crate::http::{CredentialForwarding, FollowLocation, Header, IpResolve, RequestedHttpVersion};
 use crate::util::logger::{Logger, Verbosity};
 
 use super::error::{RunnerError, RunnerErrorKind};
@@ -167,14 +167,19 @@ pub fn get_entry_options(
             }
             OptionKind::FollowLocation(value) => {
                 let value = eval_boolean_option(value, variables)?;
-                entry_options.follow_location = value;
+                if value {
+                    entry_options.follow_location =
+                        FollowLocation::Follow(CredentialForwarding::OnlyInitialHost);
+                } else {
+                    entry_options.follow_location = FollowLocation::No;
+                }
             }
             OptionKind::FollowLocationTrusted(value) => {
                 let value = eval_boolean_option(value, variables)?;
                 if value {
-                    entry_options.follow_location = true;
+                    entry_options.follow_location =
+                        FollowLocation::Follow(CredentialForwarding::AllHosts);
                 }
-                entry_options.follow_location_trusted = value;
             }
             OptionKind::Insecure(value) => {
                 let value = eval_boolean_option(value, variables)?;