1use error::RequestParseError;
2use header::{HeaderToken, parse_header};
3use method::parse_method_input;
4use uri::parse_uri_input;
5use variables::{parse_variable, parse_variable_declaration};
6use version::parse_http_version;
7
8pub mod error;
9mod header;
10mod method;
11mod uri;
12mod variables;
13mod version;
14
15#[derive(Copy, Clone, PartialEq)]
16enum ParserMode {
17 Request,
18 Headers,
19 Body,
20}
21
22#[derive(Debug)]
23enum RequestToken {
24 Method(http::method::Method),
25 Uri(http::uri::Uri),
26 HttpVersion(http::version::Version),
27 Header(HeaderToken),
28 Body(Option<String>),
29}
30
31#[inline]
32fn to_enum_chars(input: &str) -> core::iter::Enumerate<core::str::Chars> {
33 input.chars().enumerate()
34}
35
36#[inline]
37fn tokenize(
38 buffer: &str,
39 input_variables: &std::collections::HashMap<String, String>,
40) -> Result<Vec<RequestToken>, RequestParseError> {
41 let mut tokens: Vec<RequestToken> = Vec::new();
42
43 let mut parser_mode = ParserMode::Request;
44
45 let mut body_parts: Vec<String> = Vec::new();
46
47 let mut vars = input_variables.to_owned();
48
49 for line in buffer.lines() {
50 let trimmed_line = line.trim();
51
52 if trimmed_line.starts_with('#') {
54 if trimmed_line.starts_with("###") && parser_mode != ParserMode::Request {
55 if body_parts.is_empty() {
56 tokens.push(RequestToken::Body(None));
57 } else {
58 tokens.push(RequestToken::Body(Some(body_parts.join("\n"))));
59
60 body_parts.clear();
61 }
62
63 parser_mode = ParserMode::Request;
64 }
65
66 if parser_mode == ParserMode::Request {
67 continue;
68 }
69 } else if trimmed_line.starts_with("//") {
70 if parser_mode == ParserMode::Request {
72 continue;
73 }
74 }
75
76 match parser_mode {
77 ParserMode::Request => {
78 if trimmed_line.starts_with('@') {
79 let mut chrs = to_enum_chars(trimmed_line);
80
81 chrs.next();
83
84 if let Some((name, value)) = parse_variable_declaration(&mut chrs, &vars)? {
85 vars.insert(name, value);
86 continue;
87 }
88 }
89
90 if !trimmed_line.is_empty() {
91 let mut chrs = to_enum_chars(trimmed_line);
92 let method = parse_method_input(&mut chrs, &vars)?;
93
94 tokens.push(RequestToken::Method(method));
95
96 let uri = parse_uri_input(&mut chrs, &vars)?;
97
98 tokens.push(RequestToken::Uri(uri));
99
100 if let Some(http_version) = parse_http_version(&mut chrs, &vars) {
101 tokens.push(RequestToken::HttpVersion(http_version));
102 }
103
104 parser_mode = ParserMode::Headers;
105 }
106 }
107
108 ParserMode::Headers => {
109 if trimmed_line.is_empty() {
110 parser_mode = ParserMode::Body;
111 } else if let Some(header_token) =
112 parse_header(&mut to_enum_chars(trimmed_line), &vars)?
113 {
114 tokens.push(RequestToken::Header(header_token));
115 }
116 }
117
118 ParserMode::Body => {
119 let mut current_line = String::new();
120 let mut chars = to_enum_chars(line);
121
122 while let Some((_, ch)) = chars.next() {
123 if ch == '{' {
124 if let Some((var, jumps)) = parse_variable(&mut chars.clone()) {
126 if let Some(variable_value) = vars.get(&var) {
127 current_line.push_str(variable_value);
128
129 for _ in 0..jumps {
130 chars.next();
131 }
132
133 continue;
134 }
135
136 return Err(RequestParseError::VariableNotFound(var));
137 }
138 }
139
140 current_line.push(ch);
141 }
142
143 body_parts.push(current_line);
144 }
145 }
146 }
147
148 if !body_parts.is_empty() {
149 tokens.push(RequestToken::Body(Some(body_parts.join("\n"))));
150 }
151
152 Ok(tokens)
153}
154
155#[cfg(test)]
156mod test_tokenize {
157 use core::fmt::Write as _;
158
159 use crate::{RequestToken, error::RequestParseError, tokenize};
160
161 static EMPTY_VARS: std::sync::LazyLock<std::collections::HashMap<String, String>> =
162 std::sync::LazyLock::new(std::collections::HashMap::new);
163
164 #[test]
165 fn should_return_a_list_of_tokens() {
166 let method_input = "GET";
167 let uri_input = "https://mhouge.dk/";
168 let http_version = "HTTP/2";
169 let header1_key = "content-type";
170 let header1_value = "application/json";
171 let body_input = "{ \"key\": \"value\" }";
172
173 let input_request = format!(
174 "{method_input} {uri_input} {http_version}\n{header1_key}: {header1_value}\n\n{body_input}"
175 );
176
177 let tokens =
178 tokenize(&input_request, &EMPTY_VARS).expect("it to return Result<Vec<RequestToken>>");
179
180 assert_eq!(tokens.len(), 5);
181
182 for token in tokens {
183 match token {
184 RequestToken::Uri(uri_token) => assert_eq!(uri_input, uri_token.to_string()),
185 RequestToken::Method(method_token) => {
186 assert_eq!(method_input, method_token.as_str());
187 }
188 RequestToken::Header(header_token) => {
189 assert_eq!(header1_key, header_token.key.to_string());
190
191 assert_eq!(
192 header1_value,
193 header_token
194 .value
195 .to_str()
196 .expect("value to be a valid str")
197 );
198 }
199
200 RequestToken::Body(body_token) => {
201 assert!(body_token.is_some());
202
203 let body_inner = body_token.expect("body to be defined");
204
205 assert_eq!(body_input, body_inner);
206 }
207
208 RequestToken::HttpVersion(version_token) => {
209 assert_eq!(version_token, http::version::Version::HTTP_2);
210 }
211 }
212 }
213 }
214
215 #[test]
216 fn it_should_be_able_to_parse_multiple_requests() {
217 let uri = "https://mhouge.dk/";
218
219 let methods = [
220 http::Method::GET,
221 http::Method::PUT,
222 http::Method::POST,
223 http::Method::PATCH,
224 http::Method::DELETE,
225 http::Method::OPTIONS,
226 http::Method::HEAD,
227 http::Method::TRACE,
228 http::Method::CONNECT,
229 ];
230
231 let versions = [
232 http::Version::HTTP_09,
233 http::Version::HTTP_10,
234 http::Version::HTTP_11,
235 http::Version::HTTP_2,
236 http::Version::HTTP_3,
237 ];
238
239 let header_key = "x-test-header";
240 let header_value = "test-value";
241
242 let body = "mads was here\n".to_owned();
243
244 let mut input = String::new();
245
246 let mut input_request_index: u16 = 0;
247
248 for method in &methods {
249 for version in &versions {
250 writeln!(input, "{method} {uri} {version:?}").expect("it to write");
251 writeln!(input, "{header_key}: {header_value}\n").expect("it to write");
252
253 if input_request_index % 2 == 0 {
254 writeln!(input, "{body}").expect("it to write");
255 }
256
257 writeln!(input, "###\n").expect("it to write");
258
259 input_request_index += 1;
260 }
261 }
262
263 let tokens = tokenize(&input, &EMPTY_VARS).expect("it to return a list of tokens");
264
265 assert_eq!(tokens.len(), methods.len() * versions.len() * 5);
266
267 let mut output_request_index: u16 = 0;
268 let mut token_index = 0;
269
270 let body_option = Some(body);
271
272 for method in &methods {
273 for version in &versions {
274 let method_token = tokens.get(token_index).expect("it to be a method token");
275 assert!(matches!(method_token, RequestToken::Method(m) if m == method));
276 token_index += 1;
277
278 let uri_token = tokens.get(token_index).expect("it to be an uri token");
279 assert!(matches!(uri_token, RequestToken::Uri(u) if u == uri));
280 token_index += 1;
281
282 let version_token = tokens.get(token_index).expect("it to be a version token");
283 assert!(matches!(version_token, RequestToken::HttpVersion(v) if v == version));
284 token_index += 1;
285
286 let header_token = tokens.get(token_index).expect("it to be a header token");
287 assert!(
288 matches!(header_token, RequestToken::Header(h) if h.key == header_key && h.value == header_value)
289 );
290 token_index += 1;
291
292 let body_token = tokens.get(token_index).expect("it to be a body token");
293 if output_request_index % 2 == 0 {
294 assert!(matches!(body_token, RequestToken::Body(b) if b == &body_option));
295 } else {
296 assert!(matches!(body_token, RequestToken::Body(b) if b.is_none()));
297 }
298 token_index += 1;
299
300 output_request_index += 1;
301 }
302 }
303 }
304
305 #[test]
306 fn it_should_ignore_comments() {
307 let input = "
308// comment 1
309# comment 2
310
311DELETE https://mhouge.dk/";
312
313 let tokens = tokenize(input, &EMPTY_VARS).expect("it to parse successfully");
314
315 assert_eq!(tokens.len(), 2);
316
317 let method_token = tokens.first().expect("it to be some");
318
319 assert!(
320 matches!(method_token, RequestToken::Method(m) if m == http::method::Method::DELETE)
321 );
322
323 let uri_token = tokens.get(1).expect("it to be Some");
324
325 let expected_uri = "https://mhouge.dk/";
326
327 assert!(matches!(uri_token, RequestToken::Uri(uri) if uri == expected_uri));
328 }
329
330 #[test]
331 fn it_should_only_check_for_comments_when_parsermode_request() {
332 let url = "https://mhouge.dk/api/something/?refresh=true";
333 let method = "DELETE";
334
335 let status_line = format!("{method} {url}");
336
337 for comment_style in ["#", "//"] {
338 let body = format!("{comment_style} this is not a comment");
339
340 let hashtag = format!(
341 "{status_line}
342
343{body}"
344 );
345
346 let tokens = tokenize(&hashtag, &EMPTY_VARS).expect("it to parse successfully");
347
348 assert_eq!(tokens.len(), 3);
349
350 let method_token = tokens.first().expect("it to be some");
351
352 assert!(
353 matches!(method_token, RequestToken::Method(m) if m == http::method::Method::DELETE)
354 );
355
356 let uri_token = tokens.get(1).expect("it to be Some");
357
358 assert!(matches!(uri_token, RequestToken::Uri(u) if u == url));
359
360 let body_token = tokens.get(2).expect("it to be Some");
361
362 assert!(matches!(body_token, RequestToken::Body(b) if b == &Some(body)));
363 }
364 }
365
366 #[test]
367 fn it_should_support_variables() {
368 {
369 let input = "
370@method = GET
371@host = https://mhouge.dk
372@path = /api
373@query_value = mads@mhouge.dk
374@body_input = { \"key\": \"value\" }
375
376{{method}} {{host}}{{path}}?email={{query_value}}
377
378{{ body_input }}";
379
380 let tokens = tokenize(input, &EMPTY_VARS).expect("it to tokenize successfully");
381
382 assert_eq!(tokens.len(), 3);
383
384 let method_token = tokens.first().expect("it to be some");
385
386 assert!(
387 matches!(method_token, RequestToken::Method(m) if m == http::method::Method::GET)
388 );
389
390 let uri_token = tokens.get(1).expect("it to be Some");
391
392 let expected_uri = "https://mhouge.dk/api?email=mads@mhouge.dk";
393
394 assert!(matches!(uri_token, RequestToken::Uri(uri) if uri == expected_uri));
395
396 let body_token = tokens.get(2).expect("it to be set");
397
398 let expected_body_value = "{ \"key\": \"value\" }";
399
400 assert!(matches!(
401 body_token,
402 RequestToken::Body(value)
403 if value.clone().expect("value to exist") == expected_body_value
404 ));
405 };
406
407 {
408 let input = "
409GET https://mhouge.dk/
410
411{{ body_input }}";
412
413 let tokens = tokenize(input, &EMPTY_VARS).expect_err("it to return an error");
414
415 assert!(matches!(
416 tokens,
417 RequestParseError::VariableNotFound(var)
418 if var == "body_input"
419 ));
420 }
421 }
422
423 #[test]
424 fn it_should_support_input_variables() {
425 let vars = std::collections::HashMap::from([
426 ("method".to_owned(), "GET".to_owned()),
427 ("host".to_owned(), "https://mhouge.dk".to_owned()),
428 ("path".to_owned(), "/api".to_owned()),
429 ("query_value".to_owned(), "mads@mhouge.dk".to_owned()),
430 ("body_input".to_owned(), "{ \"key\": \"value\" }".to_owned()),
431 ]);
432
433 let input = "
434{{method}} {{host}}{{path}}?email={{query_value}}
435
436{{ body_input }}";
437
438 let tokens = tokenize(input, &vars).expect("it to tokenize successfully");
439
440 assert_eq!(tokens.len(), 3);
441
442 let method_token = tokens.first().expect("it to return token");
443
444 assert!(
445 matches!(method_token, RequestToken::Method(method) if method == http::Method::GET)
446 );
447
448 let expected_uri = "https://mhouge.dk/api?email=mads@mhouge.dk";
449
450 let uri_token = tokens.get(1).expect("it to return an uri");
451
452 assert!(matches!(uri_token, RequestToken::Uri(uri) if uri == expected_uri));
453
454 let body_token = tokens.get(2).expect("it to return a token");
455
456 let expected_body = "{ \"key\": \"value\" }";
457
458 assert!(
459 matches!(body_token, RequestToken::Body(Some(output_body)) if output_body == expected_body)
460 );
461 }
462
463 #[test]
464 fn it_should_raise_error_if_missing_variable() {
465 let input = "GET {{missing_variable}}";
466
467 let err = tokenize(input, &EMPTY_VARS).expect_err("it to be a missing variable error");
468
469 assert!(matches!(err, RequestParseError::VariableNotFound(v) if v == "missing_variable"));
470 }
471
472 #[test]
473 fn input_variables_should_be_overwritten_by_local_variables() {
474 let vars = std::collections::HashMap::from([("method".to_owned(), "PUT".to_owned())]);
475
476 let input = "
477@method = POST
478
479{{method}} https://mhouge.dk/";
480
481 let tokens = tokenize(input, &vars).expect("it to parse successfully");
482
483 assert_eq!(tokens.len(), 2);
484
485 let method_token = tokens.first().expect("it to return token");
486
487 assert!(
488 matches!(method_token, RequestToken::Method(method) if method == http::Method::POST)
489 );
490
491 let uri_token = tokens.get(1).expect("it to return token");
492
493 assert!(matches!(uri_token, RequestToken::Uri(uri) if uri == "https://mhouge.dk/"));
494 }
495
496 #[test]
497 fn it_should_ignore_triple_hashtag_when_in_parsermode_request() {
498 let input = "
499###
500
501###
502
503###
504
505OPTIONS https://mhouge.dk/
506###
507###
508###
509
510HEAD https://mhouge.dk/blog/";
511
512 let output = tokenize(input, &EMPTY_VARS).expect("it to parse");
513
514 assert_eq!(output.len(), 5);
515
516 {
517 let method = output.first().expect("it to return a method token");
518 assert!(matches!(method, RequestToken::Method(m) if m == http::Method::OPTIONS));
519
520 let uri = output.get(1).expect("it to return a uri token");
521 assert!(matches!(uri, RequestToken::Uri(u) if u == "https://mhouge.dk/"));
522
523 let body = output.get(2).expect("it to be an empty body token");
524 assert!(matches!(body, RequestToken::Body(b) if b.is_none()));
525 };
526
527 {
528 let method = output.get(3).expect("it to return a method token");
529 assert!(matches!(method, RequestToken::Method(m) if m == http::Method::HEAD));
530
531 let uri = output.get(4).expect("it to return a uri token");
532 assert!(matches!(uri, RequestToken::Uri(u) if u == "https://mhouge.dk/blog/"));
533 };
534 }
535}
536
537#[derive(Debug)]
538pub struct HittRequest {
539 pub method: http::method::Method,
540 pub uri: http::uri::Uri,
541 pub headers: http::HeaderMap,
542 pub body: Option<String>,
543 pub http_version: Option<http::version::Version>,
544}
545
546#[derive(Default)]
547struct PartialHittRequest {
548 method: Option<http::method::Method>,
549 uri: Option<http::uri::Uri>,
550 headers: http::HeaderMap,
551 body: Option<String>,
552 http_version: Option<http::version::Version>,
553}
554
555impl PartialHittRequest {
556 #[inline]
557 fn build(self) -> Result<HittRequest, RequestParseError> {
558 match self.method {
559 Some(method) => match self.uri {
560 Some(uri) => Ok(HittRequest {
561 method,
562 uri,
563 headers: self.headers,
564 body: self.body,
565 http_version: self.http_version,
566 }),
567 None => Err(RequestParseError::MissingUri),
568 },
569 None => Err(RequestParseError::MissingMethod),
570 }
571 }
572}
573
574#[cfg(test)]
575mod test_partial_http_request {
576 use http::{HeaderMap, Uri};
577
578 use crate::{PartialHittRequest, error::RequestParseError};
579
580 #[test]
581 fn build_should_reject_if_no_uri() {
582 let request = PartialHittRequest {
583 uri: None,
584 method: Some(http::Method::GET),
585 http_version: None,
586 headers: HeaderMap::default(),
587 body: None,
588 }
589 .build()
590 .expect_err("it to raise RequestParseError::MissingUri");
591
592 assert!(matches!(request, RequestParseError::MissingUri));
593
594 assert_eq!(request.to_string(), "missing uri");
595 }
596
597 #[test]
598 fn build_should_reject_if_no_method() {
599 let uri = Uri::from_static("https://mhouge.dk/");
600
601 let request = PartialHittRequest {
602 uri: Some(uri),
603 method: None,
604 http_version: None,
605 headers: HeaderMap::default(),
606 body: None,
607 }
608 .build()
609 .expect_err("it to raise RequestParseError::MissingMethod");
610
611 assert!(matches!(request, RequestParseError::MissingMethod));
612
613 assert_eq!(request.to_string(), "missing HTTP method");
614 }
615}
616
617#[inline]
618pub fn parse_requests(
619 buffer: &str,
620 input_variables: &std::collections::HashMap<String, String>,
621) -> Result<Vec<HittRequest>, RequestParseError> {
622 let mut requests = Vec::new();
623
624 let tokens = tokenize(buffer, input_variables)?;
625
626 let mut partial_request = PartialHittRequest::default();
627
628 for token in tokens {
629 match token {
630 RequestToken::Method(method) => {
631 partial_request.method = Some(method);
632 }
633
634 RequestToken::Uri(uri) => {
635 partial_request.uri = Some(uri);
636 }
637
638 RequestToken::Header(header) => {
639 partial_request.headers.insert(header.key, header.value);
640 }
641
642 RequestToken::Body(body) => {
643 partial_request.body = body;
644
645 requests.push(partial_request.build()?);
646
647 partial_request = PartialHittRequest::default();
648 }
649
650 RequestToken::HttpVersion(version_token) => {
651 partial_request.http_version = Some(version_token);
652 }
653 }
654 }
655
656 if partial_request.method.is_some() {
657 requests.push(partial_request.build()?);
658 }
659
660 Ok(requests)
661}
662
663#[cfg(test)]
664mod test_parse_requests {
665 use core::str::FromStr;
666
667 use crate::{error::RequestParseError, parse_requests};
668
669 const HTTP_METHODS: [&str; 9] = [
670 "GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "CONNECT", "TRACE",
671 ];
672
673 static EMPTY_VARS: std::sync::LazyLock<std::collections::HashMap<String, String>> =
674 std::sync::LazyLock::new(std::collections::HashMap::new);
675
676 #[test]
677 fn it_should_parse_http_method_correctly() {
678 let url = "https://mhouge.dk";
679
680 for method in &HTTP_METHODS {
681 let expected_method = http::Method::from_str(method).expect("m is a valid method");
682
683 let input = format!("{method} {url}");
684
685 let parsed_requests =
686 parse_requests(&input, &EMPTY_VARS).expect("request should be valid");
687
688 assert!(parsed_requests.len() == 1);
689
690 let first_request = parsed_requests.first().expect("it to be a request");
691
692 assert_eq!(expected_method, first_request.method);
693
694 let expected_uri = url.parse::<http::uri::Uri>().expect("url should be valid");
695
696 assert_eq!(expected_uri, first_request.uri);
697
698 assert_eq!(0, first_request.headers.len());
699
700 assert_eq!(None, first_request.body);
701 }
702 }
703
704 #[test]
705 fn it_should_be_able_to_parse_requests() {
706 let method_input = "GET";
707 let uri_input = "https://mhouge.dk/";
708
709 let header1_key = "content-type";
710 let header1_value = "application/json";
711 let body_input = "{ \"key\": \"value\" }";
712
713 let input_request =
714 format!("{method_input} {uri_input}\n{header1_key}: {header1_value}\n\n{body_input}");
715
716 let result =
717 parse_requests(&input_request, &EMPTY_VARS).expect("it to return a list of requests");
718
719 assert!(result.len() == 1);
720
721 let request = result.first().expect("request len to be 1");
722
723 assert_eq!(method_input, request.method.as_str());
724
725 assert_eq!(uri_input, request.uri.to_string());
726
727 let body_inner = request.body.clone().expect("body to be defined");
728
729 assert_eq!(body_inner, body_input);
730
731 assert_eq!(1, request.headers.len());
732
733 let header1_output = request
734 .headers
735 .get(header1_key)
736 .expect("header1_key to exist");
737
738 assert_eq!(
739 header1_value,
740 header1_output.to_str().expect("it to be a valid header")
741 );
742
743 assert!(request.http_version.is_none());
744 }
745
746 #[test]
747 fn it_should_be_able_to_parse_multiple_requests() {
748 let input = "
749GET https://mhouge.dk/ HTTP/0.9
750
751###
752
753PUT https://mhouge.dk/ HTTP/1.0
754
755###
756
757POST https://mhouge.dk/ HTTP/1.1
758
759###
760
761PATCH https://mhouge.dk/ HTTP/2
762
763###
764
765DELETE https://mhouge.dk/ HTTP/3
766
767###
768";
769
770 let requests = parse_requests(input, &EMPTY_VARS).expect("to get a list of requests");
771
772 assert_eq!(5, requests.len());
773
774 {
775 let request = requests.first().expect("it to be exist");
776
777 assert_eq!(http::Method::GET, request.method);
778
779 assert_eq!("https://mhouge.dk/", request.uri.to_string());
780
781 assert!(request.headers.is_empty());
782
783 assert!(request.body.is_none());
784
785 assert_eq!(
786 http::Version::HTTP_09,
787 request.http_version.expect("http_version to be defined")
788 );
789 };
790
791 {
792 let request = requests.get(1).expect("it to be exist");
793
794 assert_eq!(http::Method::PUT, request.method);
795
796 assert_eq!("https://mhouge.dk/", request.uri.to_string());
797
798 assert!(request.headers.is_empty());
799
800 assert!(request.body.is_none());
801
802 assert_eq!(
803 http::Version::HTTP_10,
804 request.http_version.expect("http_version to be defined")
805 );
806 };
807
808 {
809 let request = requests.get(2).expect("it to be exist");
810
811 assert_eq!(http::Method::POST, request.method);
812
813 assert_eq!("https://mhouge.dk/", request.uri.to_string());
814
815 assert!(request.headers.is_empty());
816
817 assert!(request.body.is_none());
818
819 assert_eq!(
820 http::Version::HTTP_11,
821 request.http_version.expect("http_version to be defined")
822 );
823 };
824
825 {
826 let request = requests.get(3).expect("it to be exist");
827
828 assert_eq!(http::Method::PATCH, request.method);
829
830 assert_eq!("https://mhouge.dk/", request.uri.to_string());
831
832 assert!(request.headers.is_empty());
833
834 assert!(request.body.is_none());
835
836 assert_eq!(
837 http::Version::HTTP_2,
838 request.http_version.expect("http_version to be defined")
839 );
840 };
841
842 {
843 let request = requests.get(4).expect("it to be exist");
844
845 assert_eq!(http::Method::DELETE, request.method);
846
847 assert_eq!("https://mhouge.dk/", request.uri.to_string());
848
849 assert!(request.headers.is_empty());
850
851 assert!(request.body.is_none());
852
853 assert_eq!(
854 http::Version::HTTP_3,
855 request.http_version.expect("http_version to be defined")
856 );
857 };
858 }
859
860 #[test]
861 fn it_should_support_variables() {
862 let input = "
863@method = GET
864@host = https://mhouge.dk
865@path = /api
866@query_value = mads@mhouge.dk
867@body_input = { \"key\": \"value\" }
868
869{{method}} {{host}}{{path}}?email={{query_value}}
870
871{{ body_input }}";
872
873 let requests = parse_requests(input, &EMPTY_VARS).expect("to get a list of requests");
874
875 assert_eq!(requests.len(), 1);
876
877 let request = requests.first().expect("it to have 1 request");
878
879 assert_eq!(request.method, http::method::Method::GET);
880
881 assert_eq!(request.uri, "https://mhouge.dk/api?email=mads@mhouge.dk");
882
883 assert_eq!(
884 "{ \"key\": \"value\" }",
885 request.body.clone().expect("body to be set"),
886 );
887 }
888
889 #[test]
890 fn it_should_support_variable_input() {
891 {
892 let mut vars = std::collections::HashMap::from([
893 ("method".to_owned(), "GET".to_owned()),
894 ("host".to_owned(), "https://mhouge.dk".to_owned()),
895 ("path".to_owned(), "/api".to_owned()),
896 ("query_value".to_owned(), "mads@mhouge.dk".to_owned()),
897 ("body_input".to_owned(), "{ \"key\": \"value\" }".to_owned()),
898 ]);
899
900 let input = "
901{{method}} {{host}}{{path}}?email={{query_value}}
902{{header_name}}: {{header_value}}
903
904{{ body_input }}";
905
906 for i in u8::MIN..u8::MAX {
907 let header_name = format!("mads-was-here{i}");
908 let header_value = format!("or was i{i}?");
909
910 vars.insert("header_name".to_owned(), header_name.clone());
911 vars.insert("header_value".to_owned(), header_value.clone());
912
913 let requests = parse_requests(input, &vars).expect("to get a list of requests");
914
915 assert_eq!(requests.len(), 1);
916
917 let request = requests.first().expect("it to have 1 request");
918
919 assert_eq!(request.method, http::method::Method::GET);
920
921 assert_eq!(request.uri, "https://mhouge.dk/api?email=mads@mhouge.dk");
922
923 assert_eq!(request.headers.len(), 1);
924
925 let result_header_value = request.headers.get(header_name).expect("it to exist");
926
927 assert_eq!(
928 header_value,
929 result_header_value
930 .to_str()
931 .expect("it to be a valid string"),
932 );
933
934 assert_eq!(
935 "{ \"key\": \"value\" }",
936 request.body.clone().expect("body to be set"),
937 );
938 }
939 }
940
941 {
942 let input = "
943GET https://mhouge.dk/
944
945{{ body_input }}";
946
947 let request = parse_requests(input, &EMPTY_VARS).expect_err("it to return an error");
948
949 assert!(matches!(
950 request,
951 RequestParseError::VariableNotFound(var)
952 if var == "body_input"
953 ));
954 }
955 }
956
957 #[test]
958 fn input_variables_should_be_overwritten_by_local_variables() {
959 let vars = std::collections::HashMap::from([("method".to_owned(), "PUT".to_owned())]);
960
961 let input = "
962@method = POST
963
964{{method}} https://mhouge.dk/";
965
966 let requests = parse_requests(input, &vars).expect("it to parse successfully");
967
968 assert_eq!(requests.len(), 1);
969
970 let request = requests.first().expect("it to exist");
971
972 assert_eq!(request.method, http::method::Method::POST);
973
974 assert_eq!(request.uri, "https://mhouge.dk/");
975
976 assert_eq!(request.headers.len(), 0);
977 }
978
979 #[test]
980 fn it_should_ignore_comments() {
981 let input = "
982// comment 1
983# comment 2
984
985DELETE https://mhouge.dk/";
986
987 let requests = parse_requests(input, &EMPTY_VARS).expect("it to parse successfully");
988
989 assert_eq!(requests.len(), 1);
990
991 let request = requests.first().expect("it to exist");
992
993 assert_eq!(request.method, http::method::Method::DELETE);
994
995 let expected_uri = "https://mhouge.dk/";
996
997 assert_eq!(request.uri, expected_uri);
998
999 assert!(request.headers.is_empty());
1000
1001 assert!(request.body.is_none());
1002 }
1003}