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

Leer waardevolle gegevens automatisch van websites te extraheren. Beheers technieken om efficiënt informatie te verzamelen, waardoor diepgaande analyses, datagedreven besluitvorming en het ontsluiten van nieuwe inzichten uit de enorme hoeveelheid online informatie mogelijk worden.

Ontdek de structuur van een HTML-bestand, leer hoe u het efficiënt kunt laden en verkrijg praktische vaardigheden in het werken met de gegevens die het bevat.

Verken de basisprincipes van Beautiful Soup voor het extraheren van gegevens uit HTML-documenten. Leer hoe u de structuur van HTML navigeert, specifieke elementen benadert en werkt met hun kindelementen om een solide basis te leggen in webscraping.

Beheers het werken met elementattributen en inhoud met Beautiful Soup. Ontwikkel vaardigheden om specifieke informatie te extraheren, elementen te zoeken op attribuutwaarden en geavanceerde technieken toe te passen voor het efficiënt parseren en analyseren van HTML-data.

Uitdaging: Itereren over Lijsten

Oplossing