This is a paragraph.
+#Content
Content
+ +# Perfect for conditional rendering +def render_items(items, show_header=True): + fragment = Fragment() + + if show_header: + fragment.append(H2("Items List")) + + for item in items: + fragment.append(Paragraph(item)) + + return fragment + +# Use in parent element +page = Div( + render_items(["Item 1", "Item 2", "Item 3"], show_header=True) +) +# Output:Item 1
Item 2
Item 3
Content
+ # Instead of:Content
{normal_text}
") + def test_to_json_simple_element(self): + """Test serialization of a simple element to JSON.""" + import json + element = HTMLElement("Hello", tag="div", id="test", class_name="container") + json_str = element.to_json() + self.assertIsInstance(json_str, str) + data = json.loads(json_str) + self.assertEqual(data["tag"], "div") + self.assertEqual(data["text"], "Hello") + self.assertEqual(data["attributes"]["id"], "test") + + def test_to_json_with_indent(self): + """Test JSON serialization with indentation.""" + element = HTMLElement("Test", tag="p") + json_str = element.to_json(indent=2) + self.assertIn("\n", json_str) # Should have newlines with indentation + self.assertIn(" ", json_str) # Should have spaces for indentation + + def test_to_json_nested_elements(self): + """Test serialization of nested elements to JSON.""" + parent = HTMLElement(tag="div", id="parent") + child1 = HTMLElement("Child 1", tag="span") + child2 = HTMLElement("Child 2", tag="span") + parent.append(child1, child2) + + json_str = parent.to_json() + import json + data = json.loads(json_str) + + self.assertEqual(len(data["children"]), 2) + self.assertEqual(data["children"][0]["text"], "Child 1") + self.assertEqual(data["children"][1]["text"], "Child 2") + + def test_from_dict_simple_element(self): + """Test reconstruction of a simple element from dictionary.""" + data = { + "tag": "div", + "self_closing": False, + "attributes": {"id": "test", "class": "container"}, + "text": "Hello", + "children": [] + } + element = HTMLElement.from_dict(data) + + self.assertEqual(element.tag, "div") + self.assertEqual(element.text, "Hello") + self.assertEqual(element.get_attribute("id"), "test") + self.assertEqual(element.get_attribute("class"), "container") + self.assertFalse(element.self_closing) + + def test_from_dict_self_closing_element(self): + """Test reconstruction of a self-closing element.""" + data = { + "tag": "br", + "self_closing": True, + "attributes": {}, + "text": "", + "children": [] + } + element = HTMLElement.from_dict(data) + + self.assertEqual(element.tag, "br") + self.assertTrue(element.self_closing) + self.assertEqual(str(element), "World
Content
") + self.assertNotIn("Single child
") + + def test_fragment_multiple_children(self): + """Test Fragment with multiple children.""" + fragment = Fragment( + H1("Header"), + Paragraph("Paragraph 1"), + Paragraph("Paragraph 2"), + Span("Inline text") + ) + + rendered = str(fragment) + expected = "Paragraph 1
Paragraph 2
Inline text" + self.assertEqual(rendered, expected) + + def test_fragment_nested_elements(self): + """Test Fragment with nested HTML elements.""" + fragment = Fragment( + Div( + H1("Title"), + Paragraph("Content") + ), + Section( + Paragraph("More content") + ) + ) + + rendered = str(fragment) + self.assertIn("Middle
", rendered) + + def test_fragment_pretty_printing(self): + """Test Fragment with pretty printing enabled.""" + fragment = Fragment( + Div( + H1("Title"), + Paragraph("Content") + ), + Paragraph("Outside") + ) + + pretty = fragment.render(pretty=True) + self.assertIn("\n", pretty) + self.assertIn(" ", pretty) # Should have indentation from children + self.assertNotIn("Added content
") + + def test_fragment_prepend_children(self): + """Test prepending children to Fragment.""" + fragment = Fragment( + Paragraph("Second") + ) + fragment.prepend(H1("First")) + + rendered = str(fragment) + self.assertEqual(rendered, "Second
") + + def test_fragment_clear(self): + """Test clearing Fragment children.""" + fragment = Fragment( + H1("Title"), + Paragraph("Content") + ) + + fragment.clear() + rendered = str(fragment) + self.assertEqual(rendered, "") + + def test_fragment_count_children(self): + """Test counting Fragment children.""" + fragment = Fragment( + H1("Title"), + Paragraph("Content 1"), + Paragraph("Content 2") + ) + + self.assertEqual(fragment.count_children(), 3) + + def test_fragment_nested_in_div(self): + """Test using Fragment inside another element.""" + fragment = Fragment( + H1("Title"), + Paragraph("Content") + ) + + div = Div() + div.append(fragment) + + rendered = str(div) + # Fragment should render its children without wrapper + self.assertEqual(rendered, "Content
Main content
", rendered) + self.assertNotIn("Footer", rendered) + + def test_fragment_list_composition(self): + """Test using Fragment to compose lists of elements.""" + items = ["Item 1", "Item 2", "Item 3"] + + fragment = Fragment() + for item in items: + fragment.append(Paragraph(item)) + + rendered = str(fragment) + self.assertEqual(rendered, "Item 1
Item 2
Item 3
") + + def test_fragment_with_attributes(self): + """Test that Fragment ignores attributes (doesn't render them).""" + fragment = Fragment( + H1("Title"), + id="ignored", + class_name="also-ignored" + ) + + rendered = str(fragment) + self.assertNotIn("id", rendered) + self.assertNotIn("class", rendered) + self.assertEqual(rendered, "Content 1
", rendered) + + def test_fragment_inheritance(self): + """Test that Fragment inherits from HTMLElement.""" + fragment = Fragment() + self.assertIsInstance(fragment, HTMLElement) + + def test_fragment_context_manager(self): + """Test using Fragment as a context manager.""" + with Fragment() as fragment: + fragment.append(H1("Title")) + fragment.append(Paragraph("Content")) + + rendered = str(fragment) + self.assertEqual(rendered, "Content
") + + def test_fragment_clone(self): + """Test cloning a Fragment.""" + original = Fragment( + H1("Title"), + Paragraph("Content") + ) + + cloned = original.clone() + + self.assertEqual(str(original), str(cloned)) + self.assertIsNot(original, cloned) + self.assertIsNot(original.children[0], cloned.children[0]) + + def test_fragment_filter(self): + """Test filtering Fragment children.""" + fragment = Fragment( + H1("Title"), + Paragraph("Para 1"), + Span("Span"), + Paragraph("Para 2") + ) + + paragraphs = list(fragment.filter(lambda x: x.tag == "p")) + self.assertEqual(len(paragraphs), 2) + + def test_fragment_find_by_attribute(self): + """Test finding elements by attribute in Fragment.""" + fragment = Fragment( + H1("Title", id="header"), + Paragraph("Content", id="main"), + Span("Text") + ) + + found = fragment.find_by_attribute("id", "main") + self.assertIsNotNone(found) + self.assertEqual(found.tag, "p") + + def test_fragment_compact_vs_pretty(self): + """Test compact vs pretty rendering of Fragment.""" + fragment = Fragment( + Div( + H1("Title"), + Paragraph("Content") + ) + ) + + # Compact + compact = fragment.render(pretty=False) + self.assertNotIn("\n", compact) + self.assertEqual(compact, "Content
This is the hidden content