import unittest
import io
import sys


def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


class TestUserCode(unittest.TestCase):

    def test_beautifulsoup_imported(self):
        with open("user_code.py", "r") as f:
            src = f.read()

        condition = "from bs4 import BeautifulSoup" in src

        _dynamic_test(
            self,
            condition,
            "The `BeautifulSoup` class is imported.",
            "Expected import: `from bs4 import BeautifulSoup`."
        )

    def test_soup_declared(self):
        import user_code
        condition = hasattr(user_code, "soup")

        _dynamic_test(
            self,
            condition,
            "The `soup` variable is declared.",
            "`soup` variable is missing."
        )

    def test_soup_is_beautifulsoup(self):
        import user_code
        from bs4 import BeautifulSoup

        try:
            s = user_code.soup
            condition = isinstance(s, BeautifulSoup)
            fail_msg = "`soup` must be a BeautifulSoup object."
        except Exception:
            condition = False
            fail_msg = "`soup` is missing or invalid."

        _dynamic_test(
            self,
            condition,
            "`soup` is a valid BeautifulSoup instance.",
            fail_msg
        )

    def test_html_is_string(self):
        import user_code

        try:
            html_val = user_code.html
            condition = isinstance(html_val, str)
            fail_msg = f"`html` must be a string but is `{type(html_val).__name__}`."
        except:
            condition = False
            fail_msg = "`html` variable missing."

        _dynamic_test(
            self,
            condition,
            "`html` contains decoded HTML.",
            fail_msg
        )

    def test_ul_children_printed(self):
        import user_code
        import importlib

        # Capture stdout
        captured = io.StringIO()
        sys.stdout = captured

        importlib.reload(user_code)

        sys.stdout = sys.__stdout__

        # real printed output
        printed = captured.getvalue().splitlines()
        printed_clean = [line for line in printed if line.strip()]

        # expected from BeautifulSoup
        expected_clean = []
        for child in user_code.soup.ul.children:
            text = str(child).strip()
            if text:
                expected_clean.append(str(child))

        # Length check
        if len(printed_clean) != len(expected_clean):
            _dynamic_test(
                self,
                False,
                "",
                f"Expected {len(expected_clean)} printed UL elements, got {len(printed_clean)}."
            )
            return

        # Compare each printed line
        for p, e in zip(printed_clean, expected_clean):
            if p.strip() != e.strip():
                _dynamic_test(
                    self,
                    False,
                    "",
                    f"Expected `{e}`, but got `{p}`."
                )
                return

        _dynamic_test(
            self,
            True,
            "All `ul` children were printed correctly.",
            ""
        )


if __name__ == "__main__":
    unittest.main()


test_code.py

Aprenda a extraer datos valiosos de sitios web de forma automática. Domine técnicas para recopilar información de manera eficiente, permitiendo realizar análisis en profundidad, tomar decisiones basadas en datos y descubrir nuevos conocimientos a partir del vasto océano de información en línea.

Explora la estructura de un archivo HTML, aprende a cargarlo de manera eficiente y adquiere habilidades prácticas para trabajar con los datos que contiene.

Explora los conceptos básicos de Beautiful Soup para extraer datos de documentos HTML. Aprende a navegar por la estructura de HTML, acceder a elementos específicos y trabajar con sus elementos secundarios para construir una base sólida en web scraping.

Domine el trabajo con atributos y contenido de elementos utilizando Beautiful Soup. Adquiera las habilidades para extraer información específica, buscar elementos por valores de atributos y emplear técnicas avanzadas para analizar y procesar datos HTML de manera eficiente.

Desafío: Iteración Sobre Listas

Solución

Desafío: Iteración Sobre Listas

Solución