import unittest
import io
import sys


def _dynamic_test(test_case, cond, ok, fail):
    if cond:
        test_case._testMethodName = ok
        test_case.assertTrue(True)
    else:
        test_case._testMethodName = fail
        test_case.fail(fail)


def normalize(text):
    return " ".join(text.split())


class TestUserCode(unittest.TestCase):

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

        cond = "from bs4 import BeautifulSoup" in src

        _dynamic_test(
            self,
            cond,
            "Imported BeautifulSoup.",
            "BeautifulSoup not imported."
        )

    def test_soup_exists(self):
        import user_code
        cond = hasattr(user_code, "soup")

        _dynamic_test(self, cond, "`soup` exists.", "`soup` missing.")

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

        try:
            cond = isinstance(user_code.soup, BeautifulSoup)
        except:
            cond = False

        _dynamic_test(self, cond, "`soup` ok.", "`soup` invalid.")

    def test_html_string(self):
        import user_code

        try:
            cond = isinstance(user_code.html, str)
        except:
            cond = False

        _dynamic_test(self, cond, "`html` ok.", "`html` invalid.")

    def test_output(self):
        import user_code
        import importlib

        buf = io.StringIO()
        sys.stdout = buf
        importlib.reload(user_code)
        sys.stdout = sys.__stdout__

        lines = buf.getvalue().splitlines()

        if len(lines) < 2:
            _dynamic_test(self, False, "", "Not enough output.")
            return

        # First line: p attributes
        printed_attrs = lines[0].strip()
        expected_attrs = str(user_code.soup.p.attrs)

        if printed_attrs != expected_attrs:
            _dynamic_test(self, False, "", "Wrong p attrs.")
            return

        # Remaining lines: UL text
        printed_ul_block = " ".join([ln.strip() for ln in lines[1:] if ln.strip()])
        printed_ul_norm = normalize(printed_ul_block)

        expected_ul_norm = normalize(user_code.soup.ul.get_text())

        if printed_ul_norm != expected_ul_norm:
            _dynamic_test(self, False, "", "Wrong UL text.")
            return

        _dynamic_test(self, True, "Correct output.", "")


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 : Attributs

Solution