Prompts pour le développement et l'assistance au code

J'ai un bug dans le code suivant. Aide-moi à l'identifier et à le corriger.

Langage / environnement : [ex. Python 3.10 / Node.js 18 / Java 11]
Framework : [si applicable]

Comportement observé :
[Décrivez précisément ce qui se passe, incluant le message d'erreur complet]

Comportement attendu :
[Décrivez ce qui devrait se passer]

Message d'erreur (stacktrace complète) :
--- début du message d'erreur ---
[Collez le message d'erreur ici]
--- fin du message d'erreur ---

Code problématique (langage : [ex. Python / JavaScript / Java]) :
--- début du code ---
[Collez votre code ici]
--- fin du code ---

Données d'entrée utilisées lors du bug :
[Exemple d'entrée qui reproduit le problème]

Explique la cause du bug, puis propose le code corrigé avec commentaires.

J'ai un bug dans le code suivant. Comportement observé : KeyError au moment
du traitement du 3ème élément. Comportement attendu : traitement de tous
les éléments sans erreur.

Message d'erreur :
KeyError: 'email'
  File "traitement.py", line 12, in traiter_utilisateurs
    emails.append(utilisateur['email'])

Code :
def traiter_utilisateurs(utilisateurs):
    emails = []
    for utilisateur in utilisateurs:
        emails.append(utilisateur['email'])
    return emails

Données d'entrée :
[{"nom": "Alice", "email": "alice@ex.com"},
 {"nom": "Bob", "email": "bob@ex.com"},
 {"nom": "Charlie"}]  # pas de clé 'email'

Voici un message d'erreur que je ne comprends pas. Explique :
1. Ce que signifie cette erreur
2. Les causes les plus fréquentes
3. Les solutions à essayer dans l'ordre

Contexte : [langage, framework, ce que vous essayiez de faire]

Erreur : [message d'erreur complet]

Refactorise le code suivant en améliorant sa qualité selon ces axes :

Objectifs de refactorisation :
☐ Lisibilité : nommage, structure, commentaires
☐ Performance : optimiser les parties lentes identifiées
☐ Maintenabilité : réduire la duplication, découper les fonctions longues
☐ Robustesse : améliorer la gestion d'erreurs et les cas limites
☐ Modernisation : utiliser les fonctionnalités de [langage vX.X]
☐ Respect des conventions : [PEP 8 / Airbnb style guide / Google style]

Contraintes :
- Ne pas modifier le comportement externe (mêmes entrées → mêmes sorties)
- [Autres contraintes spécifiques à votre projet]

Code original (langage : [ex. Python / TypeScript / Java]) :
--- début du code ---
[Collez votre code ici]
--- fin du code ---

Fournis : (1) le code refactorisé, (2) la liste des changements effectués
et leur justification, (3) les points d'attention éventuels.

# AVANT : code soumis à la refactorisation
def f(l):
    r = []
    for i in range(len(l)):
        if l[i] > 0:
            r.append(l[i] * 2)
    return r

# APRÈS : code refactorisé par l'IA
def doubler_valeurs_positives(valeurs: list[float]) -> list[float]:
    """Retourne le double des valeurs strictement positives de la liste."""
    return [valeur * 2 for valeur in valeurs if valeur > 0]

// AVANT
function getUser(id, callback) {
  fetch('/api/users/' + id)
    .then(function(res) { return res.json(); })
    .then(function(data) { callback(null, data); })
    .catch(function(err) { callback(err); });
}

// APRÈS
async function getUser(id) {
  const response = await fetch(`/api/users/${id}`);
  if (!response.ok) throw new Error(`HTTP ${response.status}`);
  return response.json();
}

Écris des tests unitaires complets pour le code suivant.

Framework de test : [ex. pytest / unittest / Jest / JUnit / RSpec]
Langage et version : [ex. Python 3.11 / JavaScript ES2022]

Code à tester (langage : [ex. Python / JavaScript / Java]) :
--- début du code ---
[Votre code ici]
--- fin du code ---

Couverture attendue :
- Cas nominaux : comportement normal avec entrées valides
- Cas limites : valeurs extrêmes, listes vides, chaînes vides, zéro
- Cas d'erreur : entrées invalides, exceptions attendues
- [Cas spécifiques à votre logique métier]

Conventions :
- Nommage des tests : [ex. test_should_X_when_Y / describe/it]
- Utiliser des mocks pour : [ex. appels HTTP / base de données / filesystem]
- Structurer avec : [ex. Arrange-Act-Assert / Given-When-Then]

# Code testé : lire_utilisateurs_actifs(chemin_fichier)
import pytest
from pathlib import Path
from mon_module import lire_utilisateurs_actifs

class TestLireUtilisateursActifs:

    def test_retourne_utilisateurs_actifs_uniquement(self, tmp_path):
        # Arrange
        csv_file = tmp_path / "users.csv"
        csv_file.write_text("nom,statut\nAlice,actif\nBob,inactif\nCarol,actif")

        # Act
        result = lire_utilisateurs_actifs(str(csv_file))

        # Assert
        assert len(result) == 2
        assert all(u["statut"] == "actif" for u in result)

    def test_retourne_liste_vide_si_aucun_actif(self, tmp_path):
        csv_file = tmp_path / "users.csv"
        csv_file.write_text("nom,statut\nBob,inactif")
        assert lire_utilisateurs_actifs(str(csv_file)) == []

    def test_leve_erreur_si_fichier_inexistant(self):
        with pytest.raises(FileNotFoundError):
            lire_utilisateurs_actifs("/chemin/inexistant.csv")

// Code testé : fetchAvecTimeout(url, options, timeoutMs)
import { fetchAvecTimeout } from './api';

global.fetch = jest.fn();

describe('fetchAvecTimeout', () => {
  afterEach(() => jest.clearAllMocks());

  it('retourne les données JSON pour une réponse 200', async () => {
    fetch.mockResolvedValue({
      ok: true,
      json: async () => ({ id: 1, nom: 'Alice' }),
    });
    const data = await fetchAvecTimeout('https://api.example.com/users/1');
    expect(data).toEqual({ id: 1, nom: 'Alice' });
  });

  it('lève une erreur pour une réponse 404', async () => {
    fetch.mockResolvedValue({ ok: false, status: 404, statusText: 'Not Found' });
    await expect(fetchAvecTimeout('https://api.example.com/users/99'))
      .rejects.toThrow('Erreur HTTP 404');
  });
});