## Vigtige punkter at huske

- **Testisolering**: hver test skal køre uafhængigt, så ændringer i én test ikke påvirker andre;
- **Fixtures i pytest**: fixtures leverer friske instanser eller opsætning til hver test og sikrer testisolering;
- **Klassedesign**: definér klasser med attributter og metoder for at organisere adfærd og tilstand;
- **Assertioner i tests**: brug `assert`-udsagn til at kontrollere, om din kode opfører sig som forventet, f.eks. ved at verificere længden af en liste, indholdet af et element eller returværdier fra metoder.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import importlib
import sys
import types
import builtins

class TestTask(unittest.TestCase):
    def setUp(self):
        # Dynamically create user_code module from task code
        import os
        self.module_name = "user_code"
        self.test_filename = "user_code.py"
        with open(self.test_filename, "r") as f:
            self.code = f.read()
        # Remove module if already loaded
        if self.module_name in sys.modules:
            del sys.modules[self.module_name]

    def test_add_item(self):
        # Setup
        ns = {}
        exec(self.code, ns)
        ShoppingCart = ns.get('ShoppingCart', None)
        _dynamic_test(
            self,
            ShoppingCart is not None,
            "ShoppingCart class is defined",
            "ShoppingCart class is not defined"
        )
        cart = ShoppingCart()
        cart.add_item('Laptop', 1200.0)
        items = getattr(cart, 'items', None)
        _dynamic_test(
            self,
            isinstance(items, list),
            "ShoppingCart.items is a list",
            f"ShoppingCart.items is not a list: {items}"
        )
        _dynamic_test(
            self,
            len(items) == 1,
            "Cart has 1 item after adding",
            f"Cart should have 1 item, has {len(items)}"
        )
        _dynamic_test(
            self,
            isinstance(items[0], dict) and items[0].get("name") == 'Laptop',
            "Cart item name is 'Laptop'",
            f"Expected item name 'Laptop', got: {items[0].get('name') if isinstance(items[0], dict) else items[0]}"
        )

    def test_total_price(self):
        ns = {}
        exec(self.code, ns)
        ShoppingCart = ns.get('ShoppingCart', None)
        cart = ShoppingCart()
        cart.add_item('Book', 20.0)
        cart.add_item('Coffee', 5.0)
        get_total = getattr(cart, 'get_total', None)
        _dynamic_test(
            self,
            callable(get_total),
            "get_total method is callable",
            "get_total method is not callable"
        )
        total = cart.get_total()
        _dynamic_test(
            self,
            total == 25.0,
            "Cart total is correct after adding two items (20.0 + 5.0)",
            f"Expected total 25.0, got {total}"
        )

    def test_empty_cart_total(self):
        ns = {}
        exec(self.code, ns)
        ShoppingCart = ns.get('ShoppingCart', None)
        cart = ShoppingCart()
        get_total = getattr(cart, 'get_total', None)
        _dynamic_test(
            self,
            callable(get_total),
            "get_total method is callable",
            "get_total method is not callable"
        )
        total = cart.get_total()
        _dynamic_test(
            self,
            total == 0,
            "Cart total is 0 for empty cart",
            f"Expected total 0, got {total}"
        )

    def test_cart_fixture_isolation(self):
        # Test that a new ShoppingCart instance is returned each time from the fixture
        ns = {}
        exec(self.code, ns)
        ShoppingCart = ns.get('ShoppingCart', None)
        cart_fixture = ns.get('cart', None)
        _dynamic_test(
            self,
            callable(cart_fixture),
            "cart fixture is defined and callable",
            "cart fixture is not defined/callable"
        )
        cart1 = cart_fixture()
        cart2 = cart_fixture()
        cart1.add_item('A', 1)
        _dynamic_test(
            self,
            len(cart2.items) == 0,
            "Each cart fixture call returns a fresh cart (test isolation)",
            f"cart2.items should be empty, got: {cart2.items}"
        )

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 normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

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


test_main.py

Du vil opnå praktiske færdigheder i Pythons moduler og imports for effektiv kodestyring. Behersk avancerede teknikker til fejlhåndtering for mere pålidelige applikationer, automatiser filoperationer med filhåndtering, og lær robuste teststrategier med Pytest og Unittest for at sikre din kodes integritet.

Master Python's exception system for robust error handling and debugging.

Explore advanced techniques for file operations and resource management using context managers.

Compare and apply Python's multithreading and multiprocessing modules for concurrent programming.

Master asynchronous programming in Python using the asyncio library for scalable I/O-bound applications.

Explore how to write, organize, and run tests using Python's unittest and pytest frameworks.

Challenge: The Cart Quality Assurance

Vigtige punkter at huske

Løsning