Skip to content

Commit 02bb120

Browse files
jbrjbr
committed
documentation changes from review
1 parent 268cabd commit 02bb120

File tree

1 file changed

+68
-68
lines changed

1 file changed

+68
-68
lines changed

‎src/proxies/forwarded.rs

Lines changed: 68 additions & 68 deletions
Original file line numberDiff line numberDiff line change
@@ -21,8 +21,8 @@ pub struct Forwarded<'a> {
2121

2222
impl<'a> Forwarded<'a> {
2323
/// Attempts to parse a Forwarded from headers (or a request or
24-
/// response). Builds a reference by default. To
25-
/// build a Forwarded with a 'static lifetime, use
24+
/// response). Builds a borrowed Forwarded by default. To build an
25+
/// owned Forwarded, use
2626
/// `Forwarded::from_headers(...).into_owned()`
2727
///
2828
/// # X-Forwarded-For, -By, and -Proto compatability
@@ -42,25 +42,29 @@ impl<'a> Forwarded<'a> {
4242
///
4343
/// # Examples
4444
/// ```rust
45-
/// # use http_types::{proxies::Forwarded, Method::Get, Request, Url};
46-
/// let mut request = Request::new(Get, Url::parse("http://_/").unwrap());
45+
/// # use http_types::{proxies::Forwarded, Method::Get, Request, Url, Result};
46+
/// # fn main() -> Result<()> {
47+
/// let mut request = Request::new(Get, Url::parse("http://_/")?);
4748
/// request.insert_header(
4849
/// "Forwarded",
4950
/// r#"for=192.0.2.43, for="[2001:db8:cafe::17]", for=unknown;proto=https"#
5051
/// );
51-
/// let forwarded = Forwarded::from_headers(&request).unwrap().unwrap();
52+
/// let forwarded = Forwarded::from_headers(&request)?.unwrap();
5253
/// assert_eq!(forwarded.proto(), Some("https"));
5354
/// assert_eq!(forwarded.forwarded_for(), vec!["192.0.2.43", "[2001:db8:cafe::17]", "unknown"]);
55+
/// # Ok(()) }
5456
/// ```
5557
///
5658
/// ```rust
57-
/// # use http_types::{proxies::Forwarded, Method::Get, Request, Url};
58-
/// let mut request = Request::new(Get, Url::parse("http://_/").unwrap());
59+
/// # use http_types::{proxies::Forwarded, Method::Get, Request, Url, Result};
60+
/// # fn main() -> Result<()> {
61+
/// let mut request = Request::new(Get, Url::parse("http://_/")?);
5962
/// request.insert_header("X-Forwarded-For", "192.0.2.43, 2001:db8:cafe::17");
6063
/// request.insert_header("X-Forwarded-Proto", "https");
61-
/// let forwarded = Forwarded::from_headers(&request).unwrap().unwrap();
64+
/// let forwarded = Forwarded::from_headers(&request)?.unwrap();
6265
/// assert_eq!(forwarded.forwarded_for(), vec!["192.0.2.43", "[2001:db8:cafe::17]"]);
6366
/// assert_eq!(forwarded.proto(), Some("https"));
67+
/// # Ok(()) }
6468
/// ```
6569
6670
pub fn from_headers(headers: &'a impl AsRef<Headers>) -> Result<Option<Self>, ParseError> {
@@ -75,21 +79,25 @@ impl<'a> Forwarded<'a> {
7579
///
7680
/// # Examples
7781
/// ```rust
78-
/// # use http_types::{proxies::Forwarded, Method::Get, Request, Url};
79-
/// let mut request = Request::new(Get, Url::parse("http://_/").unwrap());
82+
/// # use http_types::{proxies::Forwarded, Method::Get, Request, Url, Result};
83+
/// # fn main() -> Result<()> {
84+
/// let mut request = Request::new(Get, Url::parse("http://_/")?);
8085
/// request.insert_header(
8186
/// "Forwarded",
8287
/// r#"for=192.0.2.43, for="[2001:db8:cafe::17]", for=unknown;proto=https"#
8388
/// );
84-
/// let forwarded = Forwarded::from_forwarded_header(&request).unwrap().unwrap();
89+
/// let forwarded = Forwarded::from_forwarded_header(&request)?.unwrap();
8590
/// assert_eq!(forwarded.proto(), Some("https"));
8691
/// assert_eq!(forwarded.forwarded_for(), vec!["192.0.2.43", "[2001:db8:cafe::17]", "unknown"]);
92+
/// # Ok(()) }
8793
/// ```
8894
/// ```rust
89-
/// # use http_types::{proxies::Forwarded, Method::Get, Request, Url};
90-
/// let mut request = Request::new(Get, Url::parse("http://_/").unwrap());
95+
/// # use http_types::{proxies::Forwarded, Method::Get, Request, Url, Result};
96+
/// # fn main() -> Result<()> {
97+
/// let mut request = Request::new(Get, Url::parse("http://_/")?);
9198
/// request.insert_header("X-Forwarded-For", "192.0.2.43, 2001:db8:cafe::17");
92-
/// assert!(Forwarded::from_forwarded_header(&request).unwrap().is_none())
99+
/// assert!(Forwarded::from_forwarded_header(&request)?.is_none());
100+
/// # Ok(()) }
93101
/// ```
94102
pub fn from_forwarded_header(
95103
headers: &'a impl AsRef<Headers>,
@@ -107,20 +115,24 @@ impl<'a> Forwarded<'a> {
107115
///
108116
/// # Examples
109117
/// ```rust
110-
/// # use http_types::{proxies::Forwarded, Method::Get, Request, Url};
111-
/// let mut request = Request::new(Get, Url::parse("http://_/").unwrap());
118+
/// # use http_types::{proxies::Forwarded, Method::Get, Request, Url, Result};
119+
/// # fn main() -> Result<()> {
120+
/// let mut request = Request::new(Get, Url::parse("http://_/")?);
112121
/// request.insert_header("X-Forwarded-For", "192.0.2.43, 2001:db8:cafe::17");
113-
/// let forwarded = Forwarded::from_headers(&request).unwrap().unwrap();
122+
/// let forwarded = Forwarded::from_headers(&request)?.unwrap();
114123
/// assert_eq!(forwarded.forwarded_for(), vec!["192.0.2.43", "[2001:db8:cafe::17]"]);
124+
/// # Ok(()) }
115125
/// ```
116126
/// ```rust
117-
/// # use http_types::{proxies::Forwarded, Method::Get, Request, Url};
118-
/// let mut request = Request::new(Get, Url::parse("http://_/").unwrap());
127+
/// # use http_types::{proxies::Forwarded, Method::Get, Request, Url, Result};
128+
/// # fn main() -> Result<()> {
129+
/// let mut request = Request::new(Get, Url::parse("http://_/")?);
119130
/// request.insert_header(
120131
/// "Forwarded",
121132
/// r#"for=192.0.2.43, for="[2001:db8:cafe::17]", for=unknown;proto=https"#
122133
/// );
123-
/// assert!(Forwarded::from_x_headers(&request).unwrap().is_none());
134+
/// assert!(Forwarded::from_x_headers(&request)?.is_none());
135+
/// # Ok(()) }
124136
/// ```
125137
pub fn from_x_headers(headers: &'a impl AsRef<Headers>) -> Result<Option<Self>, ParseError> {
126138
let headers = headers.as_ref();
@@ -456,52 +468,41 @@ impl<'a> TryFrom<&'a str> for Forwarded<'a> {
456468
#[cfg(test)]
457469
mod tests {
458470
use super::*;
459-
use crate::{Method::Get, Request, Response};
471+
use crate::{Method::Get, Request, Response, Result};
460472
use url::Url;
461473

462474
#[test]
463-
fn parsing_for() -> crate::Result<()> {
475+
fn parsing_for() -> Result<()> {
464476
assert_eq!(
465-
Forwarded::parse(r#"for="_gazonk""#)
466-
.unwrap()
467-
.forwarded_for(),
477+
Forwarded::parse(r#"for="_gazonk""#)?.forwarded_for(),
468478
vec!["_gazonk"]
469479
);
470480
assert_eq!(
471-
Forwarded::parse(r#"For="[2001:db8:cafe::17]:4711""#)
472-
.unwrap()
473-
.forwarded_for(),
481+
Forwarded::parse(r#"For="[2001:db8:cafe::17]:4711""#)?.forwarded_for(),
474482
vec!["[2001:db8:cafe::17]:4711"]
475483
);
476484

477485
assert_eq!(
478-
Forwarded::parse("for=192.0.2.60;proto=http;by=203.0.113.43")
479-
.unwrap()
480-
.forwarded_for(),
486+
Forwarded::parse("for=192.0.2.60;proto=http;by=203.0.113.43")?.forwarded_for(),
481487
vec!["192.0.2.60"]
482488
);
483489

484490
assert_eq!(
485-
Forwarded::parse("for=192.0.2.43, for=198.51.100.17")
486-
.unwrap()
487-
.forwarded_for(),
491+
Forwarded::parse("for=192.0.2.43, for=198.51.100.17")?.forwarded_for(),
488492
vec!["192.0.2.43", "198.51.100.17"]
489493
);
490494

491495
assert_eq!(
492-
Forwarded::parse(r#"for=192.0.2.43,for="[2001:db8:cafe::17]",for=unknown"#)
493-
.unwrap()
496+
Forwarded::parse(r#"for=192.0.2.43,for="[2001:db8:cafe::17]",for=unknown"#)?
494497
.forwarded_for(),
495-
Forwarded::parse(r#"for=192.0.2.43, for="[2001:db8:cafe::17]", for=unknown"#)
496-
.unwrap()
498+
Forwarded::parse(r#"for=192.0.2.43, for="[2001:db8:cafe::17]", for=unknown"#)?
497499
.forwarded_for()
498500
);
499501

500502
assert_eq!(
501503
Forwarded::parse(
502504
r#"for=192.0.2.43,for="this is a valid quoted-string, \" \\",for=unknown"#
503-
)
504-
.unwrap()
505+
)?
505506
.forwarded_for(),
506507
vec![
507508
"192.0.2.43",
@@ -514,25 +515,19 @@ mod tests {
514515
}
515516

516517
#[test]
517-
fn formatting_for() -> crate::Result<()> {
518-
assert_eq!("", Forwarded::new().to_string());
519-
Ok(())
520-
}
521-
522-
#[test]
523-
fn basic_parse() {
524-
let forwarded =
525-
Forwarded::parse("for=client.com;by=proxy.com;host=host.com;proto=https").unwrap();
518+
fn basic_parse() -> Result<()> {
519+
let forwarded = Forwarded::parse("for=client.com;by=proxy.com;host=host.com;proto=https")?;
526520

527521
assert_eq!(forwarded.by(), Some("proxy.com"));
528522
assert_eq!(forwarded.forwarded_for(), vec!["client.com"]);
529523
assert_eq!(forwarded.host(), Some("host.com"));
530524
assert_eq!(forwarded.proto(), Some("https"));
531525
assert!(matches!(forwarded, Forwarded{..}));
526+
Ok(())
532527
}
533528

534529
#[test]
535-
fn bad_parse() {
530+
fn bad_parse() -> Result<()> {
536531
let err = Forwarded::parse("by=proxy.com;for=client;host=example.com;host").unwrap_err();
537532
assert_eq!(
538533
err.to_string(),
@@ -562,10 +557,11 @@ mod tests {
562557
err.to_string(),
563558
"unable to parse forwarded header: for= without valid value"
564559
);
560+
Ok(())
565561
}
566562

567563
#[test]
568-
fn bad_parse_from_headers() {
564+
fn bad_parse_from_headers() -> Result<()> {
569565
let mut response = Response::new(200);
570566
response.append_header("forwarded", "uh oh");
571567
assert_eq!(
@@ -574,72 +570,76 @@ mod tests {
574570
);
575571

576572
let response = Response::new(200);
577-
assert!(Forwarded::from_headers(&response).unwrap().is_none());
573+
assert!(Forwarded::from_headers(&response)?.is_none());
574+
Ok(())
578575
}
579576

580577
#[test]
581-
fn from_x_headers() {
582-
let mut request = Request::new(Get, Url::parse("http://_/").unwrap());
578+
fn from_x_headers() -> Result<()> {
579+
let mut request = Request::new(Get, Url::parse("http://_/")?);
583580
request.append_header(X_FORWARDED_FOR, "192.0.2.43, 2001:db8:cafe::17");
584581
request.append_header(X_FORWARDED_PROTO, "gopher");
585-
let forwarded = Forwarded::from_headers(&request).unwrap().unwrap();
582+
let forwarded = Forwarded::from_headers(&request)?.unwrap();
586583
assert_eq!(
587584
forwarded.to_string(),
588585
r#"for=192.0.2.43, for="[2001:db8:cafe::17]";proto=gopher"#
589586
);
587+
Ok(())
590588
}
591589

592590
#[test]
593-
fn formatting_edge_cases() {
591+
fn formatting_edge_cases() -> Result<()> {
594592
let forwarded = Forwarded::new()
595593
.with_for(r#"quote: " backslash: \"#.into())
596594
.with_for(";proto=https".into());
597595
assert_eq!(
598596
forwarded.to_string(),
599597
r#"for="quote: \" backslash: \\", for=";proto=https""#
600598
);
599+
Ok(())
601600
}
602601

603602
#[test]
604-
fn parse_edge_cases() {
603+
fn parse_edge_cases() -> Result<()> {
605604
let forwarded =
606-
Forwarded::parse(r#"for=";", for=",", for="\"", for=unquoted;by=";proto=https""#)
607-
.unwrap();
605+
Forwarded::parse(r#"for=";", for=",", for="\"", for=unquoted;by=";proto=https""#)?;
608606
assert_eq!(forwarded.forwarded_for(), vec![";", ",", "\"", "unquoted"]);
609607
assert_eq!(forwarded.by(), Some(";proto=https"));
610608
assert!(forwarded.proto().is_none());
611609

612-
let forwarded = Forwarded::parse("proto=https").unwrap();
610+
let forwarded = Forwarded::parse("proto=https")?;
613611
assert_eq!(forwarded.proto(), Some("https"));
612+
Ok(())
614613
}
615614

616615
#[test]
617-
fn owned_parse() {
618-
let forwarded = Forwarded::parse("for=client;by=proxy.com;host=example.com;proto=https")
619-
.unwrap()
620-
.into_owned();
616+
fn owned_parse() -> Result<()> {
617+
let forwarded =
618+
Forwarded::parse("for=client;by=proxy.com;host=example.com;proto=https")?.into_owned();
621619

622620
assert_eq!(forwarded.by(), Some("proxy.com"));
623621
assert_eq!(forwarded.forwarded_for(), vec!["client"]);
624622
assert_eq!(forwarded.host(), Some("example.com"));
625623
assert_eq!(forwarded.proto(), Some("https"));
626624
assert!(matches!(forwarded, Forwarded{..}));
625+
Ok(())
627626
}
628627

629628
#[test]
630-
fn from_request() -> crate::Result<()> {
631-
let mut request = Request::new(Get, Url::parse("http://_/").unwrap());
629+
fn from_request() -> Result<()> {
630+
let mut request = Request::new(Get, Url::parse("http://_/")?);
632631
request.append_header("Forwarded", "for=for");
633632

634633
let forwarded = Forwarded::from_headers(&request)?.unwrap();
635634
assert_eq!(forwarded.forwarded_for(), vec!["for"]);
635+
636636
Ok(())
637637
}
638638

639639
#[test]
640-
fn owned_can_outlive_request() -> crate::Result<()> {
640+
fn owned_can_outlive_request() -> Result<()> {
641641
let forwarded = {
642-
let mut request = Request::new(Get, Url::parse("http://_/").unwrap());
642+
let mut request = Request::new(Get, Url::parse("http://_/")?);
643643
request.append_header("Forwarded", "for=for;by=by;host=host;proto=proto");
644644
Forwarded::from_headers(&request)?.unwrap().into_owned()
645645
};

0 commit comments

Comments
 (0)