# fichier : calculatrice.py
class Calculatrice:
    def additionner(self, a, b):
        return a + b

    def diviser(self, a, b):
        if b == 0:
            raise ZeroDivisionError("Division par zero")
        return a / b


class ServiceMeteo:
    def __init__(self, client_api):
        self.client_api = client_api

    def temperature_actuelle(self, ville):
        reponse = self.client_api.get(f"/meteo/{ville}")
        return reponse["temperature"]

# fichier : test_calculatrice.py
import pytest
from calculatrice import Calculatrice, ServiceMeteo

# Test simple : fonction qui commence par test_
def test_addition():
    calc = Calculatrice()
    assert calc.additionner(2, 3) == 5

def test_division_par_zero_leve_exception():
    calc = Calculatrice()
    with pytest.raises(ZeroDivisionError):
        calc.diviser(10, 0)

# Parametrize : executer le meme test avec plusieurs jeux de donnees
@pytest.mark.parametrize("a, b, attendu", [
    (2, 3, 5),
    (-1, 1, 0),
    (0, 0, 0),
    (100, -50, 50),
])
def test_addition_parametree(a, b, attendu):
    calc = Calculatrice()
    assert calc.additionner(a, b) == attendu

# Fixture : prepare des donnees/objets reutilisables entre tests
@pytest.fixture
def calculatrice():
    print("Setup de la fixture")
    calc = Calculatrice()
    yield calc                      # tout ce qui suit yield = teardown
    print("Teardown de la fixture")

def test_avec_fixture(calculatrice):
    assert calculatrice.additionner(1, 1) == 2

# Fixtures avec portee (scope) : "function" (defaut), "module", "session"
@pytest.fixture(scope="module")
def connexion_bdd_partagee():
    print("Connexion BDD ouverte une seule fois pour tout le module")
    connexion = {"active": True}
    yield connexion
    print("Connexion BDD fermee")

# Fixtures parametrees
@pytest.fixture(params=[1, 2, 3])
def nombre(request):
    return request.param

def test_carre_positif(nombre):
    assert nombre ** 2 >= 0

# --- Mocks : isoler le code teste de ses dependances externes ---
from unittest.mock import Mock, MagicMock, patch

def test_service_meteo_avec_mock():
    client_mock = Mock()
    client_mock.get.return_value = {"temperature": 22}

    service = ServiceMeteo(client_mock)
    resultat = service.temperature_actuelle("Paris")

    assert resultat == 22
    client_mock.get.assert_called_once_with("/meteo/Paris")   # verifie l'appel

# patch : remplacer temporairement un objet/fonction pendant le test
def appeler_api_externe():
    import requests
    return requests.get("https://api.example.com/data").json()

@patch("requests.get")
def test_appel_api_mocke(mock_get):
    mock_get.return_value.json.return_value = {"cle": "valeur"}
    resultat = appeler_api_externe()
    assert resultat == {"cle": "valeur"}

# patch en tant que context manager
def test_avec_patch_context():
    with patch("requests.get") as mock_get:
        mock_get.return_value.status_code = 200
        import requests
        reponse = requests.get("https://example.com")
        assert reponse.status_code == 200

# side_effect : simuler des comportements dynamiques (exceptions, sequences de valeurs)
def test_side_effect():
    mock = Mock(side_effect=[1, 2, ValueError("erreur simulee")])
    assert mock() == 1
    assert mock() == 2
    with pytest.raises(ValueError):
        mock()

# Marqueurs : ignorer, isoler ou categoriser des tests
@pytest.mark.skip(reason="Fonctionnalite pas encore implementee")
def test_fonctionnalite_future():
    ...

@pytest.mark.slow
def test_traitement_lourd():
    ...

pytest                              # lance tous les tests du dossier courant
pytest test_calculatrice.py         # un fichier precis
pytest -k "addition"                 # filtre par nom de test
pytest -v                             # mode verbeux
pytest --cov=mon_package              # couverture de code (necessite pytest-cov)
pytest -m "not slow"                   # exclut les tests marques "slow"