=
+ LazyLock::new(|| load_vcard_personal_portfolio().unwrap());
+ CACHE.borrow_pack_archived()
+}
+
+// runs a http server serving pack, listening on bind or local emphemeric port
+// if not set, notifying bind_ready_sender when server is ready and where is
+// listening and shuts down when shutdown_receiver yields
+pub async fn serve_pack(
+ pack: &P,
+ bind: Option,
+ bind_ready_sender: Option>,
+ shutdown_receiver: oneshot::Receiver<()>,
+) -> Result<(), Error>
+where
+ P: web_static_pack::pack::Pack + Sync + 'static,
+{
+ log::trace!("staring server");
+
+ // pin shutdown future
+ pin_mut!(shutdown_receiver);
+
+ // make responder from `pack`
+ let responder = web_static_pack::responder::Responder::new(pack);
+
+ // hyper requires service to be static
+ // we use graceful, no connections will outlive server function
+ let responder = unsafe {
+ transmute::<
+ &web_static_pack::responder::Responder<'_, P>,
+ &web_static_pack::responder::Responder<'static, P>,
+ >(&responder)
+ };
+
+ // make hyper service
+ let service_fn = service_fn(|request: Request| async {
+ let (parts, _body) = request.into_parts();
+
+ log::info!("serving {}", parts.uri);
+ let response = responder.respond_flatten(parts);
+
+ Ok::<_, Infallible>(response)
+ });
+
+ // graceful shutdown watcher
+ let graceful = GracefulShutdown::new();
+
+ // use ephemeric port
+ let bind = bind.unwrap_or(SocketAddr::V4(SocketAddrV4::new(Ipv4Addr::LOCALHOST, 0)));
+
+ // server listener
+ let listener = TcpListener::bind(bind).await?;
+
+ // get final listening port
+ let bind = listener.local_addr()?;
+ log::trace!("listening on {bind}");
+
+ // notify that server is ready
+ if let Some(bind_ready_sender) = bind_ready_sender {
+ bind_ready_sender.send(bind).unwrap();
+ }
+
+ // main loop
+ log::trace!("entering main server loop");
+ loop {
+ let listener_accept = listener.accept();
+ pin_mut!(listener_accept);
+
+ match select(listener_accept, &mut shutdown_receiver).await {
+ Either::Left((result, _)) => {
+ let (stream, _remote_address) = result?;
+ log::trace!("new connection");
+
+ let io = TokioIo::new(stream);
+
+ let connection = http1::Builder::new().serve_connection(io, service_fn);
+ let graceful_connection = graceful.watch(connection);
+
+ tokio::spawn(async move {
+ graceful_connection.await.unwrap();
+ });
+ }
+ Either::Right((result, _)) => {
+ result.unwrap();
+ log::trace!("got exit signal");
+ break;
+ }
+ }
+ }
+
+ log::trace!("waiting for active connections to shutdown");
+ graceful.shutdown().await;
+
+ log::trace!("exiting server");
+ Ok(())
+}
+
+// gets each of paths from pack_paths from pack, performs GET request on
+// http://address/pack_path
+pub async fn download_verify_pack(
+ pack: &P,
+ pack_paths: &[&str],
+ address: SocketAddr,
+) -> Result<(), Error>
+where
+ P: web_static_pack::pack::Pack + Sync + 'static,
+{
+ let client = Client::new();
+
+ for pack_path in pack_paths {
+ log::trace!("downloading {pack_path}");
+
+ let file = pack
+ .get_file_by_path(pack_path)
+ .ok_or_else(|| anyhow!("request file missing in pack"))?;
+
+ let response = client
+ .get(format!("http://{address}{pack_path}"))
+ .send()
+ .await?
+ .error_for_status()?;
+
+ let content_type = response
+ .headers()
+ .get(header::CONTENT_TYPE)
+ .ok_or_else(|| anyhow!("content type missing in response"))?
+ .clone();
+ let etag = response
+ .headers()
+ .get(header::ETAG)
+ .ok_or_else(|| anyhow!("etag missing in response"))?
+ .clone();
+ let cache_control = response
+ .headers()
+ .get(header::CACHE_CONTROL)
+ .ok_or_else(|| anyhow!("cache control missing in response"))?
+ .clone();
+ let content = response.bytes().await?;
+
+ ensure!(content == web_static_pack::file::File::content(file));
+ ensure!(content_type == web_static_pack::file::File::content_type(file));
+ ensure!(etag == web_static_pack::file::File::etag(file));
+ ensure!(cache_control == web_static_pack::file::File::cache_control(file).cache_control());
+ }
+
+ drop(client);
+
+ Ok(())
+}
diff --git a/tests/tests/build_and_load.rs b/tests/tests/build_and_load.rs
new file mode 100644
index 0000000..2ad4145
--- /dev/null
+++ b/tests/tests/build_and_load.rs
@@ -0,0 +1,71 @@
+use std::collections::HashSet;
+use web_static_pack_tests::{
+ build_vcard_personal_portfolio_cached, load_vcard_personal_portfolio_cached,
+};
+
+#[test]
+fn builder_builds_pack_with_same_contents() {
+ // prebuilt `pack` loaded from data
+ let pack_archived = load_vcard_personal_portfolio_cached();
+
+ // `pack` built from source files
+ let pack = build_vcard_personal_portfolio_cached();
+
+ // check if they contain equal keys
+ assert_eq!(
+ pack.files_by_path
+ .keys()
+ .map(|pack_path| &**pack_path)
+ .collect::>(),
+ pack_archived
+ .files_by_path
+ .keys()
+ .map(|pack_path_archived| &**pack_path_archived)
+ .collect::>()
+ );
+
+ // zip values and check if they are equal
+ pack.files_by_path
+ .iter()
+ .map(|(pack_path, file)| {
+ (
+ pack_path,
+ file,
+ pack_archived.files_by_path.get(&**pack_path).unwrap(),
+ )
+ })
+ .for_each(|(_pack_path, file, file_archived)| {
+ assert_eq!(&*file.content, &*file_archived.content);
+ assert_eq!(
+ file.content_gzip.as_deref(),
+ file_archived.content_gzip.as_deref()
+ );
+ assert_eq!(
+ file.content_brotli.as_deref(),
+ file_archived.content_brotli.as_deref()
+ );
+
+ assert_eq!(file.content_type, file_archived.content_type);
+ assert_eq!(file.etag, file_archived.etag);
+ // assert_eq!(file.cache_control, file_archived.cache_control);
+ // TODO: fix this comparision
+ });
+}
+
+#[test]
+fn loader_loads_correctly_prebuilt_pack() {
+ let pack_archived = load_vcard_personal_portfolio_cached();
+
+ // index.html should have content-type: text/html; charset=utf-8
+ assert_eq!(
+ pack_archived
+ .files_by_path
+ .get("/index.html")
+ .unwrap()
+ .content_type,
+ "text/html; charset=utf-8"
+ );
+
+ // index.php should not exists
+ assert!(pack_archived.files_by_path.get("/index.php").is_none());
+}
diff --git a/tests/tests/load_and_serve.rs b/tests/tests/load_and_serve.rs
new file mode 100644
index 0000000..e68837a
--- /dev/null
+++ b/tests/tests/load_and_serve.rs
@@ -0,0 +1,45 @@
+#![feature(async_closure)]
+
+use futures::{channel::oneshot, try_join};
+use std::net::SocketAddr;
+use web_static_pack_tests::{
+ download_verify_pack, load_vcard_personal_portfolio_cached, serve_pack,
+};
+
+#[tokio::test(flavor = "current_thread")]
+async fn client_downloads_verifies_served_by_server() {
+ // `pack` to run both server and client on
+ let pack_archived = load_vcard_personal_portfolio_cached();
+
+ // all paths from `pack` used for test
+ let pack_paths = pack_archived
+ .files_by_path
+ .keys()
+ .map(|pack_path_archived| &**pack_path_archived)
+ .collect::>();
+
+ // makes client wait for server to become ready and turns it off when completed
+ let (bind_ready_sender, bind_ready_receiver) = oneshot::channel::();
+ let (shutdown_sender, shutdown_receiver) = oneshot::channel::<()>();
+
+ // server
+ let server = serve_pack(
+ pack_archived,
+ None,
+ Some(bind_ready_sender),
+ shutdown_receiver,
+ );
+
+ // client
+ let download_verifier = async move {
+ let bind = bind_ready_receiver.await?;
+
+ download_verify_pack(pack_archived, &pack_paths, bind).await?;
+
+ shutdown_sender.send(()).unwrap();
+ Ok(())
+ };
+
+ // wait for all
+ try_join!(server, download_verifier).unwrap();
+}
diff --git a/tests/tests/serve_custom.rs b/tests/tests/serve_custom.rs
new file mode 100644
index 0000000..3ba6799
--- /dev/null
+++ b/tests/tests/serve_custom.rs
@@ -0,0 +1,241 @@
+#![feature(async_closure)]
+
+use anyhow::{anyhow, Error};
+use futures::{channel::oneshot, try_join, Future};
+use http::{header, HeaderMap, HeaderName, HeaderValue, StatusCode};
+use reqwest::{get, Client, ClientBuilder, Url};
+use std::net::SocketAddr;
+use test_case::test_case;
+use web_static_pack_tests::serve_pack;
+
+struct FileMock;
+impl web_static_pack::file::File for FileMock {
+ fn content(&self) -> &[u8] {
+ b"content-identity-is-the-longest-and-least-preferred-option"
+ }
+ fn content_gzip(&self) -> Option<&[u8]> {
+ // "content-gzip"
+ Some(b"\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\x03\x4b\xce\xcf\x2b\x49\xcd\x2b\xd1\x4d\xaf\xca\x2c\x00\x00\x98\x02\x99\x74\x0c\x00\x00\x00")
+ }
+ fn content_brotli(&self) -> Option<&[u8]> {
+ // "content-brotli"
+ Some(b"\x8b\x06\x80\x63\x6f\x6e\x74\x65\x6e\x74\x2d\x62\x72\x6f\x74\x6c\x69\x03")
+ }
+
+ fn content_type(&self) -> HeaderValue {
+ HeaderValue::from_static("text/plain; charset=utf-8")
+ }
+ fn etag(&self) -> HeaderValue {
+ HeaderValue::from_static("\"etagvalue\"")
+ }
+ fn cache_control(&self) -> web_static_pack::cache_control::CacheControl {
+ web_static_pack::cache_control::CacheControl::MaxCache
+ }
+}
+struct PackMock;
+impl web_static_pack::pack::Pack for PackMock {
+ type File = FileMock;
+
+ fn get_file_by_path(
+ &self,
+ path: &str,
+ ) -> Option<&Self::File> {
+ match path {
+ "/present" => Some(&FileMock),
+ _ => None,
+ }
+ }
+}
+
+async fn run_with_server>, E: FnOnce(Url) -> F>(
+ executor: E, // async fn executor(base_url: Url) -> Result<(), Error> { ... }
+) -> Result<(), Error> {
+ let (bind_ready_sender, bind_ready_receiver) = oneshot::channel::();
+ let (shutdown_sender, shutdown_receiver) = oneshot::channel::<()>();
+
+ let server = serve_pack(&PackMock, None, Some(bind_ready_sender), shutdown_receiver);
+
+ let verifier = async move {
+ let bind = bind_ready_receiver.await?;
+ let base_url = Url::parse(&format!("http://{bind}/"))?;
+
+ executor(base_url).await?;
+
+ shutdown_sender.send(()).unwrap();
+ Ok(())
+ };
+
+ try_join!(server, verifier)?;
+
+ Ok(())
+}
+
+fn header_as_string(
+ headers: &HeaderMap,
+ name: HeaderName,
+) -> &str {
+ headers
+ .get(&name)
+ .ok_or_else(|| anyhow!("missing header {name}"))
+ .unwrap()
+ .to_str()
+ .unwrap()
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn responds_to_typical_request() {
+ run_with_server(async move |base_url: Url| {
+ let response = get(base_url.join("/present")?).await?.error_for_status()?;
+ let headers = response.headers();
+
+ assert_eq!(
+ header_as_string(headers, header::CONTENT_TYPE),
+ "text/plain; charset=utf-8"
+ );
+ assert_eq!(
+ header_as_string(headers, header::ETAG), // line break
+ "\"etagvalue\""
+ );
+ assert_eq!(
+ header_as_string(headers, header::CACHE_CONTROL), // line break
+ "max-age=31536000, immutable"
+ );
+
+ // reqwest strips content-length and content-encoding when using encoding
+ let body = response.bytes().await?;
+ assert_eq!(&*body, b"content-brotli");
+
+ Ok(())
+ })
+ .await
+ .unwrap();
+}
+
+#[test_case(true, true, b"content-brotli"; "all enabled, brotli is the shortest")]
+#[test_case(false, true, b"content-gzip"; "no brotli, but gzip")]
+#[test_case(false, false, b"content-identity-is-the-longest-and-least-preferred-option"; "nothing, should receive identity")]
+#[tokio::test(flavor = "current_thread")]
+async fn responds_with_other_encodings(
+ brotli: bool,
+ gzip: bool,
+ expected: &[u8],
+) {
+ run_with_server(async move |base_url: Url| {
+ let response = ClientBuilder::new()
+ .brotli(brotli)
+ .gzip(gzip)
+ .build()?
+ .get(base_url.join("/present")?)
+ .send()
+ .await?
+ .error_for_status()?;
+
+ // reqwest strips content-length and content-encoding when using encoding
+ let body = response.bytes().await?;
+ assert_eq!(&*body, expected);
+
+ Ok(())
+ })
+ .await
+ .unwrap();
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn resolves_no_body_for_head_request() {
+ run_with_server(async move |base_url: Url| {
+ let response = Client::new()
+ .head(base_url.join("/present")?)
+ .send()
+ .await?
+ .error_for_status()?;
+ let headers = response.headers();
+
+ // all headers should be there
+ assert_eq!(
+ header_as_string(headers, header::CONTENT_TYPE),
+ "text/plain; charset=utf-8"
+ );
+ assert_eq!(
+ header_as_string(headers, header::ETAG), // line break
+ "\"etagvalue\""
+ );
+ assert_eq!(
+ header_as_string(headers, header::CACHE_CONTROL), // line break
+ "max-age=31536000, immutable"
+ );
+
+ // reqwest strips content-length and content-encoding when using encoding
+ let body = response.bytes().await?;
+ assert_eq!(&*body, b"");
+
+ Ok(())
+ })
+ .await
+ .unwrap();
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn resolves_not_modified_for_matching_etag() {
+ run_with_server(async move |base_url: Url| {
+ let response = Client::new()
+ .get(base_url.join("/present")?)
+ .header(header::IF_NONE_MATCH, "\"etagvalue\"")
+ .send()
+ .await?;
+ let headers = response.headers();
+
+ assert_eq!(response.status(), StatusCode::NOT_MODIFIED);
+
+ // `ETag` should be resent, others should be missing.
+ assert_eq!(
+ header_as_string(headers, header::ETAG), // line break
+ "\"etagvalue\""
+ );
+ assert!(headers.get(header::CONTENT_TYPE).is_none());
+
+ // of course no body
+ let body = response.bytes().await?;
+ assert_eq!(&*body, b"");
+
+ Ok(())
+ })
+ .await
+ .unwrap();
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn resolves_error_for_invalid_method() {
+ run_with_server(async move |base_url: Url| {
+ let response = Client::new()
+ .post(base_url.join("/present")?)
+ .send()
+ .await?;
+
+ assert_eq!(response.status(), StatusCode::METHOD_NOT_ALLOWED);
+
+ // no body for flattening responder
+ let body = response.bytes().await?;
+ assert_eq!(&*body, b"");
+
+ Ok(())
+ })
+ .await
+ .unwrap();
+}
+
+#[tokio::test(flavor = "current_thread")]
+async fn resolves_error_for_file_not_found() {
+ run_with_server(async move |base_url: Url| {
+ let response = Client::new().get(base_url.join("/missing")?).send().await?;
+
+ assert_eq!(response.status(), StatusCode::NOT_FOUND);
+
+ // no body for flattening responder
+ let body = response.bytes().await?;
+ assert_eq!(&*body, b"");
+
+ Ok(())
+ })
+ .await
+ .unwrap();
+}