## Points clés à retenir

- **Isolation des tests** : chaque test doit s'exécuter indépendamment, afin que les modifications dans un test n'affectent pas les autres ;
- **Fixtures dans pytest** : les fixtures fournissent des instances ou des configurations fraîches pour chaque test, garantissant l'isolation des tests ;
- **Conception de classes** : définir des classes avec des attributs et des méthodes pour organiser le comportement et l'état ;
- **Assertions dans les tests** : utiliser les instructions `assert` pour vérifier que votre code se comporte comme prévu, par exemple en vérifiant la longueur d'une liste, le contenu d'un élément ou la valeur de retour d'une méthode.


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

Vous acquerrez des compétences pratiques dans les modules et les imports de Python pour une gestion efficace du code. Maîtrisez des techniques avancées de gestion des erreurs pour des applications plus fiables, automatisez les opérations de fichiers avec la gestion des fichiers, et apprenez des stratégies de test robustes avec Pytest et Unittest pour assurer l'intégrité de votre code.

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 : L'Assurance Qualité du Panier

Points clés à retenir

Solution