extern/nushell
1
0
Fork 1
mirror of https://github.com/nushell/nushell.git synced 2025-06-30 22:50:14 +02:00
Code Issues Packages Projects Releases Wiki Activity

changes Reqwest to Ureq. (#8320)

Browse Source 
# Description

_(Thank you for improving Nushell. Please, check our [contributing
guide](../CONTRIBUTING.md) and talk to the core team before making major
changes.)_

This pull request removes `Reqwest` and replaces it with `Ureq` to
remove some of our dependencies, giving us faster compile times as well
as smaller binaries. `Ureq` does not have an async runtime included so
we do not need build heavy dependencies such as `Tokio`. From older
tests I had the number of build units be reduced from `430 -> 392`.
The default of `Ureq` uses `Rustls` but it has been configured to
instead use `native_tls` which should work exactly the same as the `tls`
works now.
I removed `content-length` from the http commands as after refactoring i
did not see a reason to have it available, correct me if this is
something we should preserve.

In the medium, to long term, we should maybe consider changing to
`rustls` to have the same `tls` on all platforms.

# User-Facing Changes

_(List of all changes that impact the user experience here. This helps
us keep track of breaking changes.)_

# Tests + Formatting

Don't forget to add tests that cover your changes.

Make sure you've run and fixed any issues with these commands:

- `cargo fmt --all -- --check` to check standard code formatting (`cargo
fmt --all` applies these changes)
- `cargo clippy --workspace -- -D warnings -D clippy::unwrap_used -A
clippy::needless_collect` to check that you're using the standard code
style
- `cargo test --workspace` to check that all tests pass

# After Submitting

If your PR had any user-facing changes, update [the
documentation](https://github.com/nushell/nushell.github.io) after the
PR is merged, if necessary. This will help us keep the docs up to date.
This commit is contained in:
Filip Andersson
2023-03-05 23:48:13 +01:00
committed by GitHub
parent d6141881f2
commit f6ca62384e
15 changed files with 172 additions and 302 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
crates/nu-command/Cargo.toml
View File

@ -72,7 +72,8 @@ quick-xml = "0.27"
rand = "0.8"
rayon = "1.6.1"
regex = "1.7.1"
reqwest = { version = "0.11", features = ["blocking", "json"] }
ureq = { version = "2.6.2", default-features = false, features = ["json", "charset", "native-tls", "gzip"] }
native-tls = "0.2.11"
roxmltree = "0.18.0"
rust-embed = "6.3.0"
same-file = "1.0.6"

219
crates/nu-command/src/network/http/client.rs
View File

@ -7,8 +7,8 @@ use nu_protocol::engine::{EngineState, Stack};
use nu_protocol::{
BufferedReader, IntoPipelineData, PipelineData, RawStream, ShellError, Span, Value,
};
use reqwest::blocking::{RequestBuilder, Response};
use reqwest::{blocking, Error, StatusCode};
use ureq::{Error, ErrorKind, Request, Response};
use std::collections::HashMap;
use std::io::BufReader;
use std::path::PathBuf;
@ -25,12 +25,16 @@ pub enum BodyType {
// Only panics if the user agent is invalid but we define it statically so either
// it always or never fails
pub fn http_client(allow_insecure: bool) -> blocking::Client {
blocking::Client::builder()
.user_agent("nushell")
pub fn http_client(allow_insecure: bool) -> ureq::Agent {
let tls = native_tls::TlsConnector::builder()
.danger_accept_invalid_certs(allow_insecure)
.build()
.expect("Failed to build reqwest client")
.expect("Failed to build network tls");
ureq::builder()
.user_agent("nushell")
.tls_connector(std::sync::Arc::new(tls))
.build()
}
pub fn http_parse_url(
@ -62,15 +66,9 @@ pub fn response_to_buffer(
) -> PipelineData {
// Try to get the size of the file to be downloaded.
// This is helpful to show the progress of the stream.
let buffer_size = match &response.headers().get("content-length") {
let buffer_size = match response.header("content-length") {
Some(content_length) => {
let content_length = &(*content_length).clone(); // binding
let content_length = content_length
.to_str()
.unwrap_or("")
.parse::<u64>()
.unwrap_or(0);
let content_length = content_length.parse::<u64>().unwrap_or_default();
if content_length == 0 {
None
@ -81,7 +79,8 @@ pub fn response_to_buffer(
_ => None,
};
let buffered_input = BufReader::new(response);
let reader = response.into_reader();
let buffered_input = BufReader::new(reader);
PipelineData::ExternalStream {
stdout: Some(RawStream::new(
@ -103,8 +102,8 @@ pub fn response_to_buffer(
pub fn request_add_authorization_header(
user: Option<String>,
password: Option<String>,
mut request: RequestBuilder,
) -> RequestBuilder {
mut request: Request,
) -> Request {
let base64_engine = GeneralPurpose::new(&alphabet::STANDARD, PAD);
let login = match (user, password) {
@ -127,71 +126,87 @@ pub fn request_add_authorization_header(
};
if let Some(login) = login {
request = request.header("Authorization", format!("Basic {login}"));
request = request.set("Authorization", &format!("Basic {login}"));
}
request
}
pub fn request_set_body(
pub fn send_request(
request: Request,
span: Span,
body: Option<Value>,
content_type: Option<String>,
content_length: Option<String>,
body: Value,
mut request: RequestBuilder,
) -> Result<RequestBuilder, ShellError> {
// set the content-type header before using e.g., request.json
// because that will avoid duplicating the header value
if let Some(val) = &content_type {
request = request.header("Content-Type", val);
) -> Result<Response, ShellError> {
let request_url = request.url().to_string();
if body.is_none() {
return request
.call()
.map_err(|err| handle_response_error(span, &request_url, err));
}
let body = body.expect("Should never be none.");
let body_type = match content_type {
Some(it) if it == "application/json" => BodyType::Json,
Some(it) if it == "application/x-www-form-urlencoded" => BodyType::Form,
_ => BodyType::Unknown,
};
match body {
Value::Binary { val, .. } => {
request = request.body(val);
}
Value::String { val, .. } => {
request = request.body(val);
}
Value::Binary { val, .. } => request
.send_bytes(&val)
.map_err(|err| handle_response_error(span, &request_url, err)),
Value::String { val, .. } => request
.send_string(&val)
.map_err(|err| handle_response_error(span, &request_url, err)),
Value::Record { .. } if body_type == BodyType::Json => {
let data = value_to_json_value(&body)?;
request = request.json(&data);
request
.send_json(data)
.map_err(|err| handle_response_error(span, &request_url, err))
}
Value::Record { .. } if body_type == BodyType::Form => {
let data = value_to_json_value(&body)?;
request = request.form(&data);
Value::Record { cols, vals, .. } if body_type == BodyType::Form => {
let mut data: Vec<(String, String)> = Vec::with_capacity(cols.len());
for (col, val) in cols.iter().zip(vals.iter()) {
data.push((col.clone(), val.as_string()?))
}
let data = data
.iter()
.map(|(a, b)| (a.as_str(), b.as_str()))
.collect::<Vec<(&str, &str)>>();
request
.send_form(&data[..])
.map_err(|err| handle_response_error(span, &request_url, err))
}
Value::List { vals, .. } if body_type == BodyType::Form => {
if vals.len() % 2 != 0 {
return Err(ShellError::IOError("unsupported body input".into()));
}
let data = vals
.chunks(2)
.map(|it| Ok((it[0].as_string()?, it[1].as_string()?)))
.collect::<Result<Vec<(String, String)>, ShellError>>()?;
request = request.form(&data)
}
_ => {
return Err(ShellError::IOError("unsupported body input".into()));
}
};
if let Some(val) = content_length {
request = request.header("Content-Length", val);
let data = data
.iter()
.map(|(a, b)| (a.as_str(), b.as_str()))
.collect::<Vec<(&str, &str)>>();
request
.send_form(&data)
.map_err(|err| handle_response_error(span, &request_url, err))
}
_ => Err(ShellError::IOError("unsupported body input".into())),
}
Ok(request)
}
pub fn request_set_timeout(
timeout: Option<Value>,
mut request: RequestBuilder,
) -> Result<RequestBuilder, ShellError> {
mut request: Request,
) -> Result<Request, ShellError> {
if let Some(timeout) = timeout {
let val = timeout.as_i64()?;
if val.is_negative() || val < 1 {
@ -210,8 +225,8 @@ pub fn request_set_timeout(
pub fn request_add_custom_headers(
headers: Option<Value>,
mut request: RequestBuilder,
) -> Result<RequestBuilder, ShellError> {
mut request: Request,
) -> Result<Request, ShellError> {
if let Some(headers) = headers {
let mut custom_headers: HashMap<String, Value> = HashMap::new();
@ -257,7 +272,7 @@ pub fn request_add_custom_headers(
for (k, v) in &custom_headers {
if let Ok(s) = v.as_string() {
request = request.header(k, s);
request = request.set(k, &s);
}
}
}
@ -265,48 +280,41 @@ pub fn request_add_custom_headers(
Ok(request)
}
fn handle_response_error(span: Span, requested_url: &String, response: Error) -> ShellError {
// Explicitly turn 4xx and 5xx statuses into errors.
if response.is_timeout() {
ShellError::NetworkFailure(format!("Request to {requested_url} has timed out"), span)
} else if response.is_status() {
match response.status() {
Some(err_code) if err_code == StatusCode::NOT_FOUND => ShellError::NetworkFailure(
format!("Requested file not found (404): {requested_url:?}"),
span,
),
Some(err_code) if err_code == StatusCode::MOVED_PERMANENTLY => {
ShellError::NetworkFailure(
format!("Resource moved permanently (301): {requested_url:?}"),
span,
)
}
Some(err_code) if err_code == StatusCode::BAD_REQUEST => {
ShellError::NetworkFailure(format!("Bad request (400) to {requested_url:?}"), span)
}
Some(err_code) if err_code == StatusCode::FORBIDDEN => ShellError::NetworkFailure(
format!("Access forbidden (403) to {requested_url:?}"),
span,
),
_ => ShellError::NetworkFailure(
format!(
"Cannot make request to {:?}. Error is {:?}",
requested_url,
response.to_string()
),
span,
),
fn handle_response_error(span: Span, requested_url: &str, response_err: Error) -> ShellError {
match response_err {
Error::Status(301, _) => ShellError::NetworkFailure(
format!("Resource moved permanently (301): {requested_url:?}"),
span,
),
Error::Status(400, _) => {
ShellError::NetworkFailure(format!("Bad request (400) to {requested_url:?}"), span)
}
} else {
ShellError::NetworkFailure(
Error::Status(403, _) => {
ShellError::NetworkFailure(format!("Access forbidden (403) to {requested_url:?}"), span)
}
Error::Status(404, _) => ShellError::NetworkFailure(
format!("Requested file not found (404): {requested_url:?}"),
span,
),
Error::Status(408, _) => {
ShellError::NetworkFailure(format!("Request timeout (408): {requested_url:?}"), span)
}
Error::Status(_, _) => ShellError::NetworkFailure(
format!(
"Cannot make request to {:?}. Error is {:?}",
requested_url,
response.to_string()
response_err.to_string()
),
span,
)
),
Error::Transport(t) => match t {
t if t.kind() == ErrorKind::ConnectionFailed => ShellError::NetworkFailure(
format!("Cannot make request to {requested_url}, there was an error establishing a connection.",),
span,
),
t => ShellError::NetworkFailure(t.to_string(), span),
},
}
}
@ -316,20 +324,11 @@ pub fn request_handle_response(
span: Span,
requested_url: &String,
raw: bool,
response: Result<Response, Error>,
response: Result<Response, ShellError>,
) -> Result<PipelineData, ShellError> {
match response {
Ok(resp) => match resp.headers().get("content-type") {
Ok(resp) => match resp.header("content-type") {
Some(content_type) => {
let content_type = content_type.to_str().map_err(|e| {
ShellError::GenericError(
e.to_string(),
"".to_string(),
None,
Some("MIME type were invalid".to_string()),
Vec::new(),
)
})?;
let content_type = mime::Mime::from_str(content_type).map_err(|_| {
ShellError::GenericError(
format!("MIME type unknown: {content_type}"),
@ -386,29 +385,29 @@ pub fn request_handle_response(
}
None => Ok(response_to_buffer(resp, engine_state, span)),
},
Err(e) => Err(handle_response_error(span, requested_url, e)),
Err(e) => Err(e),
}
}
pub fn request_handle_response_headers(
span: Span,
requested_url: &String,
response: Result<Response, Error>,
response: Result<Response, ShellError>,
) -> Result<PipelineData, ShellError> {
match response {
Ok(resp) => {
let cols: Vec<String> = resp.headers().keys().map(|name| name.to_string()).collect();
let cols = resp.headers_names();
let mut vals = Vec::with_capacity(cols.len());
for value in resp.headers().values() {
match value.to_str() {
Ok(str_value) => vals.push(Value::String {
for key in &cols {
match resp.header(key) {
// match value.to_str() {
Some(str_value) => vals.push(Value::String {
val: str_value.to_string(),
span,
}),
Err(err) => {
None => {
return Err(ShellError::GenericError(
format!("Failure when converting header value: {err}"),
"Failure when converting header value".to_string(),
"".to_string(),
None,
Some("Failure when converting header value".to_string()),
@ -420,6 +419,6 @@ pub fn request_handle_response_headers(
Ok(Value::Record { cols, vals, span }.into_pipeline_data())
}
Err(e) => Err(handle_response_error(span, requested_url, e)),
Err(e) => Err(e),
}
}

20
crates/nu-command/src/network/http/delete.rs
View File

@ -7,7 +7,7 @@ use nu_protocol::{
use crate::network::http::client::{
http_client, http_parse_url, request_add_authorization_header, request_add_custom_headers,
request_handle_response, request_set_body, request_set_timeout,
request_handle_response, request_set_timeout, send_request,
};
#[derive(Clone)]
@ -46,12 +46,6 @@ impl Command for SubCommand {
"the MIME type of content to post",
Some('t'),
)
.named(
"content-length",
SyntaxShape::Any,
"the length of the content being posted",
Some('l'),
)
.named(
"max-time",
SyntaxShape::Int,
@ -137,7 +131,6 @@ struct Arguments {
headers: Option<Value>,
data: Option<Value>,
content_type: Option<String>,
content_length: Option<String>,
raw: bool,
insecure: bool,
user: Option<String>,
@ -156,7 +149,6 @@ fn run_delete(
headers: call.get_flag(engine_state, stack, "headers")?,
data: call.get_flag(engine_state, stack, "data")?,
content_type: call.get_flag(engine_state, stack, "content-type")?,
content_length: call.get_flag(engine_state, stack, "content-length")?,
raw: call.has_flag("raw"),
insecure: call.has_flag("insecure"),
user: call.get_flag(engine_state, stack, "user")?,
@ -176,19 +168,17 @@ fn helper(
args: Arguments,
) -> Result<PipelineData, ShellError> {
let span = args.url.span()?;
let (requested_url, url) = http_parse_url(call, span, args.url)?;
let (requested_url, _) = http_parse_url(call, span, args.url)?;
let client = http_client(args.insecure);
let mut request = client.delete(url);
let mut request = client.delete(&requested_url);
if let Some(data) = args.data {
request = request_set_body(args.content_type, args.content_length, data, request)?;
}
request = request_set_timeout(args.timeout, request)?;
request = request_add_authorization_header(args.user, args.password, request);
request = request_add_custom_headers(args.headers, request)?;
let response = request.send().and_then(|r| r.error_for_status());
let response = send_request(request, span, args.data, args.content_type);
request_handle_response(
engine_state,
stack,

19
crates/nu-command/src/network/http/get.rs
View File

@ -7,7 +7,7 @@ use nu_protocol::{
use crate::network::http::client::{
http_client, http_parse_url, request_add_authorization_header, request_add_custom_headers,
request_handle_response, request_set_body, request_set_timeout,
request_handle_response, request_set_timeout, send_request,
};
#[derive(Clone)]
@ -46,12 +46,6 @@ impl Command for SubCommand {
"the MIME type of content to post",
Some('t'),
)
.named(
"content-length",
SyntaxShape::Any,
"the length of the content being posted",
Some('l'),
)
.named(
"max-time",
SyntaxShape::Int,
@ -138,7 +132,6 @@ struct Arguments {
headers: Option<Value>,
data: Option<Value>,
content_type: Option<String>,
content_length: Option<String>,
raw: bool,
insecure: bool,
user: Option<String>,
@ -157,7 +150,6 @@ fn run_get(
headers: call.get_flag(engine_state, stack, "headers")?,
data: call.get_flag(engine_state, stack, "data")?,
content_type: call.get_flag(engine_state, stack, "content-type")?,
content_length: call.get_flag(engine_state, stack, "content-length")?,
raw: call.has_flag("raw"),
insecure: call.has_flag("insecure"),
user: call.get_flag(engine_state, stack, "user")?,
@ -176,19 +168,16 @@ fn helper(
args: Arguments,
) -> Result<PipelineData, ShellError> {
let span = args.url.span()?;
let (requested_url, url) = http_parse_url(call, span, args.url)?;
let (requested_url, _) = http_parse_url(call, span, args.url)?;
let client = http_client(args.insecure);
let mut request = client.get(url);
let mut request = client.get(&requested_url);
if let Some(data) = args.data {
request = request_set_body(args.content_type, args.content_length, data, request)?;
}
request = request_set_timeout(args.timeout, request)?;
request = request_add_authorization_header(args.user, args.password, request);
request = request_add_custom_headers(args.headers, request)?;
let response = request.send().and_then(|r| r.error_for_status());
let response = send_request(request, span, args.data, args.content_type);
request_handle_response(
engine_state,
stack,

10
crates/nu-command/src/network/http/head.rs
View File

@ -7,7 +7,7 @@ use nu_protocol::{
use crate::network::http::client::{
http_client, http_parse_url, request_add_authorization_header, request_add_custom_headers,
request_handle_response_headers, request_set_timeout,
request_handle_response_headers, request_set_timeout, send_request,
};
#[derive(Clone)]
@ -134,17 +134,17 @@ fn run_head(
// The Option<String> return a possible file extension which can be used in AutoConvert commands
fn helper(call: &Call, args: Arguments) -> Result<PipelineData, ShellError> {
let span = args.url.span()?;
let (requested_url, url) = http_parse_url(call, span, args.url)?;
let (requested_url, _) = http_parse_url(call, span, args.url)?;
let client = http_client(args.insecure);
let mut request = client.head(url);
let mut request = client.head(&requested_url);
request = request_set_timeout(args.timeout, request)?;
request = request_add_authorization_header(args.user, args.password, request);
request = request_add_custom_headers(args.headers, request)?;
let response = request.send().and_then(|r| r.error_for_status());
request_handle_response_headers(span, &requested_url, response)
let response = send_request(request, span, None, None);
request_handle_response_headers(span, response)
}
#[cfg(test)]

17
crates/nu-command/src/network/http/patch.rs
View File

@ -7,7 +7,7 @@ use nu_protocol::{
use crate::network::http::client::{
http_client, http_parse_url, request_add_authorization_header, request_add_custom_headers,
request_handle_response, request_set_body, request_set_timeout,
request_handle_response, request_set_timeout, send_request,
};
#[derive(Clone)]
@ -42,12 +42,6 @@ impl Command for SubCommand {
"the MIME type of content to post",
Some('t'),
)
.named(
"content-length",
SyntaxShape::Any,
"the length of the content being posted",
Some('l'),
)
.named(
"max-time",
SyntaxShape::Int,
@ -127,7 +121,6 @@ struct Arguments {
headers: Option<Value>,
data: Value,
content_type: Option<String>,
content_length: Option<String>,
raw: bool,
insecure: bool,
user: Option<String>,
@ -146,7 +139,6 @@ fn run_patch(
headers: call.get_flag(engine_state, stack, "headers")?,
data: call.req(engine_state, stack, 1)?,
content_type: call.get_flag(engine_state, stack, "content-type")?,
content_length: call.get_flag(engine_state, stack, "content-length")?,
raw: call.has_flag("raw"),
insecure: call.has_flag("insecure"),
user: call.get_flag(engine_state, stack, "user")?,
@ -166,17 +158,16 @@ fn helper(
args: Arguments,
) -> Result<PipelineData, ShellError> {
let span = args.url.span()?;
let (requested_url, url) = http_parse_url(call, span, args.url)?;
let (requested_url, _) = http_parse_url(call, span, args.url)?;
let client = http_client(args.insecure);
let mut request = client.patch(url);
let mut request = client.patch(&requested_url);
request = request_set_body(args.content_type, args.content_length, args.data, request)?;
request = request_set_timeout(args.timeout, request)?;
request = request_add_authorization_header(args.user, args.password, request);
request = request_add_custom_headers(args.headers, request)?;
let response = request.send().and_then(|r| r.error_for_status());
let response = send_request(request, span, Some(args.data), args.content_type);
request_handle_response(
engine_state,
stack,

17
crates/nu-command/src/network/http/post.rs
View File

@ -7,7 +7,7 @@ use nu_protocol::{
use crate::network::http::client::{
http_client, http_parse_url, request_add_authorization_header, request_add_custom_headers,
request_handle_response, request_set_body, request_set_timeout,
request_handle_response, request_set_timeout, send_request,
};
#[derive(Clone)]
@ -42,12 +42,6 @@ impl Command for SubCommand {
"the MIME type of content to post",
Some('t'),
)
.named(
"content-length",
SyntaxShape::Any,
"the length of the content being posted",
Some('l'),
)
.named(
"max-time",
SyntaxShape::Int,
@ -127,7 +121,6 @@ struct Arguments {
headers: Option<Value>,
data: Value,
content_type: Option<String>,
content_length: Option<String>,
raw: bool,
insecure: bool,
user: Option<String>,
@ -146,7 +139,6 @@ fn run_post(
headers: call.get_flag(engine_state, stack, "headers")?,
data: call.req(engine_state, stack, 1)?,
content_type: call.get_flag(engine_state, stack, "content-type")?,
content_length: call.get_flag(engine_state, stack, "content-length")?,
raw: call.has_flag("raw"),
insecure: call.has_flag("insecure"),
user: call.get_flag(engine_state, stack, "user")?,
@ -166,17 +158,16 @@ fn helper(
args: Arguments,
) -> Result<PipelineData, ShellError> {
let span = args.url.span()?;
let (requested_url, url) = http_parse_url(call, span, args.url)?;
let (requested_url, _) = http_parse_url(call, span, args.url)?;
let client = http_client(args.insecure);
let mut request = client.post(url);
let mut request = client.post(&requested_url);
request = request_set_body(args.content_type, args.content_length, args.data, request)?;
request = request_set_timeout(args.timeout, request)?;
request = request_add_authorization_header(args.user, args.password, request);
request = request_add_custom_headers(args.headers, request)?;
let response = request.send().and_then(|r| r.error_for_status());
let response = send_request(request, span, Some(args.data), args.content_type);
request_handle_response(
engine_state,
stack,

17
crates/nu-command/src/network/http/put.rs
View File

@ -7,7 +7,7 @@ use nu_protocol::{
use crate::network::http::client::{
http_client, http_parse_url, request_add_authorization_header, request_add_custom_headers,
request_handle_response, request_set_body, request_set_timeout,
request_handle_response, request_set_timeout, send_request,
};
#[derive(Clone)]
@ -42,12 +42,6 @@ impl Command for SubCommand {
"the MIME type of content to post",
Some('t'),
)
.named(
"content-length",
SyntaxShape::Any,
"the length of the content being posted",
Some('l'),
)
.named(
"max-time",
SyntaxShape::Int,
@ -127,7 +121,6 @@ struct Arguments {
headers: Option<Value>,
data: Value,
content_type: Option<String>,
content_length: Option<String>,
raw: bool,
insecure: bool,
user: Option<String>,
@ -146,7 +139,6 @@ fn run_put(
headers: call.get_flag(engine_state, stack, "headers")?,
data: call.req(engine_state, stack, 1)?,
content_type: call.get_flag(engine_state, stack, "content-type")?,
content_length: call.get_flag(engine_state, stack, "content-length")?,
raw: call.has_flag("raw"),
insecure: call.has_flag("insecure"),
user: call.get_flag(engine_state, stack, "user")?,
@ -166,17 +158,16 @@ fn helper(
args: Arguments,
) -> Result<PipelineData, ShellError> {
let span = args.url.span()?;
let (requested_url, url) = http_parse_url(call, span, args.url)?;
let (requested_url, _) = http_parse_url(call, span, args.url)?;
let client = http_client(args.insecure);
let mut request = client.put(url);
let mut request = client.put(&requested_url);
request = request_set_body(args.content_type, args.content_length, args.data, request)?;
request = request_set_timeout(args.timeout, request)?;
request = request_add_authorization_header(args.user, args.password, request);
request = request_add_custom_headers(args.headers, request)?;
let response = request.send().and_then(|r| r.error_for_status());
let response = send_request(request, span, Some(args.data), args.content_type);
request_handle_response(
engine_state,
stack,

6
crates/nu-command/tests/commands/network/http/delete.rs
View File

@ -1,6 +1,5 @@
use mockito::Server;
use nu_test_support::{nu, pipeline};
use reqwest::StatusCode;
#[test]
fn http_delete_is_success() {
@ -25,10 +24,7 @@ fn http_delete_is_success() {
fn http_delete_failed_due_to_server_error() {
let mut server = Server::new();
let _mock = server
.mock("DELETE", "/")
.with_status(StatusCode::BAD_REQUEST.as_u16() as usize)
.create();
let _mock = server.mock("DELETE", "/").with_status(400).create();
let actual = nu!(pipeline(
format!(

6
crates/nu-command/tests/commands/network/http/get.rs
View File

@ -1,6 +1,5 @@
use mockito::Server;
use nu_test_support::{nu, pipeline};
use reqwest::StatusCode;
#[test]
fn http_get_is_success() {
@ -25,10 +24,7 @@ fn http_get_is_success() {
fn http_get_failed_due_to_server_error() {
let mut server = Server::new();
let _mock = server
.mock("GET", "/")
.with_status(StatusCode::BAD_REQUEST.as_u16() as usize)
.create();
let _mock = server.mock("GET", "/").with_status(400).create();
let actual = nu!(pipeline(
format!(

6
crates/nu-command/tests/commands/network/http/head.rs
View File

@ -1,6 +1,5 @@
use mockito::Server;
use nu_test_support::{nu, pipeline};
use reqwest::StatusCode;
#[test]
fn http_head_is_success() {
@ -26,10 +25,7 @@ fn http_head_is_success() {
fn http_head_failed_due_to_server_error() {
let mut server = Server::new();
let _mock = server
.mock("HEAD", "/")
.with_status(StatusCode::BAD_REQUEST.as_u16() as usize)
.create();
let _mock = server.mock("HEAD", "/").with_status(400).create();
let actual = nu!(pipeline(
format!(

6
crates/nu-command/tests/commands/network/http/patch.rs
View File

@ -1,6 +1,5 @@
use mockito::Server;
use nu_test_support::{nu, pipeline};
use reqwest::StatusCode;
#[test]
fn http_patch_is_success() {
@ -25,10 +24,7 @@ fn http_patch_is_success() {
fn http_patch_failed_due_to_server_error() {
let mut server = Server::new();
let _mock = server
.mock("PATCH", "/")
.with_status(StatusCode::BAD_REQUEST.as_u16() as usize)
.create();
let _mock = server.mock("PATCH", "/").with_status(400).create();
let actual = nu!(pipeline(
format!(

6
crates/nu-command/tests/commands/network/http/post.rs
View File

@ -1,6 +1,5 @@
use mockito::Server;
use nu_test_support::{nu, pipeline};
use reqwest::StatusCode;
#[test]
fn http_post_is_success() {
@ -25,10 +24,7 @@ fn http_post_is_success() {
fn http_post_failed_due_to_server_error() {
let mut server = Server::new();
let _mock = server
.mock("POST", "/")
.with_status(StatusCode::BAD_REQUEST.as_u16() as usize)
.create();
let _mock = server.mock("POST", "/").with_status(400).create();
let actual = nu!(pipeline(
format!(

6
crates/nu-command/tests/commands/network/http/put.rs
View File

@ -1,6 +1,5 @@
use mockito::Server;
use nu_test_support::{nu, pipeline};
use reqwest::StatusCode;
#[test]
fn http_put_is_success() {
@ -25,10 +24,7 @@ fn http_put_is_success() {
fn http_put_failed_due_to_server_error() {
let mut server = Server::new();
let _mock = server
.mock("PUT", "/")
.with_status(StatusCode::BAD_REQUEST.as_u16() as usize)
.create();
let _mock = server.mock("PUT", "/").with_status(400).create();
let actual = nu!(pipeline(
format!(