commit
2e5475d45d
@ -0,0 +1,3 @@ |
||||
/target/ |
||||
**/*.rs.bk |
||||
Cargo.lock |
@ -0,0 +1,5 @@ |
||||
language: rust |
||||
rust: |
||||
- stable |
||||
- beta |
||||
- nightly |
@ -0,0 +1,25 @@ |
||||
[package] |
||||
name = "hyper-reverse-proxy" |
||||
version = "0.1.0" |
||||
authors = ["Brendan Zabarauskas <bjzaba@yahoo.com.au>"] |
||||
license = "Apache-2.0" |
||||
description = "A simple reverse proxy, to be used with Hyper and Tokio." |
||||
homepage = "https://github.com/brendanzab/hyper-reverse-proxy" |
||||
documentation = "https://docs.rs/hyper-reverse-proxy" |
||||
repository = "https://github.com/brendanzab/hyper-reverse-proxy" |
||||
keywords = ["http", "hyper"] |
||||
categories = ["network-programming", "web-programming"] |
||||
readme = "README.md" |
||||
|
||||
include = [ |
||||
"Cargo.toml", |
||||
"LICENSE", |
||||
"src/**/*" |
||||
] |
||||
|
||||
[dependencies] |
||||
futures = "0.1.14" |
||||
hyper = "0.11.0" |
||||
lazy_static = "0.2" |
||||
unicase = "2.0.0" |
||||
void = "1.0.2" |
@ -0,0 +1,202 @@ |
||||
|
||||
Apache License |
||||
Version 2.0, January 2004 |
||||
http://www.apache.org/licenses/ |
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION |
||||
|
||||
1. Definitions. |
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction, |
||||
and distribution as defined by Sections 1 through 9 of this document. |
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by |
||||
the copyright owner that is granting the License. |
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all |
||||
other entities that control, are controlled by, or are under common |
||||
control with that entity. For the purposes of this definition, |
||||
"control" means (i) the power, direct or indirect, to cause the |
||||
direction or management of such entity, whether by contract or |
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the |
||||
outstanding shares, or (iii) beneficial ownership of such entity. |
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity |
||||
exercising permissions granted by this License. |
||||
|
||||
"Source" form shall mean the preferred form for making modifications, |
||||
including but not limited to software source code, documentation |
||||
source, and configuration files. |
||||
|
||||
"Object" form shall mean any form resulting from mechanical |
||||
transformation or translation of a Source form, including but |
||||
not limited to compiled object code, generated documentation, |
||||
and conversions to other media types. |
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or |
||||
Object form, made available under the License, as indicated by a |
||||
copyright notice that is included in or attached to the work |
||||
(an example is provided in the Appendix below). |
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object |
||||
form, that is based on (or derived from) the Work and for which the |
||||
editorial revisions, annotations, elaborations, or other modifications |
||||
represent, as a whole, an original work of authorship. For the purposes |
||||
of this License, Derivative Works shall not include works that remain |
||||
separable from, or merely link (or bind by name) to the interfaces of, |
||||
the Work and Derivative Works thereof. |
||||
|
||||
"Contribution" shall mean any work of authorship, including |
||||
the original version of the Work and any modifications or additions |
||||
to that Work or Derivative Works thereof, that is intentionally |
||||
submitted to Licensor for inclusion in the Work by the copyright owner |
||||
or by an individual or Legal Entity authorized to submit on behalf of |
||||
the copyright owner. For the purposes of this definition, "submitted" |
||||
means any form of electronic, verbal, or written communication sent |
||||
to the Licensor or its representatives, including but not limited to |
||||
communication on electronic mailing lists, source code control systems, |
||||
and issue tracking systems that are managed by, or on behalf of, the |
||||
Licensor for the purpose of discussing and improving the Work, but |
||||
excluding communication that is conspicuously marked or otherwise |
||||
designated in writing by the copyright owner as "Not a Contribution." |
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity |
||||
on behalf of whom a Contribution has been received by Licensor and |
||||
subsequently incorporated within the Work. |
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of |
||||
this License, each Contributor hereby grants to You a perpetual, |
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable |
||||
copyright license to reproduce, prepare Derivative Works of, |
||||
publicly display, publicly perform, sublicense, and distribute the |
||||
Work and such Derivative Works in Source or Object form. |
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of |
||||
this License, each Contributor hereby grants to You a perpetual, |
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable |
||||
(except as stated in this section) patent license to make, have made, |
||||
use, offer to sell, sell, import, and otherwise transfer the Work, |
||||
where such license applies only to those patent claims licensable |
||||
by such Contributor that are necessarily infringed by their |
||||
Contribution(s) alone or by combination of their Contribution(s) |
||||
with the Work to which such Contribution(s) was submitted. If You |
||||
institute patent litigation against any entity (including a |
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work |
||||
or a Contribution incorporated within the Work constitutes direct |
||||
or contributory patent infringement, then any patent licenses |
||||
granted to You under this License for that Work shall terminate |
||||
as of the date such litigation is filed. |
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the |
||||
Work or Derivative Works thereof in any medium, with or without |
||||
modifications, and in Source or Object form, provided that You |
||||
meet the following conditions: |
||||
|
||||
(a) You must give any other recipients of the Work or |
||||
Derivative Works a copy of this License; and |
||||
|
||||
(b) You must cause any modified files to carry prominent notices |
||||
stating that You changed the files; and |
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works |
||||
that You distribute, all copyright, patent, trademark, and |
||||
attribution notices from the Source form of the Work, |
||||
excluding those notices that do not pertain to any part of |
||||
the Derivative Works; and |
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its |
||||
distribution, then any Derivative Works that You distribute must |
||||
include a readable copy of the attribution notices contained |
||||
within such NOTICE file, excluding those notices that do not |
||||
pertain to any part of the Derivative Works, in at least one |
||||
of the following places: within a NOTICE text file distributed |
||||
as part of the Derivative Works; within the Source form or |
||||
documentation, if provided along with the Derivative Works; or, |
||||
within a display generated by the Derivative Works, if and |
||||
wherever such third-party notices normally appear. The contents |
||||
of the NOTICE file are for informational purposes only and |
||||
do not modify the License. You may add Your own attribution |
||||
notices within Derivative Works that You distribute, alongside |
||||
or as an addendum to the NOTICE text from the Work, provided |
||||
that such additional attribution notices cannot be construed |
||||
as modifying the License. |
||||
|
||||
You may add Your own copyright statement to Your modifications and |
||||
may provide additional or different license terms and conditions |
||||
for use, reproduction, or distribution of Your modifications, or |
||||
for any such Derivative Works as a whole, provided Your use, |
||||
reproduction, and distribution of the Work otherwise complies with |
||||
the conditions stated in this License. |
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise, |
||||
any Contribution intentionally submitted for inclusion in the Work |
||||
by You to the Licensor shall be under the terms and conditions of |
||||
this License, without any additional terms or conditions. |
||||
Notwithstanding the above, nothing herein shall supersede or modify |
||||
the terms of any separate license agreement you may have executed |
||||
with Licensor regarding such Contributions. |
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade |
||||
names, trademarks, service marks, or product names of the Licensor, |
||||
except as required for reasonable and customary use in describing the |
||||
origin of the Work and reproducing the content of the NOTICE file. |
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or |
||||
agreed to in writing, Licensor provides the Work (and each |
||||
Contributor provides its Contributions) on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
||||
implied, including, without limitation, any warranties or conditions |
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A |
||||
PARTICULAR PURPOSE. You are solely responsible for determining the |
||||
appropriateness of using or redistributing the Work and assume any |
||||
risks associated with Your exercise of permissions under this License. |
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory, |
||||
whether in tort (including negligence), contract, or otherwise, |
||||
unless required by applicable law (such as deliberate and grossly |
||||
negligent acts) or agreed to in writing, shall any Contributor be |
||||
liable to You for damages, including any direct, indirect, special, |
||||
incidental, or consequential damages of any character arising as a |
||||
result of this License or out of the use or inability to use the |
||||
Work (including but not limited to damages for loss of goodwill, |
||||
work stoppage, computer failure or malfunction, or any and all |
||||
other commercial damages or losses), even if such Contributor |
||||
has been advised of the possibility of such damages. |
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing |
||||
the Work or Derivative Works thereof, You may choose to offer, |
||||
and charge a fee for, acceptance of support, warranty, indemnity, |
||||
or other liability obligations and/or rights consistent with this |
||||
License. However, in accepting such obligations, You may act only |
||||
on Your own behalf and on Your sole responsibility, not on behalf |
||||
of any other Contributor, and only if You agree to indemnify, |
||||
defend, and hold each Contributor harmless for any liability |
||||
incurred by, or claims asserted against, such Contributor by reason |
||||
of your accepting any such warranty or additional liability. |
||||
|
||||
END OF TERMS AND CONDITIONS |
||||
|
||||
APPENDIX: How to apply the Apache License to your work. |
||||
|
||||
To apply the Apache License to your work, attach the following |
||||
boilerplate notice, with the fields enclosed by brackets "[]" |
||||
replaced with your own identifying information. (Don't include |
||||
the brackets!) The text should be enclosed in the appropriate |
||||
comment syntax for the file format. We also recommend that a |
||||
file or class name and description of purpose be included on the |
||||
same "printed page" as the copyright notice for easier |
||||
identification within third-party archives. |
||||
|
||||
Copyright [yyyy] [name of copyright owner] |
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License"); |
||||
you may not use this file except in compliance with the License. |
||||
You may obtain a copy of the License at |
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0 |
||||
|
||||
Unless required by applicable law or agreed to in writing, software |
||||
distributed under the License is distributed on an "AS IS" BASIS, |
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
||||
See the License for the specific language governing permissions and |
||||
limitations under the License. |
@ -0,0 +1,12 @@ |
||||
# hyper-reverse-proxy |
||||
|
||||
[![Build Status](https://travis-ci.org/brendanzab/hyper-reverse-proxy.svg?branch=master)](https://travis-ci.org/brendanzab/hyper-reverse-proxy) |
||||
[![Documentation](https://docs.rs/hyper-reverse-proxy/badge.svg)](https://docs.rs/hyper-reverse-proxy) |
||||
[![Version](https://img.shields.io/crates/v/hyper-reverse-proxy.svg)](https://crates.io/crates/hyper-reverse-proxy) |
||||
[![License](https://img.shields.io/crates/l/hyper-reverse-proxy.svg)](https://github.com/brendanzab/hyper-reverse-proxy/blob/master/LICENSE) |
||||
|
||||
A simple reverse proxy, to be used with Hyper and Tokio. |
||||
|
||||
The implementation was originally based on Go's [`httputil.ReverseProxy`]. |
||||
|
||||
[`httputil.ReverseProxy`]: https://golang.org/pkg/net/http/httputil/#ReverseProxy |
@ -0,0 +1,157 @@ |
||||
//! A simple reverse proxy, to be used with Hyper and Tokio.
|
||||
|
||||
extern crate futures; |
||||
#[macro_use] |
||||
extern crate hyper; |
||||
#[macro_use] |
||||
extern crate lazy_static; |
||||
extern crate unicase; |
||||
extern crate void; |
||||
|
||||
use futures::future::Future; |
||||
use hyper::{Body, Request, Response, StatusCode}; |
||||
use hyper::server::Service; |
||||
use hyper::header::Headers; |
||||
use std::marker::PhantomData; |
||||
use std::net::IpAddr; |
||||
use void::Void; |
||||
|
||||
fn is_hop_header(name: &str) -> bool { |
||||
use unicase::Ascii; |
||||
|
||||
// A list of the headers, using `unicase` to help us compare without
|
||||
// worrying about the case, and `lazy_static!` to prevent reallocation
|
||||
// of the vector.
|
||||
lazy_static! { |
||||
static ref HOP_HEADERS: Vec<Ascii<&'static str>> = vec![ |
||||
Ascii::new("Connection"), |
||||
Ascii::new("Keep-Alive"), |
||||
Ascii::new("Proxy-Authenticate"), |
||||
Ascii::new("Proxy-Authorization"), |
||||
Ascii::new("Te"), |
||||
Ascii::new("Trailers"), |
||||
Ascii::new("Transfer-Encoding"), |
||||
Ascii::new("Upgrade"), |
||||
]; |
||||
} |
||||
|
||||
HOP_HEADERS.iter().any(|h| h == &name) |
||||
} |
||||
|
||||
/// Returns a clone of the headers without the [hop-by-hop headers].
|
||||
///
|
||||
/// [hop-by-hop headers]: http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html
|
||||
fn remove_hop_headers(headers: &Headers) -> Headers { |
||||
headers |
||||
.iter() |
||||
.filter(|header| is_hop_header(header.name())) |
||||
.collect() |
||||
} |
||||
|
||||
// TODO: use https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Forwarded ?
|
||||
header! { |
||||
/// `X-Forwarded-For` header.
|
||||
///
|
||||
/// The `X-Forwarded-For` header describes the path of
|
||||
/// proxies this request has been forwarded through.
|
||||
///
|
||||
/// # Example Values
|
||||
///
|
||||
/// * `2001:db8:85a3:8d3:1319:8a2e:370:7348`
|
||||
/// * `203.0.113.195`
|
||||
/// * `203.0.113.195, 70.41.3.18, 150.172.238.178`
|
||||
///
|
||||
/// # References
|
||||
///
|
||||
/// - [MDN](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/X-Forwarded-For)
|
||||
/// - [Wikipedia](https://en.wikipedia.org/wiki/X-Forwarded-For)
|
||||
(XForwardedFor, "X-Forwarded-For") => (IpAddr)+ |
||||
|
||||
// test_x_forwarded_for {
|
||||
// // Testcases from MDN
|
||||
// test_header!(test1, vec![b"2001:db8:85a3:8d3:1319:8a2e:370:7348"]);
|
||||
// test_header!(test2, vec![b"203.0.113.195"]);
|
||||
// test_header!(test3, vec![b"203.0.113.195, 70.41.3.18, 150.172.238.178"]);
|
||||
// }
|
||||
} |
||||
|
||||
fn create_proxied_response<B>(mut response: Response<B>) -> Response<B> { |
||||
*response.headers_mut() = remove_hop_headers(response.headers()); |
||||
response |
||||
} |
||||
|
||||
/// A `Service` that takes an incoming request, sends it to a given `Client`, then proxies back
|
||||
/// the response.
|
||||
///
|
||||
/// The implementation ensures that [Hop-by-hop headers] are stripped correctly in both directions,
|
||||
/// and adds the client's IP address to a comma-space-separated list of forwarding addresses in the
|
||||
/// `X-Forwarded-For` header.
|
||||
///
|
||||
/// The implementation is based on Go's [`httputil.ReverseProxy`].
|
||||
///
|
||||
/// [Hop-by-hop headers]: http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html
|
||||
/// [`httputil.ReverseProxy`]: https://golang.org/pkg/net/http/httputil/#ReverseProxy
|
||||
pub struct ReverseProxy<C: Service, B = Body> { |
||||
client: C, |
||||
remote_ip_addr: Option<IpAddr>, |
||||
_pantom_data: PhantomData<B>, |
||||
} |
||||
|
||||
impl<C: Service, B> ReverseProxy<C, B> { |
||||
/// Construct a reverse proxy that dispatches to the given client.
|
||||
pub fn new(client: C, remote_ip_addr: Option<IpAddr>) -> ReverseProxy<C, B> { |
||||
ReverseProxy { |
||||
client, |
||||
remote_ip_addr, |
||||
_pantom_data: PhantomData, |
||||
} |
||||
} |
||||
|
||||
fn create_proxied_request(&self, mut request: Request<B>) -> Request<B> { |
||||
*request.headers_mut() = remove_hop_headers(request.headers()); |
||||
|
||||
// Add forwarding information in the headers
|
||||
if let Some(ip_addr) = self.remote_ip_addr { |
||||
// This is kind of ugly because of borrowing. Maybe hyper's `Headers` object
|
||||
// could use an entry API like `std::collections::HashMap`?
|
||||
if request.headers().has::<XForwardedFor>() { |
||||
if let Some(prior) = request.headers_mut().get_mut::<XForwardedFor>() { |
||||
prior.0.push(ip_addr); |
||||
} |
||||
} else { |
||||
let header = XForwardedFor(vec![ip_addr]); |
||||
request.headers_mut().set(header); |
||||
} |
||||
} |
||||
|
||||
request |
||||
} |
||||
} |
||||
|
||||
impl<C, B> Service for ReverseProxy<C, B> |
||||
where |
||||
B: 'static, |
||||
C: Service<Request = Request<B>, Response = Response<B>>, |
||||
C::Error: 'static + std::fmt::Display, |
||||
C::Future: 'static, |
||||
{ |
||||
type Request = Request<B>; |
||||
type Response = Response<B>; |
||||
type Error = Void; |
||||
type Future = Box<Future<Item = Response<B>, Error = Void>>; |
||||
|
||||
fn call(&self, request: Self::Request) -> Self::Future { |
||||
let proxied_request = self.create_proxied_request(request); |
||||
|
||||
Box::new(self.client.call(proxied_request).then(|response| { |
||||
Ok(match response { |
||||
Ok(response) => create_proxied_response(response), |
||||
Err(error) => { |
||||
println!("Error: {}", error); // TODO: Configurable logging
|
||||
Response::new().with_status(StatusCode::InternalServerError) |
||||
// TODO: handle trailers
|
||||
} |
||||
}) |
||||
})) |
||||
} |
||||
} |
@ -0,0 +1,127 @@ |
||||
extern crate futures; |
||||
#[macro_use] |
||||
extern crate hyper; |
||||
extern crate hyper_reverse_proxy; |
||||
|
||||
use futures::future::{self, Future, FutureResult}; |
||||
use hyper::{Get, Request, Response}; |
||||
use hyper::server::Service; |
||||
use hyper_reverse_proxy::ReverseProxy; |
||||
|
||||
struct MockService<F: Fn(Request) -> Response>(F); |
||||
|
||||
impl<F: Fn(Request) -> Response> Service for MockService<F> { |
||||
type Request = Request; |
||||
type Response = Response; |
||||
type Error = hyper::Error; |
||||
type Future = FutureResult<Response, hyper::Error>; |
||||
|
||||
fn call(&self, request: Self::Request) -> Self::Future { |
||||
future::ok((self.0)(request)) |
||||
} |
||||
} |
||||
|
||||
#[test] |
||||
#[ignore] |
||||
fn adds_forwarded_for_header() { |
||||
// TODO: https://github.com/hyperium/hyper/issues/1258
|
||||
unimplemented!() |
||||
} |
||||
|
||||
#[test] |
||||
fn forwards_the_bodies() { |
||||
use futures::Stream; |
||||
|
||||
let mut request = Request::new(Get, "/".parse().unwrap()); |
||||
request.set_body("request"); |
||||
|
||||
let service = ReverseProxy::new(MockService(|request| { |
||||
let body = request.body().concat2().wait().unwrap(); |
||||
assert_eq!(body.as_ref(), b"request"); |
||||
|
||||
Response::new().with_body("response") |
||||
})); |
||||
|
||||
let response = service.call(request).wait().unwrap(); |
||||
let body = response.body().concat2().wait().unwrap(); |
||||
assert_eq!(body.as_ref(), b"response"); |
||||
} |
||||
|
||||
#[test] |
||||
fn clones_headers() { |
||||
header! { (XTestHeader1, "X-Test-Header1") => [String] } |
||||
header! { (XTestHeader2, "X-Test-Header2") => [String] } |
||||
|
||||
let mut request = Request::new(Get, "/".parse().unwrap()); |
||||
request.headers_mut().set(XTestHeader1("Test1".to_owned())); |
||||
request.headers_mut().set(XTestHeader2("Test2".to_owned())); |
||||
|
||||
let service = ReverseProxy::new(MockService(|request| { |
||||
let header1 = request.headers().get::<XTestHeader1>().unwrap(); |
||||
let header2 = request.headers().get::<XTestHeader2>().unwrap(); |
||||
assert_eq!(header1, &XTestHeader1("Test1".to_owned())); |
||||
assert_eq!(header2, &XTestHeader2("Test2".to_owned())); |
||||
Response::new() |
||||
})); |
||||
|
||||
service.call(request).wait().unwrap(); |
||||
} |
||||
|
||||
#[test] |
||||
fn removes_request_hop_headers() { |
||||
use hyper::header::{Connection, TransferEncoding, Upgrade}; |
||||
|
||||
let mut request = Request::new(Get, "/".parse().unwrap()); |
||||
request.headers_mut().set(Connection(vec![])); |
||||
request.headers_mut().set_raw("Keep-Alive", ""); |
||||
request.headers_mut().set_raw("Proxy-Authenticate", ""); |
||||
request.headers_mut().set_raw("Proxy-Authorization", ""); |
||||
request.headers_mut().set_raw("TE", ""); |
||||
request.headers_mut().set_raw("Trailers", ""); |
||||
request.headers_mut().set(TransferEncoding(vec![])); |
||||
request.headers_mut().set(Upgrade(vec![])); |
||||
|
||||
let service = ReverseProxy::new(MockService(|request| { |
||||
assert_eq!(request.headers().get::<Connection>(), None); |
||||
assert_eq!(request.headers().get_raw("Keep-Alive"), None); |
||||
assert_eq!(request.headers().get_raw("Proxy-Authenticate"), None); |
||||
assert_eq!(request.headers().get_raw("Proxy-Authorization"), None); |
||||
assert_eq!(request.headers().get_raw("TE"), None); |
||||
assert_eq!(request.headers().get_raw("Trailers"), None); |
||||
assert_eq!(request.headers().get::<TransferEncoding>(), None); |
||||
assert_eq!(request.headers().get::<Upgrade>(), None); |
||||
Response::new() |
||||
})); |
||||
|
||||
service.call(request).wait().unwrap(); |
||||
} |
||||
|
||||
#[test] |
||||
fn removes_response_hop_headers() { |
||||
use hyper::header::{Connection, TransferEncoding, Upgrade}; |
||||
|
||||
let request = Request::new(Get, "/".parse().unwrap()); |
||||
|
||||
let service = ReverseProxy::new(MockService(|_| { |
||||
let mut response = Response::new(); |
||||
response.headers_mut().set(Connection(vec![])); |
||||
response.headers_mut().set_raw("Keep-Alive", ""); |
||||
response.headers_mut().set_raw("Proxy-Authenticate", ""); |
||||
response.headers_mut().set_raw("Proxy-Authorization", ""); |
||||
response.headers_mut().set_raw("TE", ""); |
||||
response.headers_mut().set_raw("Trailers", ""); |
||||
response.headers_mut().set(TransferEncoding(vec![])); |
||||
response.headers_mut().set(Upgrade(vec![])); |
||||
response |
||||
})); |
||||
|
||||
let response = service.call(request).wait().unwrap(); |
||||
assert_eq!(response.headers().get::<Connection>(), None); |
||||
assert_eq!(response.headers().get_raw("Keep-Alive"), None); |
||||
assert_eq!(response.headers().get_raw("Proxy-Authenticate"), None); |
||||
assert_eq!(response.headers().get_raw("Proxy-Authorization"), None); |
||||
assert_eq!(response.headers().get_raw("TE"), None); |
||||
assert_eq!(response.headers().get_raw("Trailers"), None); |
||||
assert_eq!(response.headers().get::<TransferEncoding>(), None); |
||||
assert_eq!(response.headers().get::<Upgrade>(), None); |
||||
} |
Loading…
Reference in new issue