Une solution C++ complète pour la gestion commerciale : catalogue, caisse, stock et reporting.
💻 Installation | 🧪 Tests | 📄 Licence
- 1. Contexte et objectifs
- 2. Aperçu du projet
- 3. Architecture du projet
- 4. Modèle de données et règles de gestion
- 5. Fonctionnalités détaillées
- 6. Spécifications techniques
- 7. Installation et utilisation en local
- 8. Tests unitaires
- 9. Auteurs et remerciements
- 10. Licence
Dans un petit commerce de détail (supérette, épicerie, boutique spécialisée), la gestion quotidienne repose souvent sur des outils manuels ou des tableurs peu adaptés.
Les difficultés rencontrées sont nombreuses :
- Erreurs de stock : ruptures non détectées, surstockage, invendus oubliés.
- Absence d’historique : impossible de savoir quel client a acheté quoi, ni de mesurer le chiffre d’affaires précis.
- Lenteur du passage en caisse : les prix sont calculés mentalement, les remises sont appliquées de manière approximative.
- Manque de visibilité : aucune alerte automatique sur les produits qui se périment ou qui sont en promotion.
Ces problèmes freinent la croissance du commerce et empêchent une gestion professionnelle de l’activité.
Le projet Mini-ERP a pour objectif de fournir un logiciel de point de vente et de gestion de stock complet, fonctionnant sur un simple ordinateur, sans connexion internet permanente.
Il doit permettre à un commerçant de :
- Tenir un catalogue de produits (standards, périssables avec gestion des dates, en promotion).
- Enregistrer des ventes comme sur une caisse enregistreuse, avec calcul automatique des prix, des remises et de la TVA.
- Gérer une liste de clients avec un taux de fidélité personnalisé.
- Suivre le stock en temps réel et être alerté avant les ruptures.
- Générer des rapports de chiffre d’affaires, de produits les plus vendus et d’état du stock.
- Exporter les données au format CSV pour une analyse externe.
L’application se veut simple d’utilisation, robuste (aucune donnée saisie n’est perdue, le stock ne devient jamais négatif), et évolutive grâce à une architecture modulaire en couches.
Le projet fournit un ensemble complet d’outils opérationnels :
- Deux interfaces utilisateur : console (menus interactifs) et web (interface graphique accessible par navigateur).
- Un moteur métier en C++17 respectant les principes de la programmation orientée objet (encapsulation, héritage, polymorphisme).
- Une persistance sur fichiers texte (CSV) garantissant la sauvegarde et la restauration des données entre deux exécutions.
- Des données de démonstration contextualisées au Sénégal (produits locaux, noms sénégalais).
- Des scripts de compilation (Makefile pour Linux/MSYS2, script batch pour Windows).
- Une suite de tests unitaires validant les règles métier.
- Une documentation complète : README, rapport académique (4‑6 pages), diagramme UML des entités.
Ce système s’adresse à plusieurs profils :
- Commerçants et gérants de petits points de vente souhaitant informatiser leur gestion.
- Étudiants en informatique devant réaliser un projet complet illustrant la programmation orientée objet en C++.
- Enseignants et évaluateurs cherchant un exemple concret d’application métier bien structurée et documentée.
Le Mini‑ERP se présente sous deux formes complémentaires, accessibles depuis le même exécutable :
| Mode | Lancement | Description |
|---|---|---|
| Console | Choix 1 au démarrage |
Menus interactifs dans le terminal. Adapté aux machines légères, ne nécessite aucun navigateur. |
| Web | Choix 2 au démarrage |
Serveur HTTP intégré qui expose une interface graphique accessible sur http://localhost:8080. L’application ouvre automatiquement le navigateur par défaut. |
-
Catalogue produits
Ajout, modification, suppression et recherche de produits. Trois types gérés : standard, périssable (braderie automatique), en promotion. -
Fidélité client
Création et gestion des clients avec un taux de remise personnalisé. Historique complet des achats par client. -
Caisse enregistreuse
Panier dynamique avec ajout / suppression de lignes, calcul automatique des totaux HT, TVA, TTC, remise globale sur le montant et remise fidélité. Validation ou annulation de la vente avec restitution du stock. -
Gestion du stock
État des stocks en temps réel, alertes visuelles (sous le seuil, rupture), réapprovisionnement avec traçabilité, historique des mouvements (entrées / sorties). -
Rapports et exports
Chiffre d’affaires par période, top des produits les plus vendus, état du stock valorisé. Export de chaque rapport au format CSV. -
Tableau de bord
Vue synthétique des indicateurs clés : CA du jour / mois, nombre de produits en alerte, valeur totale du stock, dernières ventes et derniers mouvements. -
Double interface
La console offre une expérience fluide avec menus colorés, cadres ASCII et saisies robustes. L’interface web propose un design sombre professionnel, une navigation par onglets et un panier interactif.
Le projet est organisé en couches strictement séparées pour garantir la maintenabilité et la testabilité.
Chaque dossier correspond à une responsabilité unique.
mini-erp/
├── README.md
├── Makefile
├── run.bat
├── .gitignore
│
├── config/
│ ├── settings.cfg # Paramètres métier (TVA, braderie, paliers…)
│ └── logger.conf # Configuration du journal applicatif
│
├── data/
│ ├── produits.dat # Catalogue (CSV avec type polymorphique)
│ ├── clients.dat # Liste des clients
│ ├── ventes.dat # Historique des ventes (format multi‑lignes)
│ ├── mouvements_stock.dat # Mouvements d’entrée/sortie
│ └── .gitkeep
│
├── src/
│ ├── main.cpp # Point d’entrée, choix du mode, sauvegarde
│ │
│ ├── utils/ # Utilitaires transverses (aucune dépendance métier)
│ │ ├── Exceptions.h/.cpp
│ │ ├── DateUtils.h/.cpp
│ │ ├── StringUtils.h/.cpp
│ │ ├── Config.h/.cpp
│ │ ├── Logger.h/.cpp
│ │ └── Validation.h/.cpp
│ │
│ ├── model/ # Entités métier (POO, encapsulation, héritage)
│ │ ├── Produit.h/.cpp # Classe de base abstraite
│ │ ├── ProduitStandard.h/.cpp # Prix fixe
│ │ ├── ProduitPerissable.h/.cpp # Date de péremption + braderie
│ │ ├── ProduitEnPromotion.h/.cpp # Remise en pourcentage
│ │ ├── Client.h/.cpp
│ │ ├── LigneDeVente.h/.cpp
│ │ ├── Vente.h/.cpp # Facture avec remises figées
│ │ ├── MouvementStock.h/.cpp
│ │ └── Magasin.h/.cpp # Agrégat racine
│ │
│ ├── service/ # Logique métier et règles de gestion
│ │ ├── ServiceMouvements.h/.cpp
│ │ ├── GestionnaireStock.h/.cpp
│ │ ├── GestionnaireProduits.h/.cpp
│ │ ├── GestionnaireClients.h/.cpp
│ │ ├── GestionnaireRemises.h/.cpp
│ │ ├── GestionnaireVentes.h/.cpp
│ │ └── RapportService.h/.cpp
│ │
│ ├── persistence/ # Sérialisation / désérialisation sur fichiers
│ │ ├── Serializer.h
│ │ ├── ProduitSerializer.h/.cpp
│ │ ├── ClientSerializer.h/.cpp
│ │ ├── VenteSerializer.h/.cpp
│ │ ├── MouvementSerializer.h/.cpp
│ │ └── DataManager.h/.cpp
│ │
│ ├── ui/ # Interface utilisateur console (menus)
│ │ ├── ConsoleUtils.h/.cpp
│ │ ├── MenuPrincipal.h/.cpp
│ │ ├── MenuProduits.h/.cpp
│ │ ├── MenuClients.h/.cpp
│ │ ├── MenuVentes.h/.cpp
│ │ ├── MenuStock.h/.cpp
│ │ ├── MenuRapports.h/.cpp
│ │ └── DashboardView.h/.cpp
│ │
│ ├── api/ # Serveur HTTP + API REST (interface web)
│ │ ├── httplib.h # Bibliothèque header‑only
│ │ ├── json.hpp # nlohmann/json
│ │ ├── ApiServer.h/.cpp
│ │
│ └── export/ # Export CSV des rapports
│ ├── CsvExporter.h/.cpp
│ └── FactureExporter.h/.cpp
│
├── web/ # Frontend de l’interface web
│ ├── index.html
│ ├── css/style.css
│ └── js/
│ ├── app.js
│ ├── dashboard.js
│ ├── ventes.js
│ ├── produits.js
│ ├── clients.js
│ ├── stock.js
│ └── rapports.js
│
├── tests/ # Tests unitaires
│ ├── test_produit.cpp
│ ├── test_vente.cpp
│ ├── test_stock.cpp
│ ├── test_serializer.cpp
│ └── test_rapport.cpp
│
└── docs/
├── rapport.pdf
└── diagramme_entites.png
| Couche | Dossier | Rôle |
|---|---|---|
| Utilitaires | src/utils/ |
Fonctions génériques (dates, chaînes, configuration, journalisation, validation) sans dépendance métier. |
| Modèle | src/model/ |
Entités métier avec encapsulation, héritage (Produit et ses sous‑classes), invariants (stock ≥ 0). |
| Service | src/service/ |
Orchestration des règles de gestion. Les services reçoivent une référence au Magasin et utilisent les entités du modèle. |
| Persistance | src/persistence/ |
Lecture / écriture des fichiers CSV. La sérialisation polymorphique est gérée par des factories. |
| Interface console | src/ui/ |
Menus interactifs en ligne de commande, saisies robustes, tableaux formatés, couleurs ANSI. |
| API Web | src/api/ |
Serveur HTTP intégré avec cpp‑httplib. Les routes REST répondent en JSON et s’appuient sur les services existants. |
| Export | src/export/ |
Génération de fichiers CSV avec échappement des virgules, et export de factures en texte lisible. |
| Frontend Web | web/ |
Interface graphique HTML/CSS/JS servie par le serveur. Communique avec l’API REST via fetch. |
Le diagramme UML complet est disponible dans docs/diagramme_entites.png.
Il représente les classes principales (Produit, Client, Vente, LigneDeVente, MouvementStock, Magasin) ainsi que leurs relations (héritage, composition, association) et multiplicités.
Le système repose sur six entités métier, modélisées en C++ avec encapsulation stricte et héritage polymorphique pour les produits.
| Entité | Description | Attributs clés |
|---|---|---|
| Produit (abstraite) | Classe de base pour tous les articles vendus. Définit l’interface commune. | reference, designation, prixUnitaire, quantiteEnStock, seuilAlerte, tauxTVA |
| ProduitStandard | Produit sans particularité, prix fixe. | Aucun attribut supplémentaire. |
| ProduitPerissable | Produit avec date de péremption. Bénéficie d’une braderie automatique à l’approche de la date. | datePeremption |
| ProduitEnPromotion | Produit avec une remise promotionnelle en pourcentage. | pourcentageRemise (0–100) |
| Client | Acheteur enregistré, bénéficiant éventuellement d’une remise fidélité. | id, nom, tauxRemiseFidelite (0–1) |
| LigneDeVente | Ligne d’une facture, associe un produit, une quantité et le prix appliqué au moment de la vente. | produit*, quantite, prixUnitaireApplique |
| Vente / Facture | Ensemble de lignes de vente, avec les totaux et les remises figées. | id, date, client*, lignes, totaux, remises |
| MouvementStock | Trace un mouvement de stock (entrée ou sortie) avec la raison. | date, type (ENTREE/SORTIE), produit*, quantite, raison |
| Magasin | Agrégat racine qui possède les collections de produits, clients, ventes et mouvements. | Listes des entités ci‑dessus. |
Magasin ────< Produit
Magasin ────< Client
Magasin ────< Vente
Magasin ────< MouvementStock
Vente ────< LigneDeVente (composition)
LigneDeVente ────> Produit (association)
Vente ────> Client (association)
Produit <|── ProduitStandard
Produit <|── ProduitPerissable
Produit <|── ProduitEnPromotion
- Composition : une
LigneDeVenten’existe pas sans saVente; laVenteest responsable de sa destruction. - Association : une
LigneDeVenteréférence unProduitexistant, sans le posséder. - Héritage : les trois types de produits héritent de la classe abstraite
Produitet redéfinissentprixDeVente().
Ces règles sont garanties par le code, quelle que soit l’interface utilisée (console ou web).
-
Stock jamais négatif – Toute tentative de retrait supérieur au stock disponible lève une exception
StockInsuffisantException. Le stock ne peut pas descendre en dessous de zéro. -
Totaux recalculés – Les montants HT, TVA, TTC d’une vente sont systématiquement recalculés à partir des lignes. Aucun total n’est saisi manuellement.
-
Intégrité référentielle – Une ligne de vente pointe toujours vers un produit existant dans le catalogue. La suppression d’un produit ou d’un client utilisé dans au moins une vente est interdite (exception
ProduitReferencedException/ClientReferencedException). -
Remises figées – Le prix unitaire appliqué, la remise fidélité et la remise globale (paliers) sont enregistrés dans la vente au moment de sa finalisation. Les modifications ultérieures du catalogue ou du client n’affectent pas les factures passées.
-
Ordre des remises – La remise globale (paliers) est appliquée en premier sur le TTC, puis la remise fidélité du client est appliquée sur le reste.
-
Traçabilité des stocks – Chaque vente génère un mouvement de sortie, chaque réapprovisionnement génère un mouvement d’entrée. L’historique complet est consultable.
-
Produits périssables – Un produit dont la date de péremption est dépassée n’est plus commercialisable (
estCommercialisable()retournefalse). Une braderie automatique est déclenchée si la date est dans un seuil configurable (par défaut 7 jours).
Les données sont sauvegardées dans quatre fichiers texte au format CSV (séparateur virgule).
Les dates sont au format YYYY-MM-DD. Les champs contenant des virgules sont échappés.
produits.dat:TYPE,reference,designation,prix,stock,seuil,tva[,attribut spécifique]clients.dat:id,nom,tauxRemiseFideliteventes.dat: blocs multilignesVENTE,…/LIGNE,…/FINmouvements_stock.dat:date,ENTREE|SORTIE,referenceProduit,quantite,raison
Le chargement restaure les collections en mémoire ; les totaux des ventes sont recalculés pour garantir la cohérence.
Le catalogue est le cœur de l’application. Il permet de gérer l’ensemble des articles vendus par le commerce.
- Ajout d’un produit avec choix du type (standard, périssable, en promotion). Chaque type dispose de champs spécifiques (date de péremption, pourcentage de remise).
- Modification des informations : prix, désignation, seuil d’alerte, TVA. Les anciennes valeurs sont pré‑affichées et peuvent être conservées en laissant le champ vide.
- Suppression sécurisée : refusée si le produit est déjà présent dans au moins une vente.
- Recherche par référence exacte ou par désignation partielle (insensible à la casse).
- Liste complète avec affichage en tableau : référence, désignation, prix unitaire, stock actuel, seuil d’alerte et taux de TVA.
Chaque client est identifié par un code unique et peut bénéficier d’une remise fidélité.
- Ajout avec identifiant, nom et taux de remise (entre 0 et 1, par exemple 0,05 pour 5 %).
- Modification des informations existantes.
- Suppression impossible si le client a déjà effectué des achats (intégrité référentielle).
- Recherche par identifiant.
- Historique des achats : affiche toutes les ventes associées à un client (identifiant, date, total TTC).
L’interface de caisse reproduit le fonctionnement d’une caisse enregistreuse physique.
- Sélection du client obligatoire avant toute saisie.
- Ajout de produits au panier par référence ou par recherche sur la désignation. Le stock disponible, le prix de vente effectif (avec promotion ou braderie) sont affichés.
- Panier dynamique mis à jour après chaque ajout : numéro de ligne, désignation, quantité, prix unitaire appliqué, totaux partiels.
- Totaux automatiques : HT, TVA, TTC, estimation de la remise palette et de la remise fidélité.
- Suppression d’une ligne avec restitution immédiate du stock.
- Validation : finalise la vente, applique définitivement les remises, enregistre les mouvements de stock et affiche le total à payer.
- Annulation : rembourse intégralement le stock et supprime la vente.
Le suivi du stock est temps réel et visuellement enrichi.
- État du stock : tableau complet avec référence, désignation, quantité en stock, seuil d’alerte. Les stocks en alerte (sous le seuil) apparaissent en jaune, les ruptures (stock à zéro) en rouge.
- Produits sous le seuil d’alerte : liste dédiée pour un réapprovisionnement rapide.
- Réapprovisionnement : saisie de la référence, de la quantité et d’un motif. Le stock est incrémenté et un mouvement d’entrée est enregistré.
- Historique des mouvements : toutes les entrées et sorties sont horodatées et filtrables par produit.
L’application génère plusieurs rapports destinés à l’analyse de l’activité.
- Chiffre d’affaires : sur une période définie par l’utilisateur (date de début et de fin).
- Produits les plus vendus : classement décroissant par quantité totale vendue.
- État du stock valorisé : quantité × prix unitaire, avec valeur totale du stock.
- Export CSV : chaque rapport peut être exporté en un clic au format CSV compatible avec les tableurs.
Accessible depuis le menu principal ou la barre latérale en mode web, il synthétise les indicateurs clés.
- Vue d’ensemble : nombre de produits, clients, ventes.
- Chiffre d’affaires du jour et du mois en cours.
- Alertes stock : nombre de produits sous seuil et en rupture.
- Valeur totale du stock.
- Liste des 5 dernières ventes et des 5 derniers mouvements de stock.
En mode serveur, l’application expose une API REST complète et sert un frontend moderne.
- API REST : routes pour chaque entité (CRUD produits, clients, ventes, stock, rapports). Réponses JSON. Documentation accessible via Swagger (si activé).
- Frontend : interface responsive (adaptée aux écrans tactiles) avec barre latérale de navigation, cartes d’indicateurs, tableaux paginés, formulaires et un écran de caisse dynamique.
- Communication : le JavaScript interroge l’API via
fetchet met à jour l’affichage sans rechargement de page.
Le projet est intégralement écrit en C++17. Il n’utilise que la bibliothèque standard (STL) et deux bibliothèques externes header‑only pour l’interface web.
Aucune dépendance lourde (Qt, Boost, etc.) n’est nécessaire.
| Bibliothèque | Version | Rôle | Fichier(s) |
|---|---|---|---|
| cpp‑httplib | 0.18+ | Serveur HTTP / HTTPS minimaliste, utilisé pour exposer l’API REST et servir les fichiers statiques du frontend. | src/api/httplib.h |
| nlohmann/json | 3.11+ | Sérialisation / désérialisation JSON pour les échanges entre le backend et le frontend. | src/api/json.hpp |
Ces deux fichiers sont placés dans src/api/ et ne nécessitent aucune compilation séparée.
L’application suit une architecture en couches strictes :
Console UI ──────┐
├── Services ── Modèle ── Persistance (fichiers CSV)
Web UI ──────────┘
- Modèle : entités métier avec encapsulation, héritage et polymorphisme.
- Service : orchestration des règles de gestion, indépendante de l’interface.
- Persistance : lecture/écriture de fichiers CSV avec sérialisation polymorphique.
- UI Console : menus interactifs en ligne de commande.
- API + Web UI : serveur HTTP intégré et frontend HTML/CSS/JS.
Les dépendances entre couches sont descendantes : l’UI connaît les services, qui connaissent le modèle, qui ne dépend de rien d’autre que des utilitaires.
Les données sont stockées dans quatre fichiers texte avec séparateur virgule.
Les dates utilisent le format YYYY-MM-DD. Les champs contenant des virgules ou des guillemets sont automatiquement échappés.
| Fichier | Format | Exemple |
|---|---|---|
produits.dat |
TYPE,reference,designation,prix,stock,seuil,tva[,attribut] |
PERISSABLE,REF003,Lait frais 1L,0.90,25,5,0.10,2026‑08‑15 |
clients.dat |
id,nom,tauxRemiseFidelite |
CLI001,Aminata Diop,0.05 |
ventes.dat |
Blocs multi‑lignes VENTE,… / LIGNE,… / FIN |
VENTE,F0001,2026‑08‑01,CLI001,0.05,0.0 |
mouvements_stock.dat |
`date,ENTREE | SORTIE,referenceProduit,quantite,raison` |
Deux fichiers situés dans le dossier config/ permettent d’ajuster le comportement sans recompilation.
settings.cfg: paramètres métiertva_defaut = 0.20 seuil_braderie_jours = 7 taux_braderie = 0.50 id_vente_prefixe = F sauvegarde_auto = oui remise_paliers_actif = oui remise_paliers = 10000:5,20000:10
logger.conf: configuration du journal applicatif (niveauINFO,DEBUG, sortie console/fichier).
Les valeurs par défaut sont codées en dur et utilisées si les fichiers sont absents.
| Plateforme | Outil | Commande |
|---|---|---|
| Linux / MSYS2 | make |
make run (compile et lance) |
| Windows (cmd) | run.bat |
double‑clic ou run.bat dans l’invite de commandes |
Le Makefile détecte automatiquement tous les fichiers .cpp du dossier src/ et génère les dépendances.
Sous Windows, le flag -D_WIN32_WINNT=0x0A00 et la bibliothèque ws2_32 sont ajoutés pour le support réseau.
| Composant | Version minimale | Détail |
|---|---|---|
| Compilateur C++ | gcc ≥ 7, Clang ≥ 6, MSVC 2017+ | Support complet de C++17 requis. |
| make | GNU Make 3.81+ | Uniquement pour Linux / MSYS2. Sous Windows, run.bat peut être utilisé à la place. |
| Système | Windows 10+, Linux | L’interface web utilise winsock2 (Windows) ; compatible Linux sans dépendance supplémentaire. |
| Espace disque | ~10 Mo | Le projet compilé occupe environ 2 Mo. |
Aucun autre logiciel (base de données, serveur web, bibliothèque graphique) n’est nécessaire.
Cloner le dépôt Git (ou décompresser l’archive fournie) :
git clone https://github.com/votre-compte/mini-erp.git
cd mini-erpmake clean # Supprime les anciens fichiers compilés (optionnel)
make run # Compile et lance l’applicationL’exécutable est créé dans le dossier bin/. La compilation affiche la progression fichier par fichier.
Double‑cliquez sur run.bat ou exécutez‑le depuis l’invite de commandes :
run.batLe script compile tous les fichiers sources et lance automatiquement l’application.
Au démarrage, l’application affiche un menu de choix :
========================================
MINI-ERP - Choix du mode
========================================
1. Interface console (terminal)
2. Interface web (navigateur)
----------------------------------------
Votre choix (1 ou 2) :
-
Mode 1 (Console): les menus interactifs s’affichent dans le terminal. Utilisez les touches numériques pour naviguer. -
Mode 2 (Web): un serveur HTTP démarre sur le port 8080. L’application ouvre automatiquement votre navigateur par défaut.
Une fois le mode 2 sélectionné, le terminal affiche :
Serveur démarré sur http://localhost:8080
- Ouvrez manuellement un navigateur à l’adresse http://localhost:8080.
- La barre latérale permet de naviguer entre les écrans : Tableau de bord, Caisse, Produits, Clients, Stock, Rapports.
- Pour arrêter le serveur, fermez simplement la fenêtre du terminal ou appuyez sur Ctrl+C.
Le dossier data/ contient un jeu d’exemple :
8 produits: riz, huile, lait, thiéboudiengne, eau, yaourt, jus de bissap, café Touba.3 clients: Aminata Diop (5% de remise), Moussa Ndiaye (pas de remise), Fatou Sow (10% de remise).3 ventesdéjà enregistrées pour illustrer les rapports et l’historique.9 mouvements de stock(ventes et réapprovisionnements).
Ces données sont immédiatement utilisables pour tester toutes les fonctionnalités. Pour repartir de zéro, supprimez simplement les fichiers .dat avant de lancer l’application.
Les fichiers config/settings.cfg et config/logger.conf peuvent être modifiés à tout moment. Les modifications sont prises en compte au prochain lancement (pas besoin de recompiler).
# Exemple : désactiver la sauvegarde automatique
sauvegarde_auto = nonLes tests unitaires valident le comportement du modèle métier, des services et de la persistance, indépendamment de l’interface utilisateur.
Chaque test est un programme indépendant qui vérifie une règle de gestion ou un traitement critique à l’aide d’assertions.
| Fichier | Ce qui est testé |
|---|---|
test_produit.cpp |
Hiérarchie des produits, polymorphisme de prixDeVente(), invariants du stock (retrait impossible quand le stock est insuffisant), produits périssables (non commercialisable après péremption, braderie automatique). |
test_vente.cpp |
Création d’une vente (figer la remise fidélité), ajout de lignes et calcul des totaux (HT, TVA, TTC), annulation avec restauration du stock, remise palette appliquée à la finalisation. |
test_stock.cpp |
Réapprovisionnement (augmente le stock), création de mouvements d’entrée, détection des produits sous seuil et en rupture, exception levée pour un produit inconnu. |
test_serializer.cpp |
Sérialisation / désérialisation aller‑retour de chaque entité : produit standard, périssable, en promotion, client, vente (multi‑lignes), mouvement de stock. Vérifie que les champs sont identiques après reconstruction. |
test_rapport.cpp |
Chiffre d’affaires sur période, classement des produits les plus vendus (ordre décroissant), état du stock valorisé (quantité × prix unitaire). |
Les tests sont compilés et exécutés via le Makefile.
make checkCette commande réalise les étapes suivantes :
- Compile tous les fichiers
.cppdu dossiertests/. - Édite un exécutable unique
test_runner(outest_runner.exe). - Lance l’exécutable. Chaque test affiche
[OK]pour les assertions réussies et un message final récapitulatif.
Exemple de sortie console :
Test Produit...
[OK] prixDeVente standard
[OK] prixDeVente promotion
[OK] braderie périssable
[OK] produit périmé non commercialisable
[OK] retrait stock normal
[OK] exception stock insuffisant
Tous les tests Produit sont passés.
Si une assertion échoue, le programme s’arrête immédiatement avec un message d’erreur indiquant le fichier et la ligne concernés.
Ce projet a été réalisé dans le cadre de la formation Ingénieur Statisticien Économiste à l’École Nationale de la Statistique et de l’Analyse Économique (ENSAE) de Dakar, par :
- Mourtalla SALL
- Ndeye Codou MBODJ
Le projet a été mené en binôme tout au long de son développement.
Chaque membre a contribué à l’ensemble des couches (modèle, services, persistance, interface console, API web et frontend), en alternant les rôles de conception et de réalisation.
Les décisions architecturales et les choix techniques ont été pris en commun.
Ce travail s’inscrit dans le cours de Algorithmique et Programmation 3 avec C dispensé par M. Massogui CISSÉ, enseignant à l’ENSAE.
Nous le remercions pour son accompagnement, ses conseils techniques et sa disponibilité.
Nous tenons également à remercier l’ensemble de l’équipe pédagogique de l’ENSAE pour les compétences transmises durant notre cursus.
Ce projet est distribué sous licence MIT.
Vous êtes libre d’utiliser, modifier et distribuer ce code, à condition de conserver la mention de copyright originale.