import unittest
import re
import io
import sys


# Helper from the Codefinity checklist
def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)


class TestUserCode(unittest.TestCase):

    # ------------ Test import ------------
    def test_urlopen_imported(self):
        with open("user_code.py", "r") as f:
            src = f.read()

        condition = "from urllib.request import urlopen" in src

        _dynamic_test(
            self,
            condition,
            "The `urlopen` function is imported correctly.",
            "Expected `urlopen` to be imported from `urllib.request`."
        )

    # ------------ Test declared variables ------------
    def test_variables_declared(self):
        import user_code

        condition = (
            hasattr(user_code, "url") and
            hasattr(user_code, "page") and
            hasattr(user_code, "web_page")
        )

        _dynamic_test(
            self,
            condition,
            "Variables `url`, `page`, and `web_page` are declared.",
            "Expected variables `url`, `page`, and `web_page` to all be declared."
        )

    # ------------ Test read + decode ------------
    def test_read_and_decode_used(self):
        with open("user_code.py", "r") as f:
            src = f.read()

        condition = (
            ".read()" in src and
            ('.decode("utf-8")' in src or ".decode('utf-8')" in src)
        )

        _dynamic_test(
            self,
            condition,
            "The page content is read and decoded correctly.",
            "Expected use of `.read()` and `.decode('utf-8')`."
        )

    # ------------ Test web_page type ------------
    def test_web_page_is_string(self):
        import user_code
        try:
            value = user_code.web_page
            condition = isinstance(value, str)
            fail_msg = f"`web_page` should be a string but is `{type(value).__name__}`."
        except AttributeError:
            condition = False
            fail_msg = "`web_page` is not declared."

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

    # ------------ Test printed output ------------
    def test_printed_counts_are_correct(self):
        import user_code
        import importlib

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

        importlib.reload(user_code)

        sys.stdout = sys.__stdout__

        output = captured.getvalue().strip().splitlines()

        if len(output) < 2:
            _dynamic_test(
                self,
                False,
                "",
                "Expected two printed lines: number of `<div>` and number of `<img>`."
            )
            return

        # Interpret printed values
        try:
            div_printed = int(output[0])
            img_printed = int(output[1])
        except:
            _dynamic_test(
                self,
                False,
                "",
                "Printed values must be integers."
            )
            return

        # Expected values
        expected_div = user_code.web_page.count("<div")
        expected_img = user_code.web_page.count("<img")

        condition = (div_printed == expected_div and img_printed == expected_img)

        _dynamic_test(
            self,
            condition,
            "Correct counts for `<div>` and `<img>` are printed.",
            f"Expected divs={expected_div}, imgs={expected_img}, "
            f"but got divs={div_printed}, imgs={img_printed}."
        )


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


test_code.py

Erlernen Sie das automatische Extrahieren wertvoller Daten von Websites. Beherrschen Sie Techniken zur effizienten Informationsgewinnung, um fundierte Analysen durchzuführen, datenbasierte Entscheidungen zu treffen und neue Erkenntnisse aus der Fülle an Online-Informationen zu gewinnen.

Untersuchung der Struktur einer HTML-Datei, effizientes Laden sowie Erwerb praktischer Fähigkeiten im Umgang mit den enthaltenen Daten.

Grundlagen von Beautiful Soup zur Extraktion von Daten aus HTML-Dokumenten. Struktur von HTML analysieren, gezielte Elemente ansprechen und mit deren Kindelementen arbeiten, um eine solide Basis im Web Scraping zu schaffen.

Beherrschen Sie den Umgang mit Elementattributen und -inhalten unter Verwendung von Beautiful Soup. Erwerben Sie die Fähigkeiten, spezifische Informationen zu extrahieren, Elemente anhand von Attributwerten zu suchen und fortgeschrittene Techniken zur effizienten Analyse und Auswertung von HTML-Daten anzuwenden.

Herausforderung: Anzahl der Bilder Zählen

Lösung

Herausforderung: Anzahl der Bilder Zählen

Lösung