exchange hyper features From<Template> for hyper::Body with TryFrom

valkum · djc · commit 4a7068d33317 · 2023-03-03T10:31:34.000+01:00
The previous implementation hid the error returned by render,
which made it impossible for callers to react to rendering errors.

While having a simple way to call into would be nice, there is not
way to have both implementations without adding any manual
specialization. Thus, the From impl is replaced by the TryFrom impl.
diff --git a/askama_derive/src/generator.rs b/askama_derive/src/generator.rs
@@ -450,24 +450,22 @@ impl<'a> Generator<'a> {
         buf.writeln("}")?;
         buf.writeln("}")?;
 
-        // From<Template> for hyper::Body
+        // TryFrom<Template> for hyper::Body
         buf.writeln(&format!(
             "{} {{",
             quote!(
-                impl #impl_generics ::core::convert::From<&#ident #orig_ty_generics>
+                impl #impl_generics ::core::convert::TryFrom<&#ident #orig_ty_generics>
                 for ::askama_hyper::hyper::Body
                 #where_clause
             )
         ))?;
+        buf.writeln("type Error = ::askama::Error;")?;
         buf.writeln("#[inline]")?;
         buf.writeln(&format!(
             "{} {{",
-            quote!(fn from(value: &#ident #orig_ty_generics) -> Self)
+            quote!(fn try_from(value: &#ident #orig_ty_generics) -> Result<Self, Self::Error>)
         ))?;
-        buf.writeln(
-            "::askama::Template::render(value).ok().map(Into::into)\
-            .unwrap_or_else(|| ::askama_hyper::hyper::Body::empty())",
-        )?;
+        buf.writeln("::askama::Template::render(value).map(Into::into)")?;
         buf.writeln("}")?;
         buf.writeln("}")
     }
diff --git a/askama_hyper/tests/basic.rs b/askama_hyper/tests/basic.rs
@@ -22,16 +22,16 @@ async fn hello_handler(req: Request<Body>) -> Result<Response<Body>, Infallible>
     Ok(template.into())
 }
 
-async fn body_handler(req: Request<Body>) -> Result<Response<Body>, Infallible> {
+async fn try_body_handler(req: Request<Body>) -> Result<Response<Body>, Infallible> {
     let name = req.param("name").unwrap();
     let template = &HelloTemplate { name: &name };
-    Ok(Builder::new().body(template.into()).unwrap())
+    Ok(Builder::new().body(template.try_into().unwrap()).unwrap())
 }
 
 fn router() -> Router<Body, Infallible> {
     Router::builder()
         .get("/hello/:name", hello_handler)
-        .get("/body/:name", body_handler)
+        .get("/try_body/:name", try_body_handler)
         .build()
         .unwrap()
 }
@@ -43,15 +43,12 @@ async fn test_hyper() {
     let server = Server::bind(&addr).serve(service);
     let local_addr = server.local_addr();
 
-    let (tx1, rx1) = tokio::sync::oneshot::channel::<()>();
-    let (tx2, rx2) = tokio::sync::oneshot::channel::<()>();
+    let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel::<()>();
     let serve = async move {
-        let server = server.with_graceful_shutdown(async {
-            rx1.await.expect("Could not await signal to stop");
-            rx2.await.expect("Could not await signal to stop");
-        });
+        let server = server.with_graceful_shutdown(async { while rx.recv().await.is_some() {} });
         server.await.expect("Could not serve");
     };
+    let hello_tx = tx.clone();
     let hello_query = async move {
         let uri = format!("http://{local_addr}/hello/world")
             .parse()
@@ -73,32 +70,24 @@ async fn test_hyper() {
         let body = std::str::from_utf8(&body).expect("Body was not UTF-8");
         assert_eq!(body, "Hello, world!");
 
-        tx1.send(()).unwrap();
+        hello_tx.send(()).unwrap();
     };
 
-    let body_query = async move {
-        let uri = format!("http://{local_addr}/hello/world")
+    let try_body_query = async move {
+        let uri = format!("http://{local_addr}/try_body/world")
             .parse()
             .expect("Could not format URI");
         let client = Client::new();
 
         let res = client.get(uri).await.expect("Could not query client");
         assert_eq!(res.status(), hyper::StatusCode::OK);
 
-        let content_type = res
-            .headers()
-            .get("content-type")
-            .expect("Response did not contain content-type header")
-            .to_str()
-            .expect("Content-type was not a UTF-8 string");
-        assert_eq!(content_type, mime::TEXT_HTML_UTF_8.to_string());
-
         let body = to_bytes(res).await.expect("No body returned");
         let body = std::str::from_utf8(&body).expect("Body was not UTF-8");
         assert_eq!(body, "Hello, world!");
 
-        tx2.send(()).unwrap();
+        tx.send(()).unwrap();
     };
 
-    tokio::join!(serve, body_query, hello_query);
+    tokio::join!(serve, try_body_query, hello_query);
 }
