ureq 0.1.0

Minimal HTTP request library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

use std::io::Read;
use test;

use super::super::*;

#[test]
fn header_passing() {
    test::set_handler("/header_passing", |req, _url| {
        assert!(req.has("X-Foo"));
        assert_eq!(req.header("X-Foo").unwrap(), "bar");
        test::make_response(200, "OK", vec!["X-Bar: foo"], vec![])
    });
    let resp = get("test://host/header_passing").set("X-Foo", "bar").call();
    assert_eq!(*resp.status(), 200);
    assert!(resp.has("X-Bar"));
    assert_eq!(resp.header("X-Bar").unwrap(), "foo");
}

#[test]
fn repeat_non_x_header() {
    test::set_handler("/repeat_non_x_header", |req, _url| {
        assert!(req.has("Accept"));
        assert_eq!(req.header("Accept").unwrap(), "baz");
        test::make_response(200, "OK", vec![], vec![])
    });
    let resp = get("test://host/repeat_non_x_header")
        .set("Accept", "bar")
        .set("Accept", "baz")
        .call();
    assert_eq!(*resp.status(), 200);
}

#[test]
fn repeat_x_header() {
    test::set_handler("/repeat_x_header", |req, _url| {
        assert!(req.has("X-Forwarded-For"));
        assert_eq!(req.header("X-Forwarded-For").unwrap(), "130.240.19.2");
        assert_eq!(
            req.all("X-Forwarded-For"),
            vec!["130.240.19.2", "130.240.19.3"]
        );
        test::make_response(200, "OK", vec![], vec![])
    });
    let resp = get("test://host/repeat_x_header")
        .set("X-Forwarded-For", "130.240.19.2")
        .set("X-Forwarded-For", "130.240.19.3")
        .call();
    assert_eq!(*resp.status(), 200);
}

#[test]
fn body_as_text() {
    test::set_handler("/body_as_text", |_req, _url| {
        test::make_response(200, "OK", vec![], "Hello World!".to_string().into_bytes())
    });
    let resp = get("test://host/body_as_text").call();
    let text = resp.into_string().unwrap();
    assert_eq!(text, "Hello World!");
}

#[test]
fn body_as_json() {
    test::set_handler("/body_as_json", |_req, _url| {
        test::make_response(
            200,
            "OK",
            vec![],
            "{\"hello\":\"world\"}".to_string().into_bytes(),
        )
    });
    let resp = get("test://host/body_as_json").call();
    let json = resp.into_json().unwrap();
    assert_eq!(json["hello"], "world");
}

#[test]
fn body_as_reader() {
    test::set_handler("/body_as_reader", |_req, _url| {
        test::make_response(200, "OK", vec![], "abcdefgh".to_string().into_bytes())
    });
    let resp = get("test://host/body_as_reader").call();
    let mut reader = resp.into_reader();
    let mut text = String::new();
    reader.read_to_string(&mut text).unwrap();
    assert_eq!(text, "abcdefgh");
}

#[test]
fn escape_path() {
    test::set_handler("/escape_path%20here", |_req, _url| {
        test::make_response(200, "OK", vec![], vec![])
    });
    let resp = get("test://host/escape_path here").call();
    let vec = resp.to_write_vec();
    let s = String::from_utf8_lossy(&vec);
    assert!(s.contains("GET /escape_path%20here HTTP/1.1"))
}