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

Apprenez à extraire automatiquement des données précieuses à partir de sites web. Maîtrisez des techniques pour collecter efficacement des informations, permettant d’effectuer des analyses approfondies, de prendre des décisions fondées sur les données et de découvrir de nouveaux aperçus à partir de l’immense volume d’informations en ligne.

Explorer la structure d’un fichier HTML, apprendre à le charger efficacement et acquérir des compétences pratiques dans la manipulation des données qu’il contient.

Découvrez les principes fondamentaux de Beautiful Soup pour extraire des données à partir de documents HTML. Apprenez à naviguer dans la structure du HTML, à accéder à des éléments spécifiques et à manipuler leurs éléments enfants afin de consolider les bases du web scraping.

Maîtrise de la gestion des attributs d’élément et du contenu avec Beautiful Soup. Acquisition des compétences pour extraire des informations spécifiques, rechercher des éléments par valeurs d’attributs et utiliser des techniques avancées pour analyser et parser efficacement des données HTML.

Défi : Itération sur les Listes

Solution

Défi : Itération sur les Listes

Solution