improvement: attempted to make static_asset test more robust, doesn't…

… work yet

app/src/asset.rs

@@ -7,6 +7,21 @@ use pavex::request::path::PathParams;
 use rust_embed_for_web::{EmbedableFile, RustEmbed};
 use std::borrow::Cow;
 
+// trait for asset retrieval
+pub trait AssetProvider {
+    fn get_asset(&self, filename: &str) -> Option<Vec<u8>>;
+}
+
+// default provider for real assets
+pub struct EmbeddedAssetProvider;
+
+// implement the AssetProvider trait for EmbeddedAssetProvider
+impl AssetProvider for crate::asset::EmbeddedAssetProvider {
+    fn get_asset(&self, filename: &str) -> Option<Vec<u8>> {
+        Asset::get(filename).map(|f| f.data())
+    }
+}
+
 // struct type to represent a static asset from the file system
 #[derive(RustEmbed)]
 #[folder = "../static"]
@@ -29,7 +44,7 @@ pub struct StaticAsset {
 
 // methods for the StaticAsset type
 impl StaticAsset {
-    pub fn build_static_asset(params: PathParams<GetFilenameParams>) -> Self {
+    pub fn build_static_asset(params: PathParams<GetFilenameParams>, provider: &dyn crate::asset::AssetProvider) -> Option<Self> {
         let file = params.0.filename;
 
         let name = Cow::Owned(file.to_string());
@@ -39,18 +54,18 @@ impl StaticAsset {
             .map(Cow::Borrowed)
             .unwrap_or_else(|| Cow::Borrowed("application/octet-stream"));
 
-        let data = Asset::get(file.as_ref()).unwrap().data();
+        let data = provider.get_asset(file.as_ref())?;
 
         let mime_header = match HeaderValue::from_str(&mime_type) {
             Ok(hv) => hv,
             Err(_) => HeaderValue::from_static("application/octet-stream"),
         };
 
-        Self {
+        Some(Self {
             name,
             data,
             mime_type,
             mime_header,
-        }
+        })
     }
 }

app/src/blueprint.rs

@@ -14,6 +14,6 @@ pub fn blueprint() -> Blueprint {
     bp.singleton(f!(crate::template::compile_templates));
     bp.transient(f!(crate::asset::StaticAsset::build_static_asset))
         .clone_if_necessary();
-
+    bp.request_scoped(f!(<crate::asset::EmbeddedAssetProvider as crate::asset::AssetProvider>::get_asset));
     bp
 }

app/src/routes/static_assets.rs

@@ -24,5 +24,11 @@ impl TypedBody for StaticAsset {
 
 // handler function which responds with a 200 OK and the CSS styles
 pub fn get(asset: StaticAsset) -> Response {
-    Response::ok().set_typed_body(asset)
+
+    match asset {
+        Some(a) => Response::ok().set_typed_body(a),
+        None => Response::no_content().set_typed_body("No content")
+    }
+
+
 }

server/tests/integration/helpers.rs

@@ -72,6 +72,14 @@ impl TestApi {
 
 /// Convenient methods for calling the API under test.
 impl TestApi {
+    pub async fn get_index(&self) -> reqwest::Response {
+        self.api_client
+            .get(format!("{}/", &self.api_address))
+            .send()
+            .await
+            .expect("Failed to execute request.")
+    }
+
     pub async fn get_ping(&self) -> reqwest::Response {
         self.api_client
             .get(format!("{}/api/ping", &self.api_address))
@@ -80,6 +88,14 @@ impl TestApi {
             .expect("Failed to execute request.")
     }
 
+    pub async fn get_static_asset(&self, filename: &str) -> reqwest::Response {
+        self.api_client
+            .get(format!("{}/static/{}", &self.api_address, filename))
+            .send()
+            .await
+            .expect("Failed to execute request.")
+    }
+
     pub async fn post_storage_create(&self, query: &str) -> reqwest::Response {
         self.api_client
             .post(format!(

server/tests/integration/index.rs

@@ -0,0 +1,31 @@
+// tests/integration/index.rs
+
+use crate::helpers::TestApi;
+use pavex::http::StatusCode;
+
+#[tokio::test]
+async fn index_works() {
+    let api = TestApi::spawn().await;
+
+    let response = api.get_index().await;
+
+    assert_eq!(response.status(), StatusCode::OK);
+
+    let response_header = response
+        .headers()
+        .get("Content-Type")
+        .expect("Expected Content-Type header in response.");
+
+    let response_header_str = response_header.to_str().expect("Unable to get the response header text");
+
+    let expected_header_str = "text/html; charset=utf-8";
+
+    assert_eq!(response_header_str, expected_header_str);
+
+    let response_body = response.text().await.unwrap();
+
+    assert!(
+        response_body.contains("<!DOCTYPE html>"),
+        "Response body does not contain expected HTML."
+    )
+}

server/tests/integration/main.rs

@@ -1,3 +1,5 @@
 mod helpers;
+mod index;
 mod ping;
+mod static_asset;
 mod storage_create;

server/tests/integration/static_asset.rs

@@ -0,0 +1,27 @@
+// tests/integration/static_asset.rs
+
+use crate::helpers::TestApi;
+use pavex::http::StatusCode;
+
+#[tokio::test]
+async fn static_asset_works() {
+    let api = TestApi::spawn().await;
+
+    let filename = "test.css";
+
+    let response = api.get_static_asset(filename).await;
+
+    assert_eq!(response.status(), StatusCode::OK);
+
+    let response_header = response
+        .headers()
+        .get("Content-Type")
+        .expect("Expected Content-Type header in response.");
+
+    let response_header_str = response_header.to_str().expect("Unable to get the response header text");
+
+    let expected_header_str = "text/css; charset=utf-8";
+
+    assert_eq!(response_header_str, expected_header_str);
+
+}