Files
reqlite/crates/cli/tests/e2e.rs
T

125 lines
4.2 KiB
Rust

use std::process::Command;
use wiremock::matchers::{body_string, header, method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
fn reqlite() -> Command {
Command::new(env!("CARGO_BIN_EXE_reqlite"))
}
#[tokio::test]
async fn run_uses_env_files_cookies_and_names() {
let server = MockServer::start().await;
Mock::given(method("POST"))
.and(path("/login"))
.and(body_string("{\"user\": \"ada\"}"))
.respond_with(
ResponseTemplate::new(200)
.insert_header("set-cookie", "session=s1; Path=/")
.set_body_string("{\"ok\":true}"),
)
.mount(&server)
.await;
Mock::given(method("GET"))
.and(path("/me"))
.and(header("cookie", "session=s1"))
.and(header("authorization", "Bearer secret-token"))
.respond_with(ResponseTemplate::new(200).set_body_string("me"))
.mount(&server)
.await;
let dir = tempfile::tempdir().unwrap();
std::fs::write(
dir.path().join("http-client.env.json"),
format!(
r#"{{ "dev": {{ "base_url": "{}" }}, "prod": {{ "base_url": "http://unused" }} }}"#,
server.uri()
),
)
.unwrap();
std::fs::write(
dir.path().join("http-client.private.env.json"),
r#"{ "dev": { "token": "secret-token" } }"#,
)
.unwrap();
let file = dir.path().join("api.http");
std::fs::write(
&file,
"### Login\nPOST {{base_url}}/login\nContent-Type: application/json\n\n{\"user\": \"ada\"}\n\n### Me\nGET {{base_url}}/me\nAuthorization: Bearer {{token}}\n",
)
.unwrap();
let out = reqlite()
.args(["run", file.to_str().unwrap(), "--env", "dev", "--fail"])
.output()
.unwrap();
let stdout = String::from_utf8_lossy(&out.stdout);
assert!(
out.status.success(),
"{stdout}\n{}",
String::from_utf8_lossy(&out.stderr)
);
assert!(stdout.contains("HTTP/1.1 200 OK"), "{stdout}");
assert!(stdout.contains("{\"ok\":true}"));
assert!(stdout.trim_end().ends_with("me"), "{stdout}");
let out = reqlite()
.args([
"run",
file.to_str().unwrap(),
"--env",
"dev",
"--name",
"Login",
"--body-only",
"--pretty",
])
.output()
.unwrap();
assert_eq!(String::from_utf8_lossy(&out.stdout), "{\n \"ok\": true\n}\n");
// Missing variables are reported, not sent.
let out = reqlite().args(["run", file.to_str().unwrap()]).output().unwrap();
assert!(!out.status.success());
assert!(String::from_utf8_lossy(&out.stderr).contains("unknown variable `base_url`"));
}
#[test]
fn folder_auth_is_inherited() {
let dir = tempfile::tempdir().unwrap();
let root = dir.path();
std::fs::write(root.join("http-client.env.json"), r#"{ "dev": { "token": "t0k" } }"#).unwrap();
std::fs::create_dir_all(root.join(".reqlite")).unwrap();
std::fs::write(root.join(".reqlite/folder.json"), r#"{ "auth": "Bearer {{token}}" }"#).unwrap();
std::fs::create_dir_all(root.join("api")).unwrap();
let file = root.join("api/x.http");
std::fs::write(
&file,
"### Inherits\nGET http://h/a\n\n### Own\nGET http://h/b\nAuthorization: Basic u p\n\n### None\n# @no-auth\nGET http://h/c\n",
)
.unwrap();
let out = reqlite()
.args(["curl", file.to_str().unwrap(), "--env", "dev"])
.output()
.unwrap();
let stdout = String::from_utf8_lossy(&out.stdout);
assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));
let lines: Vec<&str> = stdout.lines().collect();
assert_eq!(lines.len(), 3, "{stdout}");
assert!(lines[0].contains("Authorization: Bearer t0k"), "{stdout}");
assert!(lines[1].contains("Authorization: Basic dTpw"), "{stdout}");
assert!(!lines[2].contains("Authorization"), "{stdout}");
}
#[test]
fn import_curl_prints_http() {
let out = reqlite()
.args(["import", "curl", "curl -X PUT https://x/y -H 'A: b' -d 'z=1'"])
.output()
.unwrap();
assert_eq!(
String::from_utf8_lossy(&out.stdout),
"PUT https://x/y\nA: b\nContent-Type: application/x-www-form-urlencoded\n\nz=1\n"
);
}