nushell/crates/nu-command/tests/commands/network/http/get.rs

use mockito::Server;
use nu_test_support::{nu, pipeline};

#[test]
fn http_get_is_success() {
    let mut server = Server::new();

    let _mock = server.mock("GET", "/").with_body("foo").create();

    let actual = nu!(pipeline(
        format!(
            r#"
        http get {url}
        "#,
            url = server.url()
        )
        .as_str()
    ));

    assert_eq!(actual.out, "foo")
}

#[test]
fn http_get_failed_due_to_server_error() {
    let mut server = Server::new();

    let _mock = server.mock("GET", "/").with_status(400).create();

    let actual = nu!(pipeline(
        format!(
            r#"
        http get {url}
        "#,
            url = server.url()
        )
        .as_str()
    ));

    assert!(actual.err.contains("Bad request (400)"))
}

#[test]
fn http_get_with_accept_errors() {
    let mut server = Server::new();

    let _mock = server
        .mock("GET", "/")
        .with_status(400)
        .with_body("error body")
        .create();

    let actual = nu!(pipeline(
        format!(
            r#"
        http get -e {url}
        "#,
            url = server.url()
        )
        .as_str()
    ));

    assert!(actual.out.contains("error body"))
}

#[test]
fn http_get_with_accept_errors_and_full_raw_response() {
    let mut server = Server::new();

    let _mock = server
        .mock("GET", "/")
        .with_status(400)
        .with_body("error body")
        .create();

    let actual = nu!(pipeline(
        format!(
            r#"
        http get -e -f {url} | $"($in.status) => ($in.body)"
        "#,
            url = server.url()
        )
        .as_str()
    ));

    assert!(actual.out.contains("400 => error body"))
}

#[test]
fn http_get_with_accept_errors_and_full_json_response() {
    let mut server = Server::new();

    let _mock = server
        .mock("GET", "/")
        .with_status(400)
        .with_header("content-type", "application/json")
        .with_body(
            r#"
        {"msg": "error body"}
        "#,
        )
        .create();

    let actual = nu!(pipeline(
        format!(
            r#"
        http get -e -f {url} | $"($in.status) => ($in.body.msg)"
        "#,
            url = server.url()
        )
        .as_str()
    ));

    assert!(actual.out.contains("400 => error body"))
}

#[test]
fn http_get_with_custom_headers_as_records() {
    let mut server = Server::new();

    let mock1 = server
        .mock("GET", "/")
        .match_header("content-type", "application/json")
        .with_body(r#"{"hello": "world"}"#)
        .create();

    let mock2 = server
        .mock("GET", "/")
        .match_header("content-type", "text/plain")
        .with_body("world")
        .create();

    let _json_response = nu!(format!(
        "http get -H {{content-type: application/json}} {url}",
        url = server.url()
    ));

    let _text_response = nu!(format!(
        "http get -H {{content-type: text/plain}} {url}",
        url = server.url()
    ));
    mock1.assert();
    mock2.assert();
}
// These tests require network access; they use badssl.com which is a Google-affiliated site for testing various SSL errors.
// Revisit this if these tests prove to be flaky or unstable.

#[test]
fn http_get_expired_cert_fails() {
    let actual = nu!("http get https://expired.badssl.com/");
    assert!(actual.err.contains("network_failure"));
}

#[test]
fn http_get_expired_cert_override() {
    let actual = nu!("http get --insecure https://expired.badssl.com/");
    assert!(actual.out.contains("<html>"));
}

#[test]
fn http_get_self_signed_fails() {
    let actual = nu!("http get https://self-signed.badssl.com/");
    assert!(actual.err.contains("network_failure"));
}

#[test]
fn http_get_self_signed_override() {
    let actual = nu!("http get --insecure https://self-signed.badssl.com/");
    assert!(actual.out.contains("<html>"));
}
Add unit tests for HTTP commands. (#8267) # Description Following the comment from @fdncred: https://github.com/nushell/nushell/pull/8144#issuecomment-1442514338. I added some unit tests for HTTP commands. The tests are not exhaustive, but at least, this is a first good step IMO. # User-Facing Changes None. # 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. 2023-03-02 20:05:18 +01:00			`use mockito::Server;`
			`use nu_test_support::{nu, pipeline};`

			`#[test]`
			`fn http_get_is_success() {`
			`let mut server = Server::new();`

			`let _mock = server.mock("GET", "/").with_body("foo").create();`

			`let actual = nu!(pipeline(`
			`format!(`
			`r#"`
			`http get {url}`
			`"#,`
			`url = server.url()`
			`)`
			`.as_str()`
			`));`

			`assert_eq!(actual.out, "foo")`
			`}`

			`#[test]`
			`fn http_get_failed_due_to_server_error() {`
			`let mut server = Server::new();`

changes Reqwest to Ureq. (#8320) # 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. 2023-03-05 23:48:13 +01:00			`let _mock = server.mock("GET", "/").with_status(400).create();`
Add unit tests for HTTP commands. (#8267) # Description Following the comment from @fdncred: https://github.com/nushell/nushell/pull/8144#issuecomment-1442514338. I added some unit tests for HTTP commands. The tests are not exhaustive, but at least, this is a first good step IMO. # User-Facing Changes None. # 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. 2023-03-02 20:05:18 +01:00
			`let actual = nu!(pipeline(`
			`format!(`
			`r#"`
			`http get {url}`
			`"#,`
			`url = server.url()`
			`)`
			`.as_str()`
			`));`

			`assert!(actual.err.contains("Bad request (400)"))`
			`}`
Add SSL tests for `http get` (#8327) This PR adds tests to confirm that: 1. `http get` does the right thing (bail) when it encounters common SSL errors 2. the `--insecure` flag works to ignore SSL errors It's prompted by #8098, where `--insecure` stopped working and we didn't notice until it was reported by a user. ## Deets + considerations This PR uses [badssl.com](https://badssl.com/), a very handy website affiliated with the Google Chrome team. The badssl authors mention that stability is not guaranteed: > Most subdomains are likely to have stable functionality, but anything could change without notice. I suspect that the badssl.com subdomains I've chosen will be stable enough in practice. Can revisit this if the tests end up being flaky. This PR does mean our tests are now making an external network call... which I _think_ is OK. Our CI isn't exactly designed for offline machines; test runners already have to download a bunch of crates etc. I think the new tests are quick enough: ![image](https://user-images.githubusercontent.com/26268125/222992751-a9f0d8ff-b776-4ea5-908a-7d11607487fe.png) 2023-03-07 16:56:39 +01:00
feat: added multiple options to http commands (#8571) # Description All `http` commands now have a `-f` flag which for now contains the `headers`, `body` and `status` fields (we can later add stuff like `is-redirect` or `cookies`). ![image](https://user-images.githubusercontent.com/3835355/227048504-6686445d-ad2e-4f5d-905d-e71b3a4b81a6.png) Try it yourself ``` http get http://mockbin.org/bin/630069dc-2c09-483a-a484-672561b7de14 http get -f http://mockbin.org/bin/630069dc-2c09-483a-a484-672561b7de14 ``` The `http` commands can also now use the `-e` flag, which stands for `--allow-errors`. When the status code is `>= 400`, it will still allow you to interpret it like a normal response. ![image](https://user-images.githubusercontent.com/3835355/227047790-b9f5a25f-2c0d-4741-881f-4189b23e4ef6.png) Try it yourself ``` http get http://mockbin.org/bin/2ebd3d27-bdc2-4ee8-b042-0bc2c0d1ad2a # should fail like usual http get -e http://mockbin.org/bin/2ebd3d27-bdc2-4ee8-b042-0bc2c0d1ad2a # will return the body http get -e -f http://mockbin.org/bin/2ebd3d27-bdc2-4ee8-b042-0bc2c0d1ad2a # will let you see the full response ``` # User-Facing Changes - Adds `-f` (`--full`) to all `http` commands - Adds `-e` (--allow-errors) to all `http` commands 2023-03-23 21:32:35 +01:00			`#[test]`
			`fn http_get_with_accept_errors() {`
			`let mut server = Server::new();`

			`let _mock = server`
			`.mock("GET", "/")`
			`.with_status(400)`
			`.with_body("error body")`
			`.create();`

			`let actual = nu!(pipeline(`
			`format!(`
			`r#"`
			`http get -e {url}`
			`"#,`
			`url = server.url()`
			`)`
			`.as_str()`
			`));`

			`assert!(actual.out.contains("error body"))`
			`}`

			`#[test]`
			`fn http_get_with_accept_errors_and_full_raw_response() {`
			`let mut server = Server::new();`

			`let _mock = server`
			`.mock("GET", "/")`
			`.with_status(400)`
			`.with_body("error body")`
			`.create();`

			`let actual = nu!(pipeline(`
			`format!(`
			`r#"`
			`http get -e -f {url} \| $"($in.status) => ($in.body)"`
			`"#,`
			`url = server.url()`
			`)`
			`.as_str()`
			`));`

			`assert!(actual.out.contains("400 => error body"))`
			`}`

			`#[test]`
			`fn http_get_with_accept_errors_and_full_json_response() {`
			`let mut server = Server::new();`

			`let _mock = server`
			`.mock("GET", "/")`
			`.with_status(400)`
			`.with_header("content-type", "application/json")`
			`.with_body(`
			`r#"`
			`{"msg": "error body"}`
			`"#,`
			`)`
			`.create();`

			`let actual = nu!(pipeline(`
			`format!(`
			`r#"`
			`http get -e -f {url} \| $"($in.status) => ($in.body.msg)"`
			`"#,`
			`url = server.url()`
			`)`
			`.as_str()`
			`));`

			`assert!(actual.out.contains("400 => error body"))`
			`}`

Accept records for http subcommand headers (-H) (#9771) # Description See also: #9743 Before: `http <subcommand> -H` took a list in the form: ```nushell [my-header-key-A my-header-value-A my-header-key-B my-header-value-B] ``` Now: In addition to the old format, Records can be passed, For example, ```nushell > let reqHeaders = { Cookie: "acc=barfoo", User-Agent: "Mozilla/7.0 (Windows NT 33.0; Win64; x64) AppleWebKit/1038.90 (KHTML, like Gecko)" } > http get -H $reqHeaders https://example.com ``` is now equivalent to ```nushell http get -H [Cookie "acc=barfoo" User-Agent "Mozilla/7.0 (Windows NT 33.0; Win64; x64) AppleWebKit/1038.90 (KHTML, like Gecko)"] https://example.com ``` # User-Facing Changes No breaking changes, but Records can now also be passed to `http <subcommand> -H`. # Tests + Formatting # After Submitting 2023-07-30 22:28:48 +02:00			`#[test]`
			`fn http_get_with_custom_headers_as_records() {`
			`let mut server = Server::new();`

			`let mock1 = server`
			`.mock("GET", "/")`
			`.match_header("content-type", "application/json")`
			`.with_body(r#"{"hello": "world"}"#)`
			`.create();`

			`let mock2 = server`
			`.mock("GET", "/")`
			`.match_header("content-type", "text/plain")`
			`.with_body("world")`
			`.create();`

			`let _json_response = nu!(format!(`
			`"http get -H {{content-type: application/json}} {url}",`
			`url = server.url()`
			`));`

			`let _text_response = nu!(format!(`
			`"http get -H {{content-type: text/plain}} {url}",`
			`url = server.url()`
			`));`
			`mock1.assert();`
			`mock2.assert();`
			`}`
Add SSL tests for `http get` (#8327) This PR adds tests to confirm that: 1. `http get` does the right thing (bail) when it encounters common SSL errors 2. the `--insecure` flag works to ignore SSL errors It's prompted by #8098, where `--insecure` stopped working and we didn't notice until it was reported by a user. ## Deets + considerations This PR uses [badssl.com](https://badssl.com/), a very handy website affiliated with the Google Chrome team. The badssl authors mention that stability is not guaranteed: > Most subdomains are likely to have stable functionality, but anything could change without notice. I suspect that the badssl.com subdomains I've chosen will be stable enough in practice. Can revisit this if the tests end up being flaky. This PR does mean our tests are now making an external network call... which I _think_ is OK. Our CI isn't exactly designed for offline machines; test runners already have to download a bunch of crates etc. I think the new tests are quick enough: ![image](https://user-images.githubusercontent.com/26268125/222992751-a9f0d8ff-b776-4ea5-908a-7d11607487fe.png) 2023-03-07 16:56:39 +01:00			`// These tests require network access; they use badssl.com which is a Google-affiliated site for testing various SSL errors.`
			`// Revisit this if these tests prove to be flaky or unstable.`

			`#[test]`
			`fn http_get_expired_cert_fails() {`
			`let actual = nu!("http get https://expired.badssl.com/");`
			`assert!(actual.err.contains("network_failure"));`
			`}`

			`#[test]`
			`fn http_get_expired_cert_override() {`
			`let actual = nu!("http get --insecure https://expired.badssl.com/");`
			`assert!(actual.out.contains("<html>"));`
			`}`

			`#[test]`
			`fn http_get_self_signed_fails() {`
			`let actual = nu!("http get https://self-signed.badssl.com/");`
			`assert!(actual.err.contains("network_failure"));`
			`}`

			`#[test]`
			`fn http_get_self_signed_override() {`
			`let actual = nu!("http get --insecure https://self-signed.badssl.com/");`
			`assert!(actual.out.contains("<html>"));`
			`}`