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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
#![deny(warnings)]
use serde_derive::Deserialize;
use std::collections::HashMap;
use warp::Filter;
#[tokio::test]
async fn query() {
let as_map = warp::query::<HashMap<String, String>>();
let req = warp::test::request().path("/?foo=bar&baz=quux");
let extracted = req.filter(&as_map).await.unwrap();
assert_eq!(extracted["foo"], "bar");
assert_eq!(extracted["baz"], "quux");
}
#[tokio::test]
async fn query_struct() {
let as_struct = warp::query::<MyArgs>();
let req = warp::test::request().path("/?foo=bar&baz=quux");
let extracted = req.filter(&as_struct).await.unwrap();
assert_eq!(
extracted,
MyArgs {
foo: Some("bar".into()),
baz: Some("quux".into())
}
);
}
#[tokio::test]
async fn empty_query_struct() {
let as_struct = warp::query::<MyArgs>();
let req = warp::test::request().path("/?");
let extracted = req.filter(&as_struct).await.unwrap();
assert_eq!(
extracted,
MyArgs {
foo: None,
baz: None
}
);
}
#[tokio::test]
async fn query_struct_no_values() {
let as_struct = warp::query::<MyArgs>();
let req = warp::test::request().path("/?foo&baz");
let extracted = req.filter(&as_struct).await.unwrap();
assert_eq!(
extracted,
MyArgs {
foo: Some("".into()),
baz: Some("".into())
}
);
}
#[tokio::test]
async fn missing_query_struct() {
let as_struct = warp::query::<MyArgs>();
let req = warp::test::request().path("/");
let extracted = req.filter(&as_struct).await.unwrap();
assert_eq!(
extracted,
MyArgs {
foo: None,
baz: None
}
);
}
#[derive(Deserialize, Debug, Eq, PartialEq)]
struct MyArgs {
foo: Option<String>,
baz: Option<String>,
}
#[tokio::test]
async fn required_query_struct() {
let as_struct = warp::query::<MyRequiredArgs>();
let req = warp::test::request().path("/?foo=bar&baz=quux");
let extracted = req.filter(&as_struct).await.unwrap();
assert_eq!(
extracted,
MyRequiredArgs {
foo: "bar".into(),
baz: "quux".into()
}
);
}
#[tokio::test]
async fn missing_required_query_struct_partial() {
let as_struct = warp::query::<MyRequiredArgs>();
let req = warp::test::request().path("/?foo=something");
let extracted = req.filter(&as_struct).await;
assert!(extracted.is_err())
}
#[tokio::test]
async fn missing_required_query_struct_no_query() {
let as_struct = warp::query::<MyRequiredArgs>().map(|_| warp::reply());
let req = warp::test::request().path("/");
let res = req.reply(&as_struct).await;
assert_eq!(res.status(), 400);
assert_eq!(res.body(), "Invalid query string");
}
#[derive(Deserialize, Debug, Eq, PartialEq)]
struct MyRequiredArgs {
foo: String,
baz: String,
}
#[tokio::test]
async fn raw_query() {
let as_raw = warp::query::raw();
let req = warp::test::request().path("/?foo=bar&baz=quux");
let extracted = req.filter(&as_raw).await.unwrap();
assert_eq!(extracted, "foo=bar&baz=quux".to_owned());
}
|
