## Key Points to Remember

- **Test isolation**: each test should run independently, so changes in one test do not affect others;
- **Fixtures in pytest**: fixtures provide fresh instances or setup for each test, ensuring test isolation;
- **Class design**: define classes with attributes and methods to organize behavior and state;
- **Assertions in tests**: use `assert` statements to check if your code behaves as expected, such as verifying list length, item content, or method return values.


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

A deep dive into advanced structural programming concepts in Python, focusing on robust file handling, error management, concurrency, asynchronous programming and testing.

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

Key Points to Remember

Oplossing