import unittest
import importlib
import io
import re
import inspect
from contextlib import redirect_stdout
import user_code


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)


def strip_comments_from_source(module):
    try:
        source = inspect.getsource(module)
        lines = source.split('\\n')
        cleaned = []
        for line in lines:
            stripped = line.rstrip()
            if stripped.startswith('#'):
                continue
            if '#' in line:
                line = line.split('#')[0]
            if line.strip():
                cleaned.append(line)
        return '\\n'.join(cleaned)
    except Exception:
        return ""


class TestSimpleRestocking(unittest.TestCase):

    def normalize_text(self, text):
        text = text.lower()
        text = re.sub(r'\s+', ' ', text)
        return text.strip()

    # --- STATE TESTS ---

    def test_bread_stock(self):
        importlib.reload(user_code)
        item = user_code.inventory["Bread"]
        _dynamic_test(
            self,
            item[0] == 50,
            "Bread stock is updated to 50",
            f"Expected Bread stock 50, got {item[0]}"
        )

    def test_eggs_stock(self):
        importlib.reload(user_code)
        item = user_code.inventory["Eggs"]
        _dynamic_test(
            self,
            item[0] == 200,
            "Eggs stock is updated to 200",
            f"Expected Eggs stock 200, got {item[0]}"
        )

    def test_milk_stock(self):
        importlib.reload(user_code)
        item = user_code.inventory["Milk"]
        _dynamic_test(
            self,
            item[0] == 100,
            "Milk stock is updated to 100",
            f"Expected Milk stock 100, got {item[0]}"
        )

    def test_apples_stock(self):
        importlib.reload(user_code)
        item = user_code.inventory["Apples"]
        _dynamic_test(
            self,
            item[0] == 60,
            "Apples stock is updated to 60",
            f"Expected Apples stock 60, got {item[0]}"
        )

    # --- OUTPUT TESTS ---

    def test_output_contains_required_lines(self):
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        out = self.normalize_text(f.getvalue())

        _dynamic_test(
            self,
            "restocking started" in out,
            "Output includes 'Restocking started'",
            "Expected 'Restocking started' in output"
        )

        for name in ["bread", "eggs", "milk", "apples"]:
            _dynamic_test(
                self,
                f"restocking {name}" in out,
                f"Output includes 'Restocking {name.title()}'",
                f"Expected 'Restocking {name.title()}' in output"
            )

        _dynamic_test(
            self,
            "restocking completed" in out,
            "Output includes 'Restocking completed'",
            "Expected 'Restocking completed' in output"
        )

    # --- LOOP CHECKS ---

    def test_for_loop_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            re.search(r'\\bfor\\b', source) is not None,
            "'for' loop is used",
            "Expected a 'for' loop"
        )

    def test_while_loop_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            re.search(r'\\bwhile\\b', source) is not None,
            "'while' loop is used",
            "Expected a 'while' loop"
        )


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


test_main.py

Python ist eine hochentwickelte, interpretierte, universell einsetzbare Programmiersprache. Im Gegensatz zu Sprachen wie HTML, CSS und JavaScript, die hauptsächlich in der Webentwicklung verwendet werden, zeichnet sich Python durch Vielseitigkeit in verschiedenen Bereichen wie Softwareentwicklung, Data Science und Back-End-Entwicklung aus. Dieser Kurs führt Sie durch die grundlegenden Konzepte von Python und vermittelt Ihnen die Fähigkeiten, eigene Funktionen zu erstellen.

In diesem Abschnitt werden die Grundlagen von Python behandelt.
Sie lernen Ihre Arbeitsumgebung kennen, führen einfache mathematische Operationen durch und geben Ihre Ergebnisse aus.

In diesem Abschnitt erfahren Sie, wie Sie Elemente wie Zahlen und Text im Computerspeicher speichern und sie anhand ihres Namens abrufen können. Zusätzlich erhalten Sie eine Einführung in die Textmanipulation in Python.

In diesem Abschnitt werden Sie den booleschen Datentyp untersuchen und erfahren, wie er verwendet wird,
um Programme zu entwickeln, die auf bestimmte Bedingungen reagieren.

In diesem Abschnitt werden Sie weiterhin Datentypen kennenlernen und erfahren,
wie verschiedene Attribute in einer einzigen Variablen mithilfe von Listen, Tupeln und Dictionaries organisiert werden können.

In diesem Abschnitt lernen Sie, wie man Schleifen in Python erstellt — eine grundlegende Fähigkeit
zum Iterieren durch Listen, Tupel und Dictionaries.

Zum Abschluss dieses Einführungskurses werden einige eingebaute Funktionen untersucht und anschließend eigene entwickelt.

Herausforderung: Automatisierung der Lagerbestandskontrolle

Lösung

Herausforderung: Automatisierung der Lagerbestandskontrolle

Lösung