Valider le service de bout en bout

Un service peut démarrer sans erreur et pourtant fournir une réponse incorrecte : un total peut manquer, une route peut répondre avec le mauvais statut, ou une donnée absente peut interrompre le traitement. Vous allez vérifier le parcours complet du suivi des commandes, depuis la lecture du fichier jusqu’à la réponse HTTP, puis tester le cas où ce fichier est indisponible.

Cette validation s’effectue dans le projet déjà construit : `src/calculer-total.js` fournit le calcul, `data/commandes.json` contient les commandes, et `src/serveur.js` sert la route. Vous avez déjà appris à lire ces données et à ajouter un total calculé dans la réponse ; ici, vous contrôlez que ces étapes fonctionnent ensemble et que les erreurs restent maîtrisées.

1. Contrôler le démarrage et le calcul

Placez-vous à la racine du projet, là où se trouvent `package.json` et le dossier `data`, puis lancez le serveur. Le script ci-dessous conserve l’affichage des totaux au démarrage, la route `GET /commandes`, la réponse 404 et la réponse 500. La lecture faite au démarrage sert à vérifier les données dans le terminal ; la route relit le fichier lorsqu’une requête arrive.

import http from 'node:http';
import { readFile, writeFile } from 'node:fs/promises';
import { calculerTotal } from './calculer-total.js';

const cheminCommandes = 'data/commandes.json';
const port = 3000;

async function chargerCommandes() {
  const contenu = await readFile(cheminCommandes, 'utf8');
  return JSON.parse(contenu);
}

async function verifierCommandesAuDemarrage() {
  try {
    const commandes = await chargerCommandes();

    for (const commande of commandes) {
      const total = calculerTotal(commande.montants);
      console.log(`${commande.reference} : ${total.toFixed(2)} €`);
    }
  } catch (erreur) {
    console.error('Impossible de charger les commandes au démarrage :', erreur.message);
  }
}

const serveur = http.createServer(async (requete, reponse) => {
  if (requete.method !== 'GET' || requete.url !== '/commandes') {
    reponse.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
    reponse.end('Route introuvable');
    return;
  }

  try {
    const commandes = await chargerCommandes();
    const commandesAvecTotal = commandes.map((commande) => ({
      ...commande,
      total: calculerTotal(commande.montants)
    }));

    reponse.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
    reponse.end(JSON.stringify(commandesAvecTotal));
  } catch (erreur) {
    console.error('Erreur lors de la lecture des commandes :', erreur.message);
    reponse.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
    reponse.end('Impossible de charger les commandes');
  }
});

await verifierCommandesAuDemarrage();
serveur.listen(port, () => {
  console.log(`Serveur disponible sur http://localhost:${port}`);
});

Exemple de démarrage :
CMD-001 : 18.50 €
Serveur disponible sur http://localhost:3000
Les références et les montants affichés dépendent du contenu de data/commandes.json.

Enregistrez ce contenu dans `src/serveur.js`. Il suppose que `src/calculer-total.js` exporte déjà `calculerTotal` et que chaque commande possède une référence et un tableau `montants` numérique, conformément aux données préparées dans les leçons précédentes. L’import de `writeFile` est conservé pour les opérations d’écriture déjà abordées ; cette version du serveur n’écrit pas dans le fichier.

2. Tester les réponses HTTP

Dans un premier terminal, démarrez le serveur. Laissez-le actif pendant les tests : le message indiquant l’adresse confirme qu’il écoute sur le port choisi. Dans un second terminal, demandez la route avec `curl`, un outil en ligne de commande qui affiche la réponse HTTP.

node src/serveur.js

# Dans un second terminal :
curl -i http://localhost:3000/commandes
curl -i http://localhost:3000/inconnue

Pour `/commandes`, vérifiez le statut `200`, le type de contenu JSON et le tableau renvoyé. Chaque objet doit conserver ses champs, notamment `reference`, `statut` et `montants`, et contenir aussi `total`. Comparez les totaux à ceux affichés au démarrage : ils doivent correspondre aux sommes des montants de chaque commande.

[
  {
    "reference": "CMD-001",
    "statut": "En préparation",
    "montants": [12.5, 6],
    "total": 18.5
  }
]

La commande adressée à `/inconnue` doit recevoir le statut `404` et le message `Route introuvable`. Ce contrôle confirme que le serveur ne renvoie pas les commandes pour une URL qui ne correspond pas à la route prévue. Vous pouvez aussi vérifier une méthode différente avec `curl -i -X POST http://localhost:3000/commandes` : la route ne traite que les requêtes GET.

3. Vérifier le scénario de fichier absent

Pour simuler une erreur sans supprimer les données, arrêtez le serveur avec `Ctrl+C`, renommez temporairement le fichier, puis relancez le script. Le serveur doit encore démarrer ; le terminal signale l’échec de lecture au démarrage. La route reste testable et doit répondre avec un statut `500`, plutôt que de faire terminer le processus ou d’exposer les détails techniques de l’erreur au client.

mv data/commandes.json data/commandes-test.json
node src/serveur.js

# Dans un second terminal :
curl -i http://localhost:3000/commandes

# Après avoir arrêté le serveur avec Ctrl+C :
mv data/commandes-test.json data/commandes.json

La requête GET /commandes renvoie HTTP 500 et le texte :
Impossible de charger les commandes
Le terminal contient le détail technique de l’erreur. Une fois le test terminé, le fichier d’origine est restauré.

À retenir

• Lancez `node src/serveur.js` depuis la racine et vérifiez les totaux affichés au démarrage.
• Testez `GET /commandes` et contrôlez le statut 200, le JSON et le total de chaque commande.
• Vérifiez qu’une URL non prévue reçoit une réponse 404.
• Simulez l’absence du fichier : le serveur doit rester actif et la route renvoyer 500, tandis que le détail de l’erreur reste dans le terminal.
• Restaurez le fichier JSON et refaites un test nominal.