diff --git a/packages/hurl/src/http/client.rs b/packages/hurl/src/http/client.rs index 6b6b3be6c1d..30be6468f70 100644 --- a/packages/hurl/src/http/client.rs +++ b/packages/hurl/src/http/client.rs @@ -35,19 +35,16 @@ use url::Url; #[derive(Debug)] pub struct Client { - pub options: ClientOptions, pub handle: Box, pub redirect_count: usize, - // unfortunately, follow-location feature from libcurl can not be used + // Unfortunately, follow-location feature from libcurl can not be used // libcurl returns a single list of headers for the 2 responses - // hurl needs to keep everything + // Hurl needs to keep everything. } impl Client { - /// - /// Init HTTP hurl client - /// - pub fn init(options: ClientOptions) -> Client { + /// Creates HTTP Hurl client. + pub fn new(options: &ClientOptions) -> Client { let mut h = easy::Easy::new(); // Set handle attributes @@ -65,31 +62,33 @@ impl Client { .unwrap(); Client { - options, handle: Box::new(h), redirect_count: 0, } } - /// Executes an HTTP request and returns a list + /// Executes an HTTP request, optionally follows redirection and returns a + /// list of pair of [`Request`], [`Response`]. /// /// # Arguments /// - /// * `request` - A request specification + /// * `request_spec` - A request specification + /// * `options`- Options for this execution /// * `logger`- A logger pub fn execute_with_redirect( &mut self, - request: &RequestSpec, + request_spec: &RequestSpec, + options: &ClientOptions, logger: &Logger, ) -> Result, HttpError> { let mut calls = vec![]; - let mut request_spec = request.clone(); + let mut request_spec = request_spec.clone(); self.redirect_count = 0; loop { - let (request, response) = self.execute(&request_spec, logger)?; + let (request, response) = self.execute(&request_spec, options, logger)?; calls.push((request, response.clone())); - if let Some(url) = self.get_follow_location(response.clone()) { + if let Some(url) = self.get_follow_location(&response, options) { request_spec = RequestSpec { method: Method::Get, url, @@ -103,7 +102,7 @@ impl Client { }; self.redirect_count += 1; - if let Some(max_redirect) = self.options.max_redirect { + if let Some(max_redirect) = options.max_redirect { if self.redirect_count > max_redirect { return Err(HttpError::TooManyRedirect); } @@ -115,10 +114,18 @@ impl Client { Ok(calls) } - /// Execute an http request + /// Executes an HTTP request, without following redirection and returns a + /// pair of [`Request`], [`Response`]. + /// + /// # Arguments + /// + /// * `request_spec` - A request specification + /// * `options`- Options for this execution + /// * `logger`- A logger pub fn execute( &mut self, request_spec: &RequestSpec, + options: &ClientOptions, logger: &Logger, ) -> Result<(Request, Response), HttpError> { // Set handle attributes that have not been set or reset. @@ -127,22 +134,22 @@ impl Client { // to capture HTTP request headers in libcurl `debug_function`. That's the only // way to get access to the outgoing headers. self.handle.verbose(true).unwrap(); - self.handle.ssl_verify_host(!self.options.insecure).unwrap(); - self.handle.ssl_verify_peer(!self.options.insecure).unwrap(); - if let Some(cacert_file) = self.options.cacert_file.clone() { + self.handle.ssl_verify_host(!options.insecure).unwrap(); + self.handle.ssl_verify_peer(!options.insecure).unwrap(); + if let Some(cacert_file) = options.cacert_file.clone() { self.handle.cainfo(cacert_file).unwrap(); self.handle.ssl_cert_type("PEM").unwrap(); } - if let Some(proxy) = self.options.proxy.clone() { + if let Some(proxy) = options.proxy.clone() { self.handle.proxy(proxy.as_str()).unwrap(); } - if let Some(s) = self.options.no_proxy.clone() { + if let Some(s) = options.no_proxy.clone() { self.handle.noproxy(s.as_str()).unwrap(); } - self.handle.timeout(self.options.timeout).unwrap(); + self.handle.timeout(options.timeout).unwrap(); self.handle - .connect_timeout(self.options.connect_timeout) + .connect_timeout(options.connect_timeout) .unwrap(); let url = self.generate_url(&request_spec.url, &request_spec.querystring); @@ -154,11 +161,11 @@ impl Client { self.set_multipart(&request_spec.multipart); let mut request_spec_body: &[u8] = &request_spec.body.bytes(); self.set_body(request_spec_body); - self.set_headers(request_spec); + self.set_headers(request_spec, options); let start = Instant::now(); - let verbose = self.options.verbosity != None; - let very_verbose = self.options.verbosity == Some(Verbosity::VeryVerbose); + let verbose = options.verbosity != None; + let very_verbose = options.verbosity == Some(Verbosity::VeryVerbose); let mut request_headers: Vec
= vec![]; let mut status_lines = vec![]; let mut response_headers = vec![]; @@ -192,7 +199,7 @@ impl Client { lines.pop().unwrap(); // Remove last empty line. lines.remove(0); // Remove method/path/version line. for line in lines { - if let Some(header) = Header::parse(line) { + if let Some(header) = Header::parse(&line) { request_headers.push(header); } } @@ -285,7 +292,7 @@ impl Client { // TODO: explain why status_lines is Vec ? let version = match status_lines.last() { None => return Err(HttpError::StatuslineIsMissing { url }), - Some(status_line) => self.parse_response_version(status_line.to_string())?, + Some(status_line) => self.parse_response_version(status_line)?, }; let headers = self.parse_response_headers(&response_headers); let duration = start.elapsed(); @@ -318,9 +325,7 @@ impl Client { Ok((request, response)) } - /// - /// generate url - /// + /// Generates URL. fn generate_url(&mut self, url: &str, params: &[Param]) -> String { let url = if params.is_empty() { url.to_string() @@ -338,9 +343,7 @@ impl Client { url } - /// - /// set method - /// + /// Sets HTTP method. fn set_method(&mut self, method: &Method) { match method { Method::Get => self.handle.custom_request("GET").unwrap(), @@ -355,10 +358,8 @@ impl Client { } } - /// - /// set request headers - /// - fn set_headers(&mut self, request: &RequestSpec) { + /// Sets HTTP headers. + fn set_headers(&mut self, request: &RequestSpec, options: &ClientOptions) { let mut list = easy::List::new(); for header in &request.headers { @@ -380,7 +381,7 @@ impl Client { } if request.get_header_values("User-Agent").is_empty() { - let user_agent = match self.options.user_agent { + let user_agent = match options.user_agent { Some(ref u) => u.clone(), None => format!("hurl/{}", clap::crate_version!()), }; @@ -388,23 +389,21 @@ impl Client { .unwrap(); } - if let Some(ref user) = self.options.user { + if let Some(ref user) = options.user { let authorization = base64::encode(user.as_bytes()); if request.get_header_values("Authorization").is_empty() { list.append(format!("Authorization: Basic {}", authorization).as_str()) .unwrap(); } } - if self.options.compressed && request.get_header_values("Accept-Encoding").is_empty() { + if options.compressed && request.get_header_values("Accept-Encoding").is_empty() { list.append("Accept-Encoding: gzip, deflate, br").unwrap(); } self.handle.http_headers(list).unwrap(); } - /// - /// set request cookies - /// + /// Sets request cookies. fn set_cookies(&mut self, cookies: &[RequestCookie]) { let s = cookies .iter() @@ -416,9 +415,7 @@ impl Client { } } - /// - /// set form - /// + /// Sets form params. fn set_form(&mut self, params: &[Param]) { if !params.is_empty() { let s = self.encode_params(params); @@ -427,9 +424,7 @@ impl Client { } } - /// - /// set form - /// + /// Sets multipart form datas. fn set_multipart(&mut self, params: &[MultipartParam]) { if !params.is_empty() { let mut form = easy::Form::new(); @@ -455,9 +450,7 @@ impl Client { } } - /// - /// set body - /// + /// Sets request body. fn set_body(&mut self, data: &[u8]) { if !data.is_empty() { self.handle.post(true).unwrap(); @@ -465,9 +458,7 @@ impl Client { } } - /// - /// encode parameters - /// + /// URL encodes parameters. fn encode_params(&mut self, params: &[Param]) -> String { params .iter() @@ -479,10 +470,8 @@ impl Client { .join("&") } - /// - /// parse response version - /// - fn parse_response_version(&mut self, line: String) -> Result { + /// Parses HTTP response version. + fn parse_response_version(&mut self, line: &str) -> Result { if line.starts_with("HTTP/1.0") { Ok(Version::Http10) } else if line.starts_with("HTTP/1.1") { @@ -494,28 +483,28 @@ impl Client { } } - /// - /// parse headers from libcurl responses - /// + /// Parse headers from libcurl responses. fn parse_response_headers(&mut self, lines: &[String]) -> Vec
{ let mut headers: Vec
= vec![]; for line in lines { - if let Some(header) = Header::parse(line.to_string()) { + if let Some(header) = Header::parse(line) { headers.push(header); } } headers } - /// - /// retrieve an optional location to follow + /// Retrieves an optional location to follow /// You need: /// 1. the option follow_location set to true /// 2. a 3xx response code /// 3. a header Location - /// - fn get_follow_location(&mut self, response: Response) -> Option { - if !self.options.follow_location { + fn get_follow_location( + &mut self, + response: &Response, + options: &ClientOptions, + ) -> Option { + if !options.follow_location { return None; } let response_code = response.status; @@ -534,9 +523,7 @@ impl Client { } } - /// - /// get cookie storage - /// + /// Returns cookie storage. pub fn get_cookie_storage(&mut self) -> Vec { let list = self.handle.cookies().unwrap(); let mut cookies = vec![]; @@ -551,11 +538,9 @@ impl Client { cookies } - /// - /// Add cookie to Cookiejar - /// - pub fn add_cookie(&mut self, cookie: Cookie) { - if self.options.verbosity != None { + /// Adds a cookie to the cookie jar. + pub fn add_cookie(&mut self, cookie: &Cookie, options: &ClientOptions) { + if options.verbosity != None { eprintln!("* add to cookie store: {}", cookie); } self.handle @@ -563,25 +548,25 @@ impl Client { .unwrap(); } - /// - /// Clear cookie storage - /// - pub fn clear_cookie_storage(&mut self) { - if self.options.verbosity != None { + /// Clears cookie storage. + pub fn clear_cookie_storage(&mut self, options: &ClientOptions) { + if options.verbosity != None { eprintln!("* clear cookie storage"); } self.handle.cookie_list("ALL").unwrap(); } - /// - /// return curl command-line for the http request run by the client - /// - pub fn curl_command_line(&mut self, http_request: &RequestSpec) -> String { + /// Returns curl command-line for the HTTP request run by this client. + pub fn curl_command_line( + &mut self, + request_spec: &RequestSpec, + options: &ClientOptions, + ) -> String { let mut arguments = vec!["curl".to_string()]; - let context_dir = &self.options.context_dir; - arguments.append(&mut http_request.curl_args(context_dir)); + let context_dir = &options.context_dir; + arguments.append(&mut request_spec.curl_args(context_dir)); - let cookies = all_cookies(self.get_cookie_storage(), http_request); + let cookies = all_cookies(&self.get_cookie_storage(), request_spec); if !cookies.is_empty() { arguments.push("--cookie".to_string()); arguments.push(format!( @@ -593,21 +578,19 @@ impl Client { .join("; ") )); } - arguments.append(&mut self.options.curl_args()); + arguments.append(&mut options.curl_args()); arguments.join(" ") } } -/// -/// return cookies from both cookies from the cookie storage and the request -/// -pub fn all_cookies(cookie_storage: Vec, request: &RequestSpec) -> Vec { - let mut cookies = request.cookies.clone(); +/// Returns cookies from both cookies from the cookie storage and the request. +pub fn all_cookies(cookie_storage: &[Cookie], request_spec: &RequestSpec) -> Vec { + let mut cookies = request_spec.cookies.clone(); cookies.append( &mut cookie_storage .iter() .filter(|c| c.expires != "1") // cookie expired when libcurl set value to 1? - .filter(|c| match_cookie(c, request.url.as_str())) + .filter(|c| match_cookie(c, request_spec.url.as_str())) .map(|c| RequestCookie { name: (*c).name.clone(), value: c.value.clone(), @@ -617,9 +600,7 @@ pub fn all_cookies(cookie_storage: Vec, request: &RequestSpec) -> Vec bool { // is it possible to do it with libcurl? let url = match Url::parse(url) { @@ -639,11 +620,9 @@ pub fn match_cookie(cookie: &Cookie, url: &str) -> bool { } impl Header { - /// - /// Parse an http header line received from the server - /// It does not panic. Just return none if it can not be parsed - /// - pub fn parse(line: String) -> Option
{ + /// Parses an HTTP header line received from the server + /// It does not panic. Just returns `None` if it can not be parsed. + pub fn parse(line: &str) -> Option
{ match line.find(':') { Some(index) => { let (name, value) = line.split_at(index); @@ -657,9 +636,7 @@ impl Header { } } -/// -/// Split an array of bytes into http lines (\r\n separator) -/// +/// Splits an array of bytes into HTTP lines (\r\n separator). fn split_lines(data: &[u8]) -> Vec { let mut lines = vec![]; let mut start = 0; @@ -678,16 +655,14 @@ fn split_lines(data: &[u8]) -> Vec { lines } -/// -/// Decode optionally header value as text with utf8 or iso-8859-1 encoding -/// +/// Decodes optionally header value as text with UTF-8 or ISO-8859-1 encoding. pub fn decode_header(data: &[u8]) -> Option { match str::from_utf8(data) { Ok(s) => Some(s.to_string()), Err(_) => match ISO_8859_1.decode(data, DecoderTrap::Strict) { Ok(s) => Some(s), Err(_) => { - println!("Error decoding header both utf8 and iso-8859-1 {:?}", data); + println!("Error decoding header both UTF-8 and ISO-8859-1 {:?}", data); None } }, @@ -701,20 +676,20 @@ mod tests { #[test] fn test_parse_header() { assert_eq!( - Header::parse("Foo: Bar\r\n".to_string()).unwrap(), + Header::parse("Foo: Bar\r\n").unwrap(), Header { name: "Foo".to_string(), value: "Bar".to_string(), } ); assert_eq!( - Header::parse("Location: http://localhost:8000/redirected\r\n".to_string()).unwrap(), + Header::parse("Location: http://localhost:8000/redirected\r\n").unwrap(), Header { name: "Location".to_string(), value: "http://localhost:8000/redirected".to_string(), } ); - assert!(Header::parse("Foo".to_string()).is_none()); + assert!(Header::parse("Foo").is_none()); } #[test] diff --git a/packages/hurl/src/main.rs b/packages/hurl/src/main.rs index d9f5922452c..857bfc9bcea 100644 --- a/packages/hurl/src/main.rs +++ b/packages/hurl/src/main.rs @@ -168,7 +168,7 @@ fn execute( }; let context_dir = ContextDir::new(current_dir, file_root); - let options = http::ClientOptions { + let client_options = http::ClientOptions { cacert_file, follow_location, max_redirect, @@ -185,7 +185,7 @@ fn execute( context_dir: context_dir.clone(), }; - let mut client = http::Client::init(options); + let mut client = http::Client::new(&client_options); let pre_entry = if cli_options.interactive { cli::interactive::pre_entry @@ -202,7 +202,7 @@ fn execute( let to_entry = cli_options.to_entry; let ignore_asserts = cli_options.ignore_asserts; let very_verbose = cli_options.very_verbose; - let options = RunnerOptions { + let runner_options = RunnerOptions { fail_fast, variables, to_entry, @@ -212,7 +212,14 @@ fn execute( pre_entry, post_entry, }; - let result = runner::run(&hurl_file, filename, &mut client, &options, logger); + let result = runner::run( + &hurl_file, + filename, + &mut client, + &runner_options, + &client_options, + logger, + ); if cli_options.progress { logger.test_completed(result.success); } diff --git a/packages/hurl/src/runner/entry.rs b/packages/hurl/src/runner/entry.rs index 73343f35293..5a390267d7d 100644 --- a/packages/hurl/src/runner/entry.rs +++ b/packages/hurl/src/runner/entry.rs @@ -19,6 +19,7 @@ use std::collections::HashMap; use crate::cli::Logger; use crate::http; +use crate::http::ClientOptions; use hurl_core::ast::*; use super::core::*; @@ -49,13 +50,18 @@ use crate::runner::request::{cookie_storage_clear, cookie_storage_set}; /// ``` pub fn run( entry: Entry, - http_client: &mut http::Client, entry_index: usize, + http_client: &mut http::Client, variables: &mut HashMap, - options: &RunnerOptions, + runner_options: &RunnerOptions, + client_options: &ClientOptions, logger: &Logger, ) -> Vec { - let http_request = match eval_request(entry.request.clone(), variables, &options.context_dir) { + let http_request = match eval_request( + entry.request.clone(), + variables, + &runner_options.context_dir, + ) { Ok(r) => r, Err(error) => { return vec![EntryResult { @@ -81,13 +87,13 @@ pub fn run( use std::str::FromStr; if let Some(s) = cookie_storage_set(entry.request.clone()) { if let Ok(cookie) = http::Cookie::from_str(s.as_str()) { - http_client.add_cookie(cookie); + http_client.add_cookie(&cookie, client_options); } else { logger.warning(format!("Cookie string can not be parsed: '{}'", s).as_str()); } } if cookie_storage_clear(entry.request.clone()) { - http_client.clear_cookie_storage(); + http_client.clear_cookie_storage(client_options); } logger.debug(""); @@ -98,10 +104,14 @@ pub fn run( logger.debug(""); log_request_spec(&http_request, logger); logger.debug("Request can be run with the following curl command:"); - logger.debug(http_client.curl_command_line(&http_request).as_str()); + logger.debug( + http_client + .curl_command_line(&http_request, client_options) + .as_str(), + ); logger.debug(""); - let calls = match http_client.execute_with_redirect(&http_request, logger) { + let calls = match http_client.execute_with_redirect(&http_request, client_options, logger) { Ok(calls) => calls, Err(http_error) => { let runner_error = RunnerError::from(http_error); @@ -152,7 +162,7 @@ pub fn run( for capture_result in captures.clone() { variables.insert(capture_result.name, capture_result.value); } - asserts = if options.ignore_asserts { + asserts = if runner_options.ignore_asserts { vec![] } else { match entry.response.clone() { @@ -161,7 +171,7 @@ pub fn run( response, variables, http_response.clone(), - &options.context_dir, + &runner_options.context_dir, ), } }; diff --git a/packages/hurl/src/runner/hurl_file.rs b/packages/hurl/src/runner/hurl_file.rs index 3fd748faad2..f0541bc2215 100644 --- a/packages/hurl/src/runner/hurl_file.rs +++ b/packages/hurl/src/runner/hurl_file.rs @@ -20,6 +20,7 @@ use std::time::Instant; use crate::cli::Logger; use crate::http; +use crate::http::ClientOptions; use hurl_core::ast::*; use super::core::*; @@ -55,13 +56,13 @@ use super::entry; /// let hurl_file = parser::parse_hurl_file(s).unwrap(); /// /// // Create an HTTP client -/// let options = http::ClientOptions::default(); -/// let mut client = http::Client::init(options); +/// let client_options = http::ClientOptions::default(); +/// let mut client = http::Client::new(&client_options); /// let logger = Logger::new(false, false, filename, s); /// /// // Define runner options /// let variables = std::collections::HashMap::new(); -/// let options = runner::RunnerOptions { +/// let runner_options = runner::RunnerOptions { /// fail_fast: false, /// variables, /// to_entry: None, @@ -77,7 +78,8 @@ use super::entry; /// &hurl_file, /// filename, /// &mut client, -/// &options, +/// &runner_options, +/// &client_options, /// &logger, /// ); /// assert!(hurl_results.success); @@ -88,17 +90,18 @@ pub fn run( hurl_file: &HurlFile, filename: &str, http_client: &mut http::Client, - options: &RunnerOptions, + runner_options: &RunnerOptions, + client_options: &ClientOptions, logger: &Logger, ) -> HurlResult { let mut entries = vec![]; let mut variables = HashMap::default(); - for (key, value) in options.variables.clone() { + for (key, value) in runner_options.variables.clone() { variables.insert(key.to_string(), value); } - let n = if let Some(to_entry) = options.to_entry { + let n = if let Some(to_entry) = runner_options.to_entry { to_entry } else { hurl_file.entries.len() @@ -113,17 +116,18 @@ pub fn run( .enumerate() .collect::>() { - let exit = (options.pre_entry)(entry.clone()); + let exit = (runner_options.pre_entry)(entry.clone()); if exit { break; } let entry_results = entry::run( entry, - http_client, entry_index, + http_client, &mut variables, - options, + runner_options, + client_options, logger, ); @@ -133,8 +137,8 @@ pub fn run( } entries.push(entry_result.clone()); } - let exit = (options.post_entry)(); - if exit || (options.fail_fast && !entry_results.last().unwrap().errors.is_empty()) { + let exit = (runner_options.post_entry)(); + if exit || (runner_options.fail_fast && !entry_results.last().unwrap().errors.is_empty()) { break; } } diff --git a/packages/hurl/tests/libcurl.rs b/packages/hurl/tests/libcurl.rs index ec4d66224cf..997c5f97da6 100644 --- a/packages/hurl/tests/libcurl.rs +++ b/packages/hurl/tests/libcurl.rs @@ -29,15 +29,10 @@ pub fn new_header(name: &str, value: &str) -> Header { } } -fn default_client() -> Client { - let options = ClientOptions::default(); - Client::init(options) -} - -fn default_get_request(url: String) -> RequestSpec { +fn default_get_request(url: &str) -> RequestSpec { RequestSpec { method: Method::Get, - url, + url: url.to_string(), headers: vec![], querystring: vec![], form: vec![], @@ -52,15 +47,16 @@ fn default_get_request(url: String) -> RequestSpec { #[test] fn test_hello() { - let mut client = default_client(); + let options = ClientOptions::default(); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); - let request_spec = default_get_request("http://localhost:8000/hello".to_string()); + let request_spec = default_get_request("http://localhost:8000/hello"); assert_eq!( - client.curl_command_line(&request_spec), + client.curl_command_line(&request_spec, &options), "curl 'http://localhost:8000/hello'".to_string() ); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert_eq!(request.method, "GET".to_string()); assert_eq!(request.url, "http://localhost:8000/hello".to_string()); assert_eq!(request.headers.len(), 3); @@ -95,7 +91,8 @@ fn test_hello() { #[test] fn test_put() { - let mut client = default_client(); + let options = ClientOptions::default(); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); let request_spec = RequestSpec { method: Method::Put, @@ -109,11 +106,11 @@ fn test_put() { content_type: None, }; assert_eq!( - client.curl_command_line(&request_spec), + client.curl_command_line(&request_spec, &options), "curl 'http://localhost:8000/put' -X PUT".to_string() ); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert_eq!(request.method, "PUT".to_string()); assert_eq!(request.url, "http://localhost:8000/put".to_string()); assert!(request.headers.contains(&Header { @@ -131,7 +128,8 @@ fn test_put() { #[test] fn test_patch() { - let mut client = default_client(); + let options = ClientOptions::default(); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); let request_spec = RequestSpec { method: Method::Patch, @@ -158,11 +156,11 @@ fn test_patch() { content_type: None, }; assert_eq!( - client.curl_command_line(&request_spec), + client.curl_command_line(&request_spec, &options), "curl 'http://localhost:8000/patch/file.txt' -X PATCH -H 'Host: www.example.com' -H 'Content-Type: application/example' -H 'If-Match: \"e0023aa4e\"'".to_string() ); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert_eq!(request.method, "PATCH".to_string()); assert_eq!( request.url, @@ -187,7 +185,8 @@ fn test_patch() { #[test] fn test_custom_headers() { - let mut client = default_client(); + let options = ClientOptions::default(); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); let request_spec = RequestSpec { method: Method::Get, @@ -206,13 +205,13 @@ fn test_custom_headers() { body: Body::Binary(vec![]), content_type: None, }; - assert!(client.options.curl_args().is_empty()); + assert!(options.curl_args().is_empty()); assert_eq!( - client.curl_command_line(&request_spec), + client.curl_command_line(&request_spec, &options), "curl 'http://localhost:8000/custom-headers' -H 'Fruit: Raspberry' -H 'Fruit: Apple' -H 'Fruit: Banana' -H 'Fruit: Grape' -H 'Color: Green'".to_string() ); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert_eq!(request.method, "GET".to_string()); assert_eq!( request.url, @@ -232,7 +231,8 @@ fn test_custom_headers() { #[test] fn test_querystring_params() { - let mut client = default_client(); + let options = ClientOptions::default(); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); let request_spec = RequestSpec { method: Method::Get, @@ -263,10 +263,10 @@ fn test_querystring_params() { content_type: None, }; assert_eq!( - client.curl_command_line(&request_spec), + client.curl_command_line(&request_spec, &options), "curl 'http://localhost:8000/querystring-params?param1=value1¶m2=¶m3=a%3Db¶m4=1%2C2%2C3'".to_string() ); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert_eq!(request.method, "GET".to_string()); assert_eq!(request.url, "http://localhost:8000/querystring-params?param1=value1¶m2=¶m3=a%3Db¶m4=1%2C2%2C3".to_string()); assert_eq!(request.headers.len(), 3); @@ -281,7 +281,8 @@ fn test_querystring_params() { #[test] fn test_form_params() { - let mut client = default_client(); + let options = ClientOptions::default(); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); let request_spec = RequestSpec { method: Method::Post, @@ -320,11 +321,11 @@ fn test_form_params() { content_type: Some("application/x-www-form-urlencoded".to_string()), }; assert_eq!( - client.curl_command_line(&request_spec), + client.curl_command_line(&request_spec, &options), "curl 'http://localhost:8000/form-params' --data 'param1=value1' --data 'param2=' --data 'param3=a%3Db' --data 'param4=a%253db' --data 'values[0]=0' --data 'values[1]=1'".to_string() ); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert_eq!(request.method, "POST".to_string()); assert_eq!(request.url, "http://localhost:8000/form-params".to_string()); assert!(request.headers.contains(&Header { @@ -336,8 +337,8 @@ fn test_form_params() { assert!(response.body.is_empty()); // make sure you can reuse client for other request - let request = default_get_request("http://localhost:8000/hello".to_string()); - let (request, response) = client.execute(&request, &logger).unwrap(); + let request = default_get_request("http://localhost:8000/hello"); + let (request, response) = client.execute(&request, &options, &logger).unwrap(); assert_eq!(request.method, "GET".to_string()); assert_eq!(request.url, "http://localhost:8000/hello".to_string()); assert_eq!(request.headers.len(), 3); @@ -351,10 +352,11 @@ fn test_form_params() { #[test] fn test_redirect() { - let request_spec = default_get_request("http://localhost:8000/redirect".to_string()); + let request_spec = default_get_request("http://localhost:8000/redirect"); let logger = Logger::new(false, false, "", ""); - let mut client = default_client(); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let options = ClientOptions::default(); + let mut client = Client::new(&options); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert_eq!(request.method, "GET".to_string()); assert_eq!(request.url, "http://localhost:8000/redirect".to_string()); assert_eq!(request.headers.len(), 3); @@ -369,21 +371,21 @@ fn test_redirect() { #[test] fn test_follow_location() { - let request_spec = default_get_request("http://localhost:8000/redirect".to_string()); + let request_spec = default_get_request("http://localhost:8000/redirect"); let logger = Logger::new(false, false, "", ""); let options = ClientOptions { follow_location: true, ..Default::default() }; - let mut client = Client::init(options); - assert_eq!(client.options.curl_args(), vec!["-L".to_string()]); + let mut client = Client::new(&options); + assert_eq!(options.curl_args(), vec!["-L".to_string()]); assert_eq!( - client.curl_command_line(&request_spec), + client.curl_command_line(&request_spec, &options), "curl 'http://localhost:8000/redirect' -L".to_string() ); let calls = client - .execute_with_redirect(&request_spec, &logger) + .execute_with_redirect(&request_spec, &options, &logger) .unwrap(); assert_eq!(calls.len(), 2); @@ -406,8 +408,10 @@ fn test_follow_location() { assert_eq!(client.redirect_count, 1); // make sure that the redirect count is reset to 0 - let request = default_get_request("http://localhost:8000/hello".to_string()); - let calls = client.execute_with_redirect(&request, &logger).unwrap(); + let request = default_get_request("http://localhost:8000/hello"); + let calls = client + .execute_with_redirect(&request, &options, &logger) + .unwrap(); let (_, response) = calls.get(0).unwrap(); assert_eq!(response.status, 200); assert_eq!(response.body, b"Hello World!".to_vec()); @@ -421,27 +425,27 @@ fn test_max_redirect() { max_redirect: Some(10), ..Default::default() }; - let mut client = Client::init(options); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); - let request_spec = default_get_request("http://localhost:8000/redirect/15".to_string()); + let request_spec = default_get_request("http://localhost:8000/redirect/15"); assert_eq!( - client.curl_command_line(&request_spec), + client.curl_command_line(&request_spec, &options), "curl 'http://localhost:8000/redirect/15' -L --max-redirs 10".to_string() ); let error = client - .execute_with_redirect(&request_spec, &logger) + .execute_with_redirect(&request_spec, &options, &logger) .err() .unwrap(); assert_eq!(error, HttpError::TooManyRedirect); - let request_spec = default_get_request("http://localhost:8000/redirect/8".to_string()); + let request_spec = default_get_request("http://localhost:8000/redirect/8"); assert_eq!( - client.curl_command_line(&request_spec), + client.curl_command_line(&request_spec, &options), "curl 'http://localhost:8000/redirect/8' -L --max-redirs 10".to_string() ); let calls = client - .execute_with_redirect(&request_spec, &logger) + .execute_with_redirect(&request_spec, &options, &logger) .unwrap(); let (request, response) = calls.last().unwrap(); assert_eq!(request.url, "http://localhost:8000/redirect/0".to_string()); @@ -455,7 +459,8 @@ fn test_max_redirect() { #[test] fn test_multipart_form_data() { - let mut client = default_client(); + let options = ClientOptions::default(); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); let request_spec = RequestSpec { method: Method::Post, @@ -492,11 +497,11 @@ fn test_multipart_form_data() { content_type: Some("multipart/form-data".to_string()), }; assert_eq!( - client.curl_command_line(&request_spec), + client.curl_command_line(&request_spec, &options), "curl 'http://localhost:8000/multipart-form-data' -F 'key1=value1' -F 'upload1=@data.txt;type=text/plain' -F 'upload2=@data.html;type=text/html' -F 'upload3=@data.txt;type=text/html'".to_string() ); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert!(request.headers.contains(&Header { name: "Content-Length".to_string(), value: "627".to_string(), @@ -505,8 +510,8 @@ fn test_multipart_form_data() { assert!(response.body.is_empty()); // make sure you can reuse client for other request - let request_spec = default_get_request("http://localhost:8000/hello".to_string()); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let request_spec = default_get_request("http://localhost:8000/hello"); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert_eq!(request.method, "GET".to_string()); assert_eq!(response.status, 200); assert_eq!(response.body, b"Hello World!".to_vec()); @@ -518,7 +523,8 @@ fn test_multipart_form_data() { #[test] fn test_post_bytes() { - let mut client = default_client(); + let options = ClientOptions::default(); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); let request_spec = RequestSpec { method: Method::Post, @@ -532,10 +538,10 @@ fn test_post_bytes() { content_type: None, }; assert_eq!( - client.curl_command_line(&request_spec), + client.curl_command_line(&request_spec, &options), "curl 'http://localhost:8000/post-base64' -H 'Content-Type: application/octet-stream' --data $'\\x48\\x65\\x6c\\x6c\\x6f\\x20\\x57\\x6f\\x72\\x6c\\x64\\x21'".to_string() ); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert!(request.headers.contains(&Header { name: "Content-Length".to_string(), value: "12".to_string(), @@ -549,7 +555,8 @@ fn test_post_bytes() { #[test] fn test_expect() { - let mut client = default_client(); + let options = ClientOptions::default(); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); let request_spec = RequestSpec { method: Method::Post, @@ -566,11 +573,11 @@ fn test_expect() { content_type: None, }; assert_eq!( - client.curl_command_line(&request_spec), + client.curl_command_line(&request_spec, &options), "curl 'http://localhost:8000/expect' -H 'Expect: 100-continue' -H 'Content-Type:' --data 'data'".to_string() ); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert!(request.headers.contains(&Header { name: "Expect".to_string(), value: "100-continue".to_string(), @@ -586,7 +593,7 @@ fn test_basic_authentication() { user: Some("bob@email.com:secret".to_string()), ..Default::default() }; - let mut client = Client::init(options); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); let request_spec = RequestSpec { method: Method::Get, @@ -600,11 +607,11 @@ fn test_basic_authentication() { content_type: None, }; assert_eq!( - client.curl_command_line(&request_spec), + client.curl_command_line(&request_spec, &options), "curl 'http://localhost:8000/basic-authentication' --user 'bob@email.com:secret'" .to_string() ); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert!(request.headers.contains(&Header { name: "Authorization".to_string(), value: "Basic Ym9iQGVtYWlsLmNvbTpzZWNyZXQ=".to_string(), @@ -613,7 +620,8 @@ fn test_basic_authentication() { assert_eq!(response.version, Version::Http10); assert_eq!(response.body, b"You are authenticated".to_vec()); - let mut client = default_client(); + let options = ClientOptions::default(); + let mut client = Client::new(&options); let request_spec = RequestSpec { method: Method::Get, url: "http://bob%40email.com:secret@localhost:8000/basic-authentication".to_string(), @@ -629,7 +637,7 @@ fn test_basic_authentication() { request_spec.curl_args(&ContextDir::default()), vec!["'http://bob%40email.com:secret@localhost:8000/basic-authentication'".to_string()] ); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert!(request.headers.contains(&Header { name: "Authorization".to_string(), value: "Basic Ym9iQGVtYWlsLmNvbTpzZWNyZXQ=".to_string(), @@ -645,10 +653,10 @@ fn test_cacert() { cacert_file: Some("tests/cert.pem".to_string()), ..Default::default() }; - let mut client = Client::init(options); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); - let request_spec = default_get_request("https://localhost:8001/hello".to_string()); - let (_, response) = client.execute(&request_spec, &logger).unwrap(); + let request_spec = default_get_request("https://localhost:8001/hello"); + let (_, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert_eq!(response.status, 200); } @@ -656,10 +664,14 @@ fn test_cacert() { #[test] fn test_error_could_not_resolve_host() { - let mut client = default_client(); + let options = ClientOptions::default(); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); - let request = default_get_request("http://unknown".to_string()); - let error = client.execute(&request, &logger).err().unwrap(); + let request_spec = default_get_request("http://unknown"); + let error = client + .execute(&request_spec, &options, &logger) + .err() + .unwrap(); assert!(matches!(error, HttpError::Libcurl { .. })); if let HttpError::Libcurl { code, @@ -675,10 +687,14 @@ fn test_error_could_not_resolve_host() { #[test] fn test_error_fail_to_connect() { - let mut client = default_client(); + let options = ClientOptions::default(); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); - let request_spec = default_get_request("http://localhost:9999".to_string()); - let error = client.execute(&request_spec, &logger).err().unwrap(); + let request_spec = default_get_request("http://localhost:9999"); + let error = client + .execute(&request_spec, &options, &logger) + .err() + .unwrap(); assert!(matches!(error, HttpError::Libcurl { .. })); if let HttpError::Libcurl { code, @@ -695,9 +711,9 @@ fn test_error_fail_to_connect() { proxy: Some("localhost:9999".to_string()), ..Default::default() }; - let mut client = Client::init(options); - let request = default_get_request("http://localhost:8000/hello".to_string()); - let error = client.execute(&request, &logger).err().unwrap(); + let mut client = Client::new(&options); + let request = default_get_request("http://localhost:8000/hello"); + let error = client.execute(&request, &options, &logger).err().unwrap(); assert!(matches!(error, HttpError::Libcurl { .. })); if let HttpError::Libcurl { code, @@ -718,10 +734,13 @@ fn test_error_could_not_resolve_proxy_name() { proxy: Some("unknown".to_string()), ..Default::default() }; - let mut client = Client::init(options); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); - let request_spec = default_get_request("http://localhost:8000/hello".to_string()); - let error = client.execute(&request_spec, &logger).err().unwrap(); + let request_spec = default_get_request("http://localhost:8000/hello"); + let error = client + .execute(&request_spec, &options, &logger) + .err() + .unwrap(); assert!(matches!(error, HttpError::Libcurl { .. })); if let HttpError::Libcurl { code, @@ -738,10 +757,13 @@ fn test_error_could_not_resolve_proxy_name() { #[test] fn test_error_ssl() { let options = ClientOptions::default(); - let mut client = Client::init(options); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); - let request_spec = default_get_request("https://localhost:8001/hello".to_string()); - let error = client.execute(&request_spec, &logger).err().unwrap(); + let request_spec = default_get_request("https://localhost:8001/hello"); + let error = client + .execute(&request_spec, &options, &logger) + .err() + .unwrap(); if let HttpError::Libcurl { code, description, @@ -768,10 +790,13 @@ fn test_timeout() { timeout: Duration::from_millis(100), ..Default::default() }; - let mut client = Client::init(options); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); - let request_spec = default_get_request("http://localhost:8000/timeout".to_string()); - let error = client.execute(&request_spec, &logger).err().unwrap(); + let request_spec = default_get_request("http://localhost:8000/timeout"); + let error = client + .execute(&request_spec, &options, &logger) + .err() + .unwrap(); assert!(matches!(error, HttpError::Libcurl { .. })); if let HttpError::Libcurl { code, @@ -791,7 +816,7 @@ fn test_accept_encoding() { compressed: true, ..Default::default() }; - let mut client = Client::init(options); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); let request_spec = RequestSpec { @@ -805,7 +830,7 @@ fn test_accept_encoding() { body: Body::Binary(vec![]), content_type: None, }; - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert!(request.headers.contains(&Header { name: "Accept-Encoding".to_string(), value: "gzip, deflate, br".to_string(), @@ -823,14 +848,17 @@ fn test_connect_timeout() { connect_timeout: Duration::from_secs(1), ..Default::default() }; - let mut client = Client::init(options); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); - let request_spec = default_get_request("http://10.0.0.0".to_string()); + let request_spec = default_get_request("http://10.0.0.0"); assert_eq!( - client.curl_command_line(&request_spec), + client.curl_command_line(&request_spec, &options), "curl 'http://10.0.0.0' --connect-timeout 1".to_string() ); - let error = client.execute(&request_spec, &logger).err().unwrap(); + let error = client + .execute(&request_spec, &options, &logger) + .err() + .unwrap(); assert!(matches!(error, HttpError::Libcurl { .. })); if let HttpError::Libcurl { code, @@ -860,7 +888,8 @@ fn test_connect_timeout() { #[test] fn test_cookie() { - let mut client = default_client(); + let options = ClientOptions::default(); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); let request_spec = RequestSpec { method: Method::Get, @@ -877,14 +906,14 @@ fn test_cookie() { content_type: None, }; assert_eq!( - client.curl_command_line(&request_spec), + client.curl_command_line(&request_spec, &options), "curl 'http://localhost:8000/cookies/set-request-cookie1-valueA' --cookie 'cookie1=valueA'" .to_string() ); //assert_eq!(request.cookies(), vec!["cookie1=valueA".to_string(),]); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert!(request.headers.contains(&Header { name: "Cookie".to_string(), value: "cookie1=valueA".to_string(), @@ -903,13 +932,14 @@ fn test_cookie() { body: Body::Binary(vec![]), content_type: None, }; - let (_request, response) = client.execute(&request_spec, &logger).unwrap(); + let (_request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert_eq!(response.status, 200); } #[test] fn test_multiple_request_cookies() { - let mut client = default_client(); + let options = ClientOptions::default(); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); let request_spec = RequestSpec { method: Method::Get, @@ -936,11 +966,11 @@ fn test_multiple_request_cookies() { content_type: None, }; assert_eq!( - client.curl_command_line(&request_spec), + client.curl_command_line(&request_spec, &options), "curl 'http://localhost:8000/cookies/set-multiple-request-cookies' --cookie 'user1=Bob; user2=Bill; user3=Bruce'".to_string() ); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert!(request.headers.contains(&Header { name: "Cookie".to_string(), value: "user1=Bob; user2=Bill; user3=Bruce".to_string(), @@ -951,11 +981,12 @@ fn test_multiple_request_cookies() { #[test] fn test_cookie_storage() { - let mut client = default_client(); + let options = ClientOptions::default(); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); let request_spec = - default_get_request("http://localhost:8000/cookies/set-session-cookie2-valueA".to_string()); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + default_get_request("http://localhost:8000/cookies/set-session-cookie2-valueA"); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert_eq!( request.url, "http://localhost:8000/cookies/set-session-cookie2-valueA".to_string() @@ -978,10 +1009,9 @@ fn test_cookie_storage() { } ); - let request_spec = default_get_request( - "http://localhost:8000/cookies/assert-that-cookie2-is-valueA".to_string(), - ); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let request_spec = + default_get_request("http://localhost:8000/cookies/assert-that-cookie2-is-valueA"); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert!(request.headers.contains(&Header { name: "Cookie".to_string(), value: "cookie2=valueA".to_string(), @@ -996,17 +1026,16 @@ fn test_cookie_file() { cookie_input_file: Some("tests/cookies.txt".to_string()), ..Default::default() }; - let mut client = Client::init(options); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); - let request_spec = default_get_request( - "http://localhost:8000/cookies/assert-that-cookie2-is-valueA".to_string(), - ); + let request_spec = + default_get_request("http://localhost:8000/cookies/assert-that-cookie2-is-valueA"); assert_eq!( - client.curl_command_line(&request_spec), + client.curl_command_line(&request_spec, &options), "curl 'http://localhost:8000/cookies/assert-that-cookie2-is-valueA' --cookie tests/cookies.txt".to_string() ); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert_eq!( request.url, "http://localhost:8000/cookies/assert-that-cookie2-is-valueA" @@ -1031,14 +1060,14 @@ fn test_proxy() { proxy: Some("localhost:8888".to_string()), ..Default::default() }; - let mut client = Client::init(options); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); - let request_spec = default_get_request("http://localhost:8000/proxy".to_string()); + let request_spec = default_get_request("http://localhost:8000/proxy"); assert_eq!( - client.curl_command_line(&request_spec), + client.curl_command_line(&request_spec, &options), "curl 'http://localhost:8000/proxy' --proxy 'localhost:8888'".to_string() ); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert_eq!(request.url, "http://localhost:8000/proxy"); assert_eq!(response.status, 200); } @@ -1051,16 +1080,16 @@ fn test_insecure() { insecure: true, ..Default::default() }; - let mut client = Client::init(options); + let mut client = Client::new(&options); let logger = Logger::new(false, false, "", ""); - assert_eq!(client.options.curl_args(), vec!["--insecure".to_string()]); - let request_spec = default_get_request("https://localhost:8001/hello".to_string()); + assert_eq!(options.curl_args(), vec!["--insecure".to_string()]); + let request_spec = default_get_request("https://localhost:8001/hello"); assert_eq!( - client.curl_command_line(&request_spec), + client.curl_command_line(&request_spec, &options), "curl 'https://localhost:8001/hello' --insecure".to_string() ); - let (request, response) = client.execute(&request_spec, &logger).unwrap(); + let (request, response) = client.execute(&request_spec, &options, &logger).unwrap(); assert_eq!(request.url, "https://localhost:8001/hello"); assert_eq!(response.status, 200); } diff --git a/packages/hurl/tests/runner.rs b/packages/hurl/tests/runner.rs index bb096b3f6c9..72b59f4685b 100644 --- a/packages/hurl/tests/runner.rs +++ b/packages/hurl/tests/runner.rs @@ -33,11 +33,11 @@ fn test_hurl_file() { let content = cli::read_to_string(filename).expect("Something went wrong reading the file"); let hurl_file = parser::parse_hurl_file(content.as_str()).unwrap(); let variables = HashMap::new(); - let options = http::ClientOptions::default(); - let mut client = http::Client::init(options); + let client_options = http::ClientOptions::default(); + let mut client = http::Client::new(&client_options); let logger = Logger::new(false, false, filename, &content); - let options = RunnerOptions { + let runner_options = RunnerOptions { fail_fast: false, variables, to_entry: None, @@ -48,7 +48,14 @@ fn test_hurl_file() { post_entry: || true, }; - let _hurl_log = runner::run(&hurl_file, filename, &mut client, &options, &logger); + let _hurl_log = runner::run( + &hurl_file, + filename, + &mut client, + &runner_options, + &client_options, + &logger, + ); } #[cfg(test)] @@ -114,8 +121,8 @@ fn hello_request() -> Request { #[test] fn test_hello() { - let options = http::ClientOptions::default(); - let mut client = http::Client::init(options); + let client_options = http::ClientOptions::default(); + let mut client = http::Client::new(&client_options); // We construct a Hurl file ast "by hand", with fake source info. // In this particular case, the raw content is empty as the Hurl file hasn't @@ -162,7 +169,7 @@ fn test_hello() { line_terminators: vec![], }; let variables = HashMap::new(); - let options = RunnerOptions { + let runner_options = RunnerOptions { fail_fast: true, variables, to_entry: None, @@ -173,5 +180,12 @@ fn test_hello() { post_entry: || true, }; - runner::run(&hurl_file, "filename", &mut client, &options, &logger); + runner::run( + &hurl_file, + "filename", + &mut client, + &runner_options, + &client_options, + &logger, + ); }