🎨 Protege el uso de render en PrepareMarkup

tests/html_pm.rs

@@ -1,70 +1,69 @@
 use pagetop::prelude::*;
 
-#[pagetop::test]
-async fn prepare_markup_render_none_is_empty_string() {
-    assert_eq!(PrepareMarkup::None.render().as_str(), "");
+/// Componente mínimo para probar `PrepareMarkup` pasando por el ciclo real
+/// de renderizado de componentes (`ComponentRender`).
+#[derive(AutoDefault)]
+struct TestPrepareComponent {
+    pm: PrepareMarkup,
+}
+
+impl Component for TestPrepareComponent {
+    fn new() -> Self {
+        Self {
+            pm: PrepareMarkup::None,
+        }
+    }
+
+    fn prepare_component(&self, _cx: &mut Context) -> PrepareMarkup {
+        self.pm.clone()
+    }
+}
+
+impl TestPrepareComponent {
+    fn render_pm(pm: PrepareMarkup) -> String {
+        let mut c = TestPrepareComponent { pm };
+        c.render(&mut Context::default()).into_string()
+    }
 }
 
 #[pagetop::test]
-async fn prepare_markup_render_escaped_escapes_html_and_ampersands() {
+async fn prepare_markup_none_is_empty_string() {
+    assert_eq!(PrepareMarkup::None.into_string(), "");
+}
+
+#[pagetop::test]
+async fn prepare_markup_escaped_escapes_html_and_ampersands() {
     let pm = PrepareMarkup::Escaped("<b>& \" ' </b>".to_string());
-    assert_eq!(pm.render().as_str(), "&lt;b&gt;&amp; &quot; ' &lt;/b&gt;");
+    assert_eq!(pm.into_string(), "&lt;b&gt;&amp; &quot; ' &lt;/b&gt;");
 }
 
 #[pagetop::test]
-async fn prepare_markup_render_raw_is_inserted_verbatim() {
+async fn prepare_markup_raw_is_inserted_verbatim() {
     let pm = PrepareMarkup::Raw("<b>bold</b><script>1<2</script>".to_string());
-    assert_eq!(pm.render().as_str(), "<b>bold</b><script>1<2</script>");
+    assert_eq!(pm.into_string(), "<b>bold</b><script>1<2</script>");
 }
 
 #[pagetop::test]
-async fn prepare_markup_render_with_keeps_structure() {
+async fn prepare_markup_with_keeps_structure() {
     let pm = PrepareMarkup::With(html! {
         h2 { "Sample title" }
-        p { "This is a paragraph." }
+        p  { "This is a paragraph." }
     });
     assert_eq!(
-        pm.render().as_str(),
+        pm.into_string(),
         "<h2>Sample title</h2><p>This is a paragraph.</p>"
     );
 }
 
-#[pagetop::test]
-async fn prepare_markup_does_not_double_escape_when_wrapped_in_html_macro() {
-    // Escaped: dentro de `html!` no debe volver a escaparse.
-    let escaped = PrepareMarkup::Escaped("<i>x</i>".into());
-    let wrapped_escaped = html! { div { (escaped.render()) } };
-    assert_eq!(
-        wrapped_escaped.into_string(),
-        "<div>&lt;i&gt;x&lt;/i&gt;</div>"
-    );
-
-    // Raw: tampoco debe escaparse al integrarlo.
-    let raw = PrepareMarkup::Raw("<i>x</i>".into());
-    let wrapped_raw = html! { div { (raw.render()) } };
-    assert_eq!(wrapped_raw.into_string(), "<div><i>x</i></div>");
-
-    // With: debe incrustar el Markup tal cual.
-    let with = PrepareMarkup::With(html! { span.title { "ok" } });
-    let wrapped_with = html! { div { (with.render()) } };
-    assert_eq!(
-        wrapped_with.into_string(),
-        "<div><span class=\"title\">ok</span></div>"
-    );
-}
-
 #[pagetop::test]
 async fn prepare_markup_unicode_is_preserved() {
     // Texto con acentos y emojis debe conservarse (salvo el escape HTML de signos).
     let esc = PrepareMarkup::Escaped("Hello, tomorrow coffee ☕ & donuts!".into());
-    assert_eq!(
-        esc.render().as_str(),
-        "Hello, tomorrow coffee ☕ &amp; donuts!"
-    );
+    assert_eq!(esc.into_string(), "Hello, tomorrow coffee ☕ &amp; donuts!");
 
     // Raw debe pasar íntegro.
     let raw = PrepareMarkup::Raw("Title — section © 2025".into());
-    assert_eq!(raw.render().as_str(), "Title — section © 2025");
+    assert_eq!(raw.into_string(), "Title — section © 2025");
 }
 
 #[pagetop::test]
@@ -88,7 +87,36 @@ async fn prepare_markup_is_empty_semantics() {
 }
 
 #[pagetop::test]
-async fn prepare_markup_equivalence_between_render_and_inline_in_html_macro() {
+async fn prepare_markup_does_not_double_escape_when_markup_is_reinjected_in_html_macro() {
+    let mut cx = Context::default();
+
+    // Escaped: dentro de `html!` no debe volver a escaparse.
+    let mut comp = TestPrepareComponent {
+        pm: PrepareMarkup::Escaped("<i>x</i>".into()),
+    };
+    let markup = comp.render(&mut cx); // Markup
+    let wrapped_escaped = html! { div { (markup) } }.into_string();
+    assert_eq!(wrapped_escaped, "<div>&lt;i&gt;x&lt;/i&gt;</div>");
+
+    // Raw: tampoco debe escaparse al integrarlo.
+    let mut comp = TestPrepareComponent {
+        pm: PrepareMarkup::Raw("<i>x</i>".into()),
+    };
+    let markup = comp.render(&mut cx);
+    let wrapped_raw = html! { div { (markup) } }.into_string();
+    assert_eq!(wrapped_raw, "<div><i>x</i></div>");
+
+    // With: debe incrustar el Markup tal cual.
+    let mut comp = TestPrepareComponent {
+        pm: PrepareMarkup::With(html! { span.title { "ok" } }),
+    };
+    let markup = comp.render(&mut cx);
+    let wrapped_with = html! { div { (markup) } }.into_string();
+    assert_eq!(wrapped_with, "<div><span class=\"title\">ok</span></div>");
+}
+
+#[pagetop::test]
+async fn prepare_markup_equivalence_between_component_render_and_markup_reinjected_in_html_macro() {
     let cases = [
         PrepareMarkup::None,
         PrepareMarkup::Escaped("<b>x</b>".into()),
@@ -97,12 +125,20 @@ async fn prepare_markup_equivalence_between_render_and_inline_in_html_macro() {
     ];
 
     for pm in cases {
-        let rendered = pm.render();
-        let in_macro = html! { (rendered) }.into_string();
+        // Vía 1: renderizamos y obtenemos directamente el String.
+        let via_component = TestPrepareComponent::render_pm(pm.clone());
+
+        // Vía 2: renderizamos, reinyectamos el Markup en `html!` y volvemos a obtener String.
+        let via_macro = {
+            let mut cx = Context::default();
+            let mut comp = TestPrepareComponent { pm };
+            let markup = comp.render(&mut cx);
+            html! { (markup) }.into_string()
+        };
+
         assert_eq!(
-            rendered.as_str(),
-            in_macro,
-            "The output of Render and (pm) inside html! must match"
+            via_component, via_macro,
+            "The output of component render and (Markup) inside html! must match"
         );
     }
 }