push final

j'ai fait:
- user stories 10 et 11
- j'ai commencé à ajouter un menu pour les bénévoles pour choisir si on veut voir les demandes acceptées ou en cours séparément
- j'ai commencé à faire une page pour voir les demandes en cours, séparée de celle pour les demandes acceptées; mais pour le moment elle affiche toutes les demandes en cours indépendamment de qui les a prises
- j'ai modifié la bdd sql pour ajouter 2 colonnes "motif_rejet" et "benevole_id", du coup la fonction prendreDemande() marche maintenant

.classpath

@@ -26,7 +26,7 @@
 			<attribute name="optional" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7">
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>

.forgejo/workflows/workflow.yml

@@ -0,0 +1,47 @@
+name: CI Workflow
+
+on:
+  push:
+    branches:
+      - "*"
+
+jobs:
+  build-and-test:
+    runs-on: ubuntu-latest
+
+    steps:
+      # on recupere d'abord le code
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      # on setup java comme il faut
+      - name: Set up Java
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'temurin' # OpenJDK
+          java-version: '17'      # version de java pour le projet
+
+      # on definit l'url, login et mot de passe pour la bdd insa
+      - name: Set database environment variables
+        env:
+          DB_URL: ${{ secrets.DB_URL }}
+          DB_USER: ${{ secrets.DB_USER }}
+          DB_PASSWORD: ${{ secrets.DB_PASSWORD }}
+        run: |
+          echo "Database environment variables have been set."
+
+      # on compile d'abord le projet...
+      - name: Compile project
+        env:
+          DB_URL: ${{ secrets.DB_URL }}
+          DB_USER: ${{ secrets.DB_USER }}
+          DB_PASSWORD: ${{ secrets.DB_PASSWORD }}
+        run: mvn compile
+
+      # ...puis enfin on fait les tests comme voulu
+      - name: Run tests
+        env:
+          DB_URL: ${{ secrets.DB_URL }}
+          DB_USER: ${{ secrets.DB_USER }}
+          DB_PASSWORD: ${{ secrets.DB_PASSWORD }}
+        run: mvn test

.gitignore

@@ -1 +1,3 @@
 /target/
+/.idea/
+/.settings/

.project

@@ -20,4 +20,15 @@
 		<nature>org.eclipse.jdt.core.javanature</nature>
 		<nature>org.eclipse.m2e.core.maven2Nature</nature>
 	</natures>
+	<filteredResources>
+		<filter>
+			<id>1730423778330</id>
+			<name></name>
+			<type>30</type>
+			<matcher>
+				<id>org.eclipse.core.resources.regexFilterMatcher</id>
+				<arguments>node_modules|\.git|__CREATED_BY_JAVA_LANGUAGE_SERVER__</arguments>
+			</matcher>
+		</filter>
+	</filteredResources>
 </projectDescription>

.settings/org.eclipse.jdt.core.prefs

@@ -1,8 +0,0 @@
-eclipse.preferences.version=1
-org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
-org.eclipse.jdt.core.compiler.compliance=1.7
-org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
-org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
-org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=ignore
-org.eclipse.jdt.core.compiler.release=disabled
-org.eclipse.jdt.core.compiler.source=1.7

.settings/org.eclipse.m2e.core.prefs

@@ -1,4 +0,0 @@
-activeProfiles=
-eclipse.preferences.version=1
-resolveWorkspaceProjects=true
-version=1

README.md

@@ -0,0 +1,95 @@
+# Application PDLA - Gestion des Demandes Bénévoles
+
+## Prérequis
+- Java JDK 11 ou supérieur
+- Apache Maven 3.6 ou supérieur
+- Eclipse IDE
+- Accès aux machines INSA (pour l'exécution sur Linux)
+
+## Installation
+
+### Configuration Eclipse
+1. Importez le projet dans Eclipse :
+   - File > Import > Maven > Existing Maven Projects
+   - Sélectionnez le dossier racine du projet
+   - Cliquez sur "Finish"
+
+2. Configuration du build path :
+   - Clic droit sur le projet > Properties
+   - Java Build Path > Libraries
+   - Vérifiez que le JDK est correctement configuré
+
+### Configuration Maven
+1. Mettez à jour les dépendances Maven :
+```bash
+mvn clean install
+```
+
+2. Vérifiez que le fichier `pom.xml` est correctement configuré avec toutes les dépendances nécessaires.
+
+## Exécution des Tests
+
+### Dans Eclipse
+1. Clic droit sur le projet
+2. Run As > Maven test
+
+### En ligne de commande (Linux INSA)
+```bash
+# Se connecter aux machines INSA
+ssh votre_login@votre_machine.insa-toulouse.fr
+
+# Naviguer vers le répertoire du projet
+cd chemin/vers/votre/projet
+
+# Exécuter les tests
+mvn test
+```
+
+## Structure du Projet
+- `src/main/java/` : Code source principal
+  - `controller/` : Contrôleurs de l'application
+  - `database/` : Gestion de la base de données
+  - Classes principales : 
+    - BenevoleDemandes*.java
+    - CreateAccountPage.java
+    - LoginPage.java
+    - MenuBenevole.java
+    - SoumettreDemande.java
+    - Validateur.java
+
+- `src/test/java/` : Tests unitaires et d'intégration
+  - Tests correspondants aux classes principales
+  - Tests de validation
+  - Tests de base de données
+
+## Exécution de l'Application
+
+### Dans Eclipse
+1. Localisez la classe principale
+2. Clic droit > Run As > Java Application
+
+### En ligne de commande (Linux INSA)
+```bash
+# Compiler et créer le package
+mvn package
+
+# Exécuter l'application
+java -jar target/nom-du-jar.jar
+```
+
+## Notes Importantes
+- Assurez-vous que la base de données est correctement configurée avant l'exécution
+- Tous les tests doivent passer avant de soumettre des modifications
+- Utilisez la branche 'master' pour le développement principal
+
+## Tests
+L'application inclut plusieurs types de tests :
+- Tests unitaires pour les composants individuels
+- Tests d'intégration pour les flux complets
+- Tests de validation pour les formulaires
+- Tests de la base de données
+
+Pour exécuter des tests spécifiques :
+```bash
+mvn test -Dtest=NomDuTest
+```

pom.xml

@@ -8,13 +8,34 @@
   <artifactId>AidePersonnesApp</artifactId>
   <version>1.0-SNAPSHOT</version>
 
+  <properties>
+      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+  </properties>
+
   <dependencies>
+    <!-- Dépendance pour JUnit 5 -->
+    <dependency>
+        <groupId>org.junit.jupiter</groupId>
+        <artifactId>junit-jupiter-api</artifactId>
+        <version>5.7.0</version>
+        <scope>test</scope>
+    </dependency>
+
+    <dependency>
+        <groupId>org.junit.jupiter</groupId>
+        <artifactId>junit-jupiter-engine</artifactId>
+        <version>5.7.0</version>
+        <scope>test</scope>
+    </dependency>
+
     <!-- Dépendance pour MySQL Connector -->
     <dependency>
       <groupId>mysql</groupId>
       <artifactId>mysql-connector-java</artifactId>
       <version>8.0.28</version>
     </dependency>
+
   </dependencies>
 
 </project>

src/main/java/controller/AjoutUtilisateur.java

@@ -1,108 +0,0 @@
-package controller;
-
-import database.DatabaseConnection;
-
-import javax.swing.*;
-import java.awt.*;
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
-import java.sql.Connection;
-import java.sql.PreparedStatement;
-import java.sql.SQLException;
-
-public class AjoutUtilisateur extends JFrame {
-    private JTextField nomField;
-    private JTextField emailField;
-    private JComboBox<String> typeComboBox;
-    private JButton ajouterButton;
-    private JButton retourAccueilButton;
-
-    public AjoutUtilisateur() {
-        setTitle("Ajouter un utilisateur");
-        setSize(400, 300);
-        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-        setLocationRelativeTo(null);
-        setLayout(new GridBagLayout());
-
-        GridBagConstraints gbc = new GridBagConstraints();
-        gbc.insets = new Insets(10, 10, 10, 10);
-        gbc.fill = GridBagConstraints.HORIZONTAL;
-
-        JLabel nomLabel = new JLabel("Nom :");
-        gbc.gridx = 0;
-        gbc.gridy = 0;
-        add(nomLabel, gbc);
-
-        nomField = new JTextField();
-        gbc.gridx = 1;
-        gbc.gridy = 0;
-        gbc.gridwidth = 2;
-        add(nomField, gbc);
-
-        JLabel emailLabel = new JLabel("Email :");
-        gbc.gridx = 0;
-        gbc.gridy = 1;
-        add(emailLabel, gbc);
-
-        emailField = new JTextField();
-        gbc.gridx = 1;
-        gbc.gridy = 1;
-        gbc.gridwidth = 2;
-        add(emailField, gbc);
-
-        JLabel typeLabel = new JLabel("Type d'utilisateur :");
-        gbc.gridx = 0;
-        gbc.gridy = 2;
-        add(typeLabel, gbc);
-
-        typeComboBox = new JComboBox<>(new String[]{"benevole", "personne_besoin", "validateur"});
-        gbc.gridx = 1;
-        gbc.gridy = 2;
-        gbc.gridwidth = 2;
-        add(typeComboBox, gbc);
-
-        ajouterButton = new JButton("Ajouter");
-        gbc.gridx = 1;
-        gbc.gridy = 3;
-        add(ajouterButton, gbc);
-
-        retourAccueilButton = new JButton("Retour à l'accueil");
-        gbc.gridx = 1;
-        gbc.gridy = 4;
-        add(retourAccueilButton, gbc);
-
-        ajouterButton.addActionListener(new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                ajouterUtilisateur();
-            }
-        });
-
-        retourAccueilButton.addActionListener(new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                MainMenu menu = new MainMenu();
-                menu.setVisible(true);
-                dispose();
-            }
-        });
-    }
-
-    private void ajouterUtilisateur() {
-        String nom = nomField.getText();
-        String email = emailField.getText();
-        String typeUtilisateur = (String) typeComboBox.getSelectedItem();
-
-        try (Connection connection = DatabaseConnection.getConnection()) {
-            String sql = "INSERT INTO utilisateurs (nom, email, type_utilisateur) VALUES (?, ?, ?)";
-            PreparedStatement statement = connection.prepareStatement(sql);
-            statement.setString(1, nom);
-            statement.setString(2, email);
-            statement.setString(3, typeUtilisateur);
-            statement.executeUpdate();
-            JOptionPane.showMessageDialog(this, "Utilisateur ajouté avec succès !");
-        } catch (SQLException e) {
-            e.printStackTrace();
-        }
-    }
-}

src/main/java/controller/BenevoleDemandesEncoursPage.java

@@ -0,0 +1,137 @@
+package controller;
+
+import database.DatabaseConnection;
+
+import javax.swing.*;
+import javax.swing.table.DefaultTableModel;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class BenevoleDemandesEncoursPage extends JFrame {
+    private JTable table;
+    private DefaultTableModel tableModel;
+    private JButton finaliserDemandeButton;
+    private JButton retourBenevoleButton;
+    private int utilisateurId; // Ajout de l'ID du bénévole
+
+    public BenevoleDemandesEncoursPage(final int utilisateurId) { // Ajout du paramètre utilisateurId
+        this.utilisateurId = utilisateurId; // Stockage de l'ID du bénévole
+        setTitle("Demandes en cours");
+        setSize(600, 400);
+        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        setLocationRelativeTo(null);
+
+        // Tableau pour afficher les demandes
+        tableModel = new DefaultTableModel(new String[]{"ID", "Description", "Statut"}, 0);
+        table = new JTable(tableModel);
+        JScrollPane scrollPane = new JScrollPane(table);
+
+        // Bouton pour prendre et finaliser des demandes
+        finaliserDemandeButton = new JButton("Finaliser la demande");
+        retourBenevoleButton = new JButton("Retour au menu bénévole");
+
+        // Panel des boutons
+        JPanel buttonPanel = new JPanel();
+        buttonPanel.add(finaliserDemandeButton);
+        buttonPanel.add(retourBenevoleButton);
+
+        getContentPane().add(scrollPane, "Center");
+        getContentPane().add(buttonPanel, "South");
+
+        // ActionListener pour finaliser une demande
+        finaliserDemandeButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                finaliserDemande();
+            }
+        });
+
+        // Bouton de retour à la page d'accueil
+        // ActionListener pour retourner à la page de connexion
+        retourBenevoleButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                MenuBenevole menu = new MenuBenevole(utilisateurId);
+                menu.setVisible(true);
+                dispose();
+            }
+        });
+
+        // Charger les demandes acceptées
+        loadDemandesEnCours();
+    }
+
+    //Méthodes de type get()
+    public JTable getTable() {return this.table;}
+    public DefaultTableModel getTableModel() {return this.tableModel;}
+    public JButton getFinaliserDemandeButton() {return this.finaliserDemandeButton;}
+    public JButton getRetourBenevoleButton() {return this.retourBenevoleButton;}
+    public int getID() {return this.utilisateurId;}
+
+    // Méthode pour charger les demandes acceptées
+    private void loadDemandesEnCours() {
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            String sql = "SELECT id, description, statut FROM demandes_aide WHERE statut = 'en cours' AND benevole_id = ?";
+            PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setInt(1, utilisateurId);
+            ResultSet resultSet = statement.executeQuery();
+
+            tableModel.setRowCount(0); // Réinitialiser le tableau
+            while (resultSet.next()) {
+                int id = resultSet.getInt("id");
+                String description = resultSet.getString("description");
+                String statut = resultSet.getString("statut");
+
+                tableModel.addRow(new Object[]{id, description, statut});
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    // Méthode pour finaliser une demande
+    private void finaliserDemande() {
+        int selectedRow = table.getSelectedRow();
+        if (selectedRow == -1) {
+            JOptionPane.showMessageDialog(this, "Veuillez sélectionner une demande à finaliser.");
+            return;
+        }
+
+        int demandeId = (int) tableModel.getValueAt(selectedRow, 0);
+
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            // Verifier si la demande est bien 'en cours' d'abord
+            String checkSql = "SELECT statut FROM demandes_aide WHERE id = ? AND benevole_id = ?";
+            PreparedStatement checkStatement = connection.prepareStatement(checkSql);
+            checkStatement.setInt(1, demandeId);
+            checkStatement.setInt(2, utilisateurId);
+            ResultSet resultSet = checkStatement.executeQuery();
+
+            if (resultSet.next()) {
+                String currentStatus = resultSet.getString("statut");
+
+                if ("en cours".equals(currentStatus)) {
+                    // Mise à jour seulement si le statut est 'en cours'
+                    String updateSql = "UPDATE demandes_aide SET statut = 'finalisée' WHERE id = ?";
+                    PreparedStatement updateStatement = connection.prepareStatement(updateSql);
+                    updateStatement.setInt(1, demandeId);
+                    updateStatement.executeUpdate();
+
+                    JOptionPane.showMessageDialog(this, "Demande finalisée avec succès.");
+                } else {
+                    // Statut n'est pas 'en cours'
+                    JOptionPane.showMessageDialog(this, "Demande non finalisée car le statut n'est pas 'en cours'. (Statut actuel : " + currentStatus + ")");
+                }
+                loadDemandesEnCours();  // Recharger les demandes après tentative/réssuite de finalisation
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+            JOptionPane.showMessageDialog(this, "Erreur lors de la finalisation de la demande.");
+        }
+    }
+}
+

src/main/java/controller/BenevoleDemandesFinaliseesPage.java

@@ -0,0 +1,201 @@
+package controller;
+
+import database.DatabaseConnection;
+
+import javax.swing.*;
+import javax.swing.table.DefaultTableModel;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class BenevoleDemandesFinaliseesPage extends JFrame {
+    private JTable table;
+    private DefaultTableModel tableModel;
+    private JButton voirAvisButton; // Bouton pour voir les avis
+    private JButton modifierAvisButton; // Bouton pour modifer l'avis (benevole)
+    private JButton retourBenevoleButton;
+    private int utilisateurId; // Ajout de l'ID du bénévole
+
+    public BenevoleDemandesFinaliseesPage(final int utilisateurId) { // Ajout du paramètre utilisateurId
+        this.utilisateurId = utilisateurId; // Stockage de l'ID du bénévole
+        setTitle("Demandes finalisées");
+        setSize(600, 400);
+        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        setLocationRelativeTo(null);
+
+        // Tableau pour afficher les demandes
+        tableModel = new DefaultTableModel(new String[]{"ID", "Description", "Statut"}, 0);
+        table = new JTable(tableModel);
+        JScrollPane scrollPane = new JScrollPane(table);
+
+        // Bouton pour prendre et finaliser des demandes
+        voirAvisButton = new JButton("Voir les avis");
+        modifierAvisButton = new JButton("Modifier l'avis");
+        retourBenevoleButton = new JButton("Retour au menu bénévole");
+
+        // Panel des boutons
+        JPanel buttonPanel = new JPanel();
+        buttonPanel.add(voirAvisButton);
+        buttonPanel.add(modifierAvisButton);
+        buttonPanel.add(retourBenevoleButton);
+
+        getContentPane().add(scrollPane, "Center");
+        getContentPane().add(buttonPanel, "South");
+
+        // ActionListener pour finaliser une demande
+        voirAvisButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                afficherAvis();
+            }
+        });
+
+        modifierAvisButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                modifierAvis();
+            }
+        });
+
+        // Bouton de retour à la page d'accueil
+        // ActionListener pour retourner à la page de connexion
+        retourBenevoleButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                MenuBenevole menu = new MenuBenevole(utilisateurId);
+                menu.setVisible(true);
+                dispose();
+            }
+        });
+
+        // Charger les demandes acceptées
+        loadDemandesFinalisees();
+    }
+
+    //Méthodes de type get()
+    public JTable getTable() {return this.table;}
+    public DefaultTableModel getTableModel() {return this.tableModel;}
+    public JButton getVoirAvisButton() {return this.voirAvisButton;}
+    public JButton getModifierAvisButton() {return this.modifierAvisButton;}
+    public JButton getRetourBenevoleButton() {return this.retourBenevoleButton;}
+    public int getID() {return this.utilisateurId;}
+
+    private void afficherAvis() {
+        int selectedRow = table.getSelectedRow();
+        if (selectedRow == -1) {
+            JOptionPane.showMessageDialog(this, "Veuillez sélectionner une demande dont vous voulez afficher les avis.");
+            return;
+        }
+
+        int demandeId = (int) tableModel.getValueAt(selectedRow, 0);
+
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            // Verifier si la demande est bien 'finalisée' d'abord
+            String checkSql = "SELECT description, statut, avis_besoin, avis_benevole FROM demandes_aide WHERE id = ? ";
+            PreparedStatement checkStatement = connection.prepareStatement(checkSql);
+            checkStatement.setInt(1, demandeId);
+            ResultSet resultSet = checkStatement.executeQuery();
+
+            if (resultSet.next()) {
+                String currentStatus = resultSet.getString("statut");
+
+                if ("finalisée".equals(currentStatus)) {
+                    // Affichage seulement si le statut est 'finalisée'
+                    String desc = resultSet.getString("description");
+                    String avis_besoin = resultSet.getString("avis_besoin");
+                    String avis_benevole = resultSet.getString("avis_benevole");
+
+                    String texte_avis =
+                            "Description de la demande:\n" +
+                                    desc +
+                                    "\n___________________________________________________\n" +
+                                    "Avis de la personne dans le besoin :\n" +
+                                    avis_besoin +
+                                    "\n___________________________________________________\n" +
+                                    "Avis du benevole en charge de la demande :\n" +
+                                    avis_benevole;
+
+                    JOptionPane.showMessageDialog(this, texte_avis);
+                } else {
+                    // Statut n'est pas 'finalisée'
+                    JOptionPane.showMessageDialog(this, "Avis non affichés car la demande n'est pas 'finalisée'. (Statut actuel : " + currentStatus + ")");
+                }
+                loadDemandesFinalisees();  // Recharger les demandes après tentative/réssuite de l'affichage des avis
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+            JOptionPane.showMessageDialog(this, "Erreur lors de l'affichage des avis.");
+        }
+    }
+
+    // Méthode pour rejeter une demande
+    private void modifierAvis() {
+        int selectedRow = table.getSelectedRow();
+        if (selectedRow == -1) {
+            JOptionPane.showMessageDialog(this, "Veuillez sélectionner une demande dont vous voulez modifier l'avis.");
+            return;
+        }
+
+        int demandeId = (int) tableModel.getValueAt(selectedRow, 0);
+
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            // Verifier si la demande est bien 'finalisée' d'abord
+            String checkSql = "SELECT statut FROM demandes_aide WHERE id = ? ";
+            PreparedStatement checkStatement = connection.prepareStatement(checkSql);
+            checkStatement.setInt(1, demandeId);
+            ResultSet resultSet = checkStatement.executeQuery();
+
+            if (resultSet.next()) {
+                String currentStatus = resultSet.getString("statut");
+
+                if ("finalisée".equals(currentStatus)) {
+                    String avis = JOptionPane.showInputDialog(this, "Veuillez entrer votre avis (500 caractères max):", "Modification de l'avis", JOptionPane.PLAIN_MESSAGE);
+
+                    if (!avis.isEmpty()) {
+                        String sql = "UPDATE demandes_aide SET avis_benevole = ? WHERE id = ?";
+                        PreparedStatement statement = connection.prepareStatement(sql);
+                        statement.setString(1, avis);
+                        statement.setInt(2, demandeId);
+                        statement.executeUpdate();
+
+                        JOptionPane.showMessageDialog(this, "Avis modifié avec succès.");
+                    } else {
+                        JOptionPane.showMessageDialog(this, "Votre avis ne peut pas être vide.");
+                    }
+                } else {
+                    // Statut n'est pas 'finalisée'
+                    JOptionPane.showMessageDialog(this, "Vous ne pouvez pas modifier l'avis car la demande n'est pas 'finalisée'. (Statut actuel : " + currentStatus + ")");
+                }
+                loadDemandesFinalisees();  // Recharger les demandes après tentative/réssuite de modification de l'avis
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+            JOptionPane.showMessageDialog(this, "Erreur lors de la modification de l'avis.");
+        }
+    }
+
+    // Méthode pour charger les demandes acceptées
+    private void loadDemandesFinalisees() {
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            String sql = "SELECT id, description, statut FROM demandes_aide WHERE statut = 'finalisée' AND benevole_id = ?";
+            PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setInt(1, utilisateurId);
+            ResultSet resultSet = statement.executeQuery();
+
+            tableModel.setRowCount(0); // Réinitialiser le tableau
+            while (resultSet.next()) {
+                int id = resultSet.getInt("id");
+                String description = resultSet.getString("description");
+                String statut = resultSet.getString("statut");
+
+                tableModel.addRow(new Object[]{id, description, statut});
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+}
+

src/main/java/controller/BenevoleDemandesPage.java

@@ -0,0 +1,126 @@
+package controller;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JOptionPane;
+import javax.swing.JPanel;
+import javax.swing.JScrollPane;
+import javax.swing.JTable;
+import javax.swing.table.DefaultTableModel;
+
+import database.DatabaseConnection;
+
+public class BenevoleDemandesPage extends JFrame {
+    private JTable table;
+    private DefaultTableModel tableModel;
+    private JButton prendreDemandeButton;
+    private JButton retourBenevoleButton;
+    
+    final int utilisateurId ; // Ajout de l'ID du bénévole
+
+    public BenevoleDemandesPage(final int utilisateurId) { // Ajout du paramètre utilisateurId
+        this.utilisateurId = utilisateurId; // Stockage de l'ID du bénévole
+        setTitle("Demandes acceptées");
+        setSize(600, 400);
+        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        setLocationRelativeTo(null);
+
+        // Tableau pour afficher les demandes
+        tableModel = new DefaultTableModel(new String[]{"ID", "Description", "Statut"}, 0);
+        table = new JTable(tableModel);
+        JScrollPane scrollPane = new JScrollPane(table);
+
+        // Bouton pour prendre et finaliser des demandes
+        prendreDemandeButton = new JButton("Prendre la demande");
+        retourBenevoleButton = new JButton("Retour au menu bénévole");
+
+        // Panel des boutons
+        JPanel buttonPanel = new JPanel();
+        buttonPanel.add(prendreDemandeButton);
+        buttonPanel.add(retourBenevoleButton);
+
+        getContentPane().add(scrollPane, "Center");
+        getContentPane().add(buttonPanel, "South");
+
+        // ActionListener pour prendre une demande
+        prendreDemandeButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                prendreDemande();
+            }
+        });
+        
+        // Bouton de retour à la page d'accueil
+        // ActionListener pour retourner à la page de connexion
+        retourBenevoleButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                MenuBenevole menu = new MenuBenevole(utilisateurId);
+                menu.setVisible(true);
+                dispose();
+            }
+        });
+
+        // Charger les demandes acceptées
+        loadDemandesAcceptees();
+    }
+
+    //Méthodes de type get()
+    public JTable getTable() {return this.table;}
+    public DefaultTableModel getTableModel() {return this.tableModel;}
+    public JButton getPrendreDemandeButton() {return this.prendreDemandeButton;}
+    public JButton getRetourBenevoleButton() {return this.retourBenevoleButton;}
+    public int getID() {return this.utilisateurId;}
+
+    // Méthode pour charger les demandes acceptées
+    private void loadDemandesAcceptees() {
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            String sql = "SELECT id, description, statut FROM demandes_aide WHERE statut = 'acceptée'";
+            PreparedStatement statement = connection.prepareStatement(sql);
+            ResultSet resultSet = statement.executeQuery();
+
+            tableModel.setRowCount(0); // Réinitialiser le tableau
+            while (resultSet.next()) {
+                int id = resultSet.getInt("id");
+                String description = resultSet.getString("description");
+                String statut = resultSet.getString("statut");
+
+                tableModel.addRow(new Object[]{id, description, statut});
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    // Méthode pour prendre une demande
+    private void prendreDemande() {
+        int selectedRow = table.getSelectedRow();
+        if (selectedRow == -1) {
+            JOptionPane.showMessageDialog(this, "Veuillez sélectionner une demande à prendre.");
+            return;
+        }
+
+        int demandeId = (int) tableModel.getValueAt(selectedRow, 0);
+
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            String sql = "UPDATE demandes_aide SET statut = 'en cours', benevole_id = ? WHERE id = ?";
+            PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setInt(1, utilisateurId);  // ID du bénévole qui prend la demande
+            statement.setInt(2, demandeId);
+            statement.executeUpdate();
+
+            JOptionPane.showMessageDialog(this, "Demande prise avec succès.");
+            loadDemandesAcceptees();  // Recharger les demandes après la prise
+        } catch (SQLException e) {
+            e.printStackTrace();
+            JOptionPane.showMessageDialog(this, "Erreur lors de la prise de la demande.");
+        }
+    }
+}

src/main/java/controller/CreateAccountPage.java

@@ -0,0 +1,103 @@
+package controller;
+
+import database.DatabaseConnection;
+
+import javax.swing.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+public class CreateAccountPage extends JFrame {
+    private JTextField nomField;
+    private JTextField emailField;
+    private JComboBox<String> roleComboBox;
+    private JButton createAccountButton;
+    private JButton retourLoginButton;  // Nouveau bouton pour retourner à la connexion
+
+    public CreateAccountPage() {
+        setTitle("Créer un compte");
+        setSize(400, 300);
+        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        setLocationRelativeTo(null);
+
+        // Création des champs et boutons
+        JLabel nomLabel = new JLabel("Nom :");
+        nomField = new JTextField(20);
+
+        JLabel emailLabel = new JLabel("Email :");
+        emailField = new JTextField(20);
+
+        JLabel roleLabel = new JLabel("Rôle :");
+        String[] roles = {"benevole", "personne_besoin", "validateur"};
+        roleComboBox = new JComboBox<>(roles);
+
+        createAccountButton = new JButton("Créer un compte");
+        retourLoginButton = new JButton("Retour à la connexion");  // Nouveau bouton
+
+        JPanel panel = new JPanel();
+        panel.add(nomLabel);
+        panel.add(nomField);
+        panel.add(emailLabel);
+        panel.add(emailField);
+        panel.add(roleLabel);
+        panel.add(roleComboBox);
+        panel.add(createAccountButton);
+        panel.add(retourLoginButton);  // Ajouter le bouton de retour
+
+        getContentPane().add(panel);
+
+        // ActionListener pour créer un compte
+        createAccountButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                createAccount();
+            }
+        });
+
+        // ActionListener pour retourner à la connexion
+        retourLoginButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                LoginPage loginPage = new LoginPage();
+                loginPage.setVisible(true);
+                dispose();  // Fermer la page de création de compte
+            }
+        });
+    }
+
+    // Méthode pour créer un compte dans la base de données
+    private void createAccount() {
+        String nom = nomField.getText();
+        String email = emailField.getText();
+        String role = (String) roleComboBox.getSelectedItem();
+
+        if (nom.isEmpty() || email.isEmpty()) {
+            JOptionPane.showMessageDialog(this, "Veuillez remplir tous les champs.");
+            return;
+        }
+
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            String sql = "INSERT INTO utilisateur (nom, email, role) VALUES (?, ?, ?)";
+            PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setString(1, nom);
+            statement.setString(2, email);
+            statement.setString(3, role);
+            statement.executeUpdate();
+
+            JOptionPane.showMessageDialog(this, "Compte créé avec succès !");
+            dispose();  // Fermer la page de création de compte
+            LoginPage loginPage = new LoginPage();  // Retourner à la connexion après création
+            loginPage.setVisible(true);
+        } catch (SQLException e) {
+            e.printStackTrace();
+            JOptionPane.showMessageDialog(this, "Erreur lors de la création du compte.");
+        }
+    }
+
+    public static void main(String[] args) {
+        CreateAccountPage createAccountPage = new CreateAccountPage();
+        createAccountPage.setVisible(true);
+    }
+}

src/main/java/controller/LoginPage.java

@@ -0,0 +1,113 @@
+package controller;
+
+import database.DatabaseConnection;
+
+import javax.swing.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.nio.charset.Charset;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class LoginPage extends JFrame {
+	 private JTextField emailField;
+	 private JButton loginButton;
+     private JButton createAccountButton;
+
+    public LoginPage() {
+        setTitle("Page de connexion");
+        setSize(400, 200);
+        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        setLocationRelativeTo(null);
+
+        // Création des champs et boutons
+        JLabel emailLabel = new JLabel("Email :");
+        emailField = new JTextField(20);
+        loginButton = new JButton("Se connecter");
+        createAccountButton = new JButton("Créer un compte");
+
+        JPanel panel = new JPanel();
+        panel.add(emailLabel);
+        panel.add(emailField);
+        panel.add(loginButton);
+        panel.add(createAccountButton);
+
+        getContentPane().add(panel);
+
+        // ActionListener pour se connecter
+        loginButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                loginUser();
+            }
+        });
+
+        // ActionListener pour créer un compte
+        createAccountButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                CreateAccountPage createAccountPage = new CreateAccountPage();
+                createAccountPage.setVisible(true);
+                dispose();  // Fermer la page de login après ouverture de la page création de compte
+            }
+        });
+    }
+
+    //Méthodes de type get()
+    public JTextField getEmailField() {return this.emailField;}
+    public JButton getLoginButton() {return this.loginButton;}
+    public JButton getCreateAccountButton() {return this.createAccountButton;}
+
+
+    // suprime de main menu
+    // Méthode pour gérer la connexion de l'utilisateur
+    private void loginUser() {
+        String email = emailField.getText();
+
+        if (email.isEmpty()) {
+            JOptionPane.showMessageDialog(this, "Veuillez entrer votre email.");
+            return;
+        }
+
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            String sql = "SELECT id, role FROM utilisateur WHERE email = ?";
+            PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setString(1, email);
+            ResultSet resultSet = statement.executeQuery();
+
+            if (resultSet.next()) {
+                int utilisateurId = resultSet.getInt("id");
+                String role = resultSet.getString("role");
+
+                // Rediriger vers la bonne page selon le rôle
+                if (role.equalsIgnoreCase("benevole")) {
+                    MenuBenevole menu = new MenuBenevole(utilisateurId);
+                    menu.setVisible(true);
+                    dispose();
+                } else if (role.equalsIgnoreCase("personne_besoin")) {
+                    SoumettreDemande soumettreDemandePage = new SoumettreDemande(utilisateurId);
+                    soumettreDemandePage.setVisible(true);
+                    dispose();
+                } else if (role.equalsIgnoreCase("validateur")) {
+                    Validateur validateurPage = new Validateur(utilisateurId);
+                    validateurPage.setVisible(true);
+                    dispose();
+                } else {
+                    JOptionPane.showMessageDialog(this, "Rôle non reconnu.");
+                }
+            } else {
+                JOptionPane.showMessageDialog(this, "Email non trouvé. Veuillez créer un compte.");
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+            JOptionPane.showMessageDialog(this, "Erreur lors de la connexion.");
+        }
+    }
+
+    public static void main(String[] args) {
+        LoginPage loginPage = new LoginPage();
+        loginPage.setVisible(true);
+    }
+}

src/main/java/controller/MainMenu.java

@@ -1,56 +0,0 @@
-package controller;
-
-import javax.swing.*;
-import java.awt.*;
-import java.awt.event.ActionEvent;
-import java.awt.event.ActionListener;
-
-public class MainMenu extends JFrame {
-    private JButton ajouterUtilisateurButton;
-    private JButton soumettreDemandeButton;
-
-    public MainMenu() {
-        setTitle("Menu Principal");
-        setSize(400, 300);
-        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-        setLocationRelativeTo(null);
-        setLayout(new GridBagLayout());
-
-        GridBagConstraints gbc = new GridBagConstraints();
-        gbc.insets = new Insets(10, 10, 10, 10);
-        gbc.fill = GridBagConstraints.HORIZONTAL;
-
-        ajouterUtilisateurButton = new JButton("Ajouter un utilisateur");
-        gbc.gridx = 0;
-        gbc.gridy = 0;
-        add(ajouterUtilisateurButton, gbc);
-
-        soumettreDemandeButton = new JButton("Soumettre une demande d'aide");
-        gbc.gridx = 0;
-        gbc.gridy = 1;
-        add(soumettreDemandeButton, gbc);
-
-        ajouterUtilisateurButton.addActionListener(new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                AjoutUtilisateur ajoutUtilisateur = new AjoutUtilisateur();
-                ajoutUtilisateur.setVisible(true);
-                dispose();
-            }
-        });
-
-        soumettreDemandeButton.addActionListener(new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                SoumettreDemande soumettreDemande = new SoumettreDemande();
-                soumettreDemande.setVisible(true);
-                dispose();
-            }
-        });
-    }
-
-    public static void main(String[] args) {
-        MainMenu menu = new MainMenu();
-        menu.setVisible(true);
-    }
-}

src/main/java/controller/MenuBenevole.java

@@ -0,0 +1,123 @@
+package controller;
+
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+public class MenuBenevole extends JFrame{
+    private JButton voirDemandesAcceptesButton;
+    private JButton voirDemandesEnCoursButton;
+    private JButton voirDemandesFinaliseesButton;
+    private JButton retourButton;
+    private int utilisateurId; // Ajout de l'ID du bénévole
+
+    public MenuBenevole(final int utilisateurId) {
+        this.utilisateurId = utilisateurId;
+        setTitle("Menu Benevole");
+        setSize(400, 300);
+        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        setLocationRelativeTo(null);
+        setLayout(new GridBagLayout());
+
+        GridBagConstraints gbc = new GridBagConstraints();
+        gbc.insets = new Insets(10, 10, 10, 10);
+        gbc.fill = GridBagConstraints.HORIZONTAL;
+
+        setVoirDemandesAcceptesButton(new JButton("Voir demandes acceptés"));
+        gbc.gridx = 0;
+        gbc.gridy = 0;
+        add(getVoirDemandesAcceptesButton(), gbc);
+
+        setVoirDemandesEnCoursButton(new JButton("Voir demandes personelles en cours"));
+        gbc.gridx = 0;
+        gbc.gridy = 1;
+        add(getVoirDemandesEnCoursButton(), gbc);
+
+        setVoirDemandesFinaliseesButton(new JButton("Voir demandes personelles finalisées"));
+        gbc.gridx = 0;
+        gbc.gridy = 2;
+        add(getVoirDemandesFinaliseesButton(), gbc);
+
+        setRetourButton(new JButton("Retour à l'acceuil"));
+        gbc.gridx = 0;
+        gbc.gridy = 3;
+        add(getRetourButton(), gbc);
+
+        getVoirDemandesAcceptesButton().addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                BenevoleDemandesPage benevoleDemandesPage = new BenevoleDemandesPage(utilisateurId);  // Test avec un utilisateur par défaut
+                benevoleDemandesPage.setVisible(true);
+                dispose();
+            }
+        });
+
+        getVoirDemandesEnCoursButton().addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                BenevoleDemandesEncoursPage benevoleDemandesEncoursPage = new BenevoleDemandesEncoursPage(utilisateurId);
+                benevoleDemandesEncoursPage.setVisible(true);
+                dispose();
+            }
+        });
+
+        getVoirDemandesFinaliseesButton().addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                BenevoleDemandesFinaliseesPage benevoleDemandesFinaliseesPage = new BenevoleDemandesFinaliseesPage(utilisateurId);
+                benevoleDemandesFinaliseesPage.setVisible(true);
+                dispose();
+            }
+        });
+
+        // Bouton de retour à la page d'accueil
+        // ActionListener pour retourner à la page de connexion
+        getRetourButton().addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                LoginPage loginPage = new LoginPage();
+                loginPage.setVisible(true);
+                dispose();  // Fermer la page
+            }
+        });
+
+    }
+
+    //Méthodes de type get()
+	public JButton getVoirDemandesAcceptesButton() {
+		return voirDemandesAcceptesButton;
+	}
+    public JButton getVoirDemandesEnCoursButton() {
+        return voirDemandesEnCoursButton;
+    }
+    public JButton getVoirDemandesFinaliseesButton() {
+        return voirDemandesFinaliseesButton;
+    }
+    public JButton getRetourButton() {
+        return retourButton;
+    }
+
+    //Méthodes de type set()
+	public void setVoirDemandesAcceptesButton(JButton voirDemandesAcceptesButton) {
+		this.voirDemandesAcceptesButton = voirDemandesAcceptesButton;
+	}
+
+	public void setVoirDemandesEnCoursButton(JButton voirDemandesEnCoursButton) {
+		this.voirDemandesEnCoursButton = voirDemandesEnCoursButton;
+	}
+
+	public void setVoirDemandesFinaliseesButton(JButton voirDemandesFinaliseesButton) {
+		this.voirDemandesFinaliseesButton = voirDemandesFinaliseesButton;
+	}
+
+	public void setRetourButton(JButton retourButton) {
+		this.retourButton = retourButton;
+	}
+
+
+    public static void main(String[] args) {
+        MenuBenevole menu = new MenuBenevole(2);
+        menu.setVisible(true);
+    }
+}

src/main/java/controller/SoumettreDemande.java

@@ -3,65 +3,75 @@ package controller;
 import database.DatabaseConnection;
 
 import javax.swing.*;
+import javax.swing.table.DefaultTableModel;
 import java.awt.*;
 import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.sql.Connection;
 import java.sql.PreparedStatement;
+import java.sql.ResultSet;
 import java.sql.SQLException;
 
 public class SoumettreDemande extends JFrame {
-    private JTextField utilisateurIdField;
-    private JTextArea descriptionArea;
+    private JTextField descriptionField;
     private JButton soumettreButton;
-    private JButton retourAccueilButton;
+    private JButton retourButton; // Bouton retour
+    private JButton voirMotifButton; // Bouton pour voir motif de rejet
+    private JButton voirAvisButton; // Bouton pour voir les avis
+    private JButton modifierAvisButton; // Bouton pour modifer l'avis (personne dans le besoin)
+    private JTable demandesTable;
+    private DefaultTableModel tableModel;
+    private int utilisateurId;
 
-    public SoumettreDemande() {
+    public SoumettreDemande(int utilisateurId) {
+        this.utilisateurId = utilisateurId;
         setTitle("Soumettre une demande d'aide");
-        setSize(500, 400);
+        setSize(600, 400);
         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         setLocationRelativeTo(null);
-        setLayout(new GridBagLayout());
 
-        GridBagConstraints gbc = new GridBagConstraints();
-        gbc.insets = new Insets(10, 10, 10, 10);
-        gbc.fill = GridBagConstraints.HORIZONTAL;
-
-        JLabel utilisateurIdLabel = new JLabel("ID de l'utilisateur :");
-        gbc.gridx = 0;
-        gbc.gridy = 0;
-        add(utilisateurIdLabel, gbc);
-
-        utilisateurIdField = new JTextField();
-        gbc.gridx = 1;
-        gbc.gridy = 0;
-        gbc.gridwidth = 2;
-        add(utilisateurIdField, gbc);
-
-        JLabel descriptionLabel = new JLabel("Description de la tâche :");
-        gbc.gridx = 0;
-        gbc.gridy = 1;
-        add(descriptionLabel, gbc);
-
-        descriptionArea = new JTextArea(5, 20);
-        descriptionArea.setWrapStyleWord(true);
-        descriptionArea.setLineWrap(true);
-        JScrollPane scrollPane = new JScrollPane(descriptionArea);
-        gbc.gridx = 1;
-        gbc.gridy = 1;
-        gbc.gridwidth = 2;
-        add(scrollPane, gbc);
+        // Layout principal en BorderLayout pour mieux organiser les composants
+        setLayout(new BorderLayout());
 
+        // Création des champs et boutons
+        JLabel descriptionLabel = new JLabel("Description de la demande :");
+        descriptionField = new JTextField(20);
         soumettreButton = new JButton("Soumettre");
-        gbc.gridx = 1;
-        gbc.gridy = 2;
-        add(soumettreButton, gbc);
+        retourButton = new JButton("Retour à l'accueil"); // Création du bouton retour
+        voirMotifButton = new JButton("Voir motif de refus");
+        voirAvisButton = new JButton("Voir les avis");
+        modifierAvisButton = new JButton("Modifier l'avis");
 
-        retourAccueilButton = new JButton("Retour à l'accueil");
-        gbc.gridx = 1;
-        gbc.gridy = 3;
-        add(retourAccueilButton, gbc);
+        // Tableau pour afficher les anciennes demandes
+        tableModel = new DefaultTableModel(new String[]{"ID", "Description", "Statut", "Bénévole en charge"}, 0);
+        demandesTable = new JTable(tableModel);
+        JScrollPane scrollPane = new JScrollPane(demandesTable);
 
+        // Panel pour les champs de saisie et boutons (haut de la fenêtre)
+        JPanel inputPanel = new JPanel(new GridLayout(3, 2));
+        inputPanel.add(descriptionLabel);
+        inputPanel.add(descriptionField);
+        inputPanel.add(soumettreButton);
+
+        // Ajouter les composants à la fenêtre
+        add(inputPanel, BorderLayout.NORTH); // Panel de saisie en haut
+        add(scrollPane, BorderLayout.CENTER); // Tableau au centre
+
+        // Panel pour le bouton retour en bas
+        JPanel bottomPanel = new JPanel(new FlowLayout(FlowLayout.CENTER));
+        bottomPanel.add(retourButton);
+        add(bottomPanel, BorderLayout.SOUTH); // Ajouter le panel du bouton retour en bas
+        bottomPanel.add(voirMotifButton);
+        add(bottomPanel, BorderLayout.SOUTH);
+        bottomPanel.add(voirAvisButton);
+        add(bottomPanel, BorderLayout.SOUTH);
+        bottomPanel.add(modifierAvisButton);
+        add(bottomPanel, BorderLayout.SOUTH);
+
+        // Charger les anciennes demandes
+        loadAnciennesDemandes();
+
+        // ActionListener pour soumettre une demande
         soumettreButton.addActionListener(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent e) {
@@ -69,29 +79,245 @@ public class SoumettreDemande extends JFrame {
             }
         });
 
-        retourAccueilButton.addActionListener(new ActionListener() {
+        // ActionListener pour retourner à l'accueil
+        retourButton.addActionListener(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent e) {
-                MainMenu menu = new MainMenu();
-                menu.setVisible(true);
-                dispose();
+                // Retour à la page de connexion
+                LoginPage loginPage = new LoginPage();
+                loginPage.setVisible(true);
+                dispose();  // Fermer la page actuelle
             }
         });
+
+        // ActionListener pour afficher le motif de refus
+        voirMotifButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                afficherMotifRefus();
+            }
+        });
+
+        // ActionListener pour afficher les avis
+        voirAvisButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                afficherAvis();
+            }
+        });
+
+        // ActionListener pour modifier l'avis
+        modifierAvisButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {modifierAvis(); }
+        });
     }
 
+    //Méthodes de type get()
+    public JTable getTable() {return this.demandesTable;}
+    public DefaultTableModel getTableModel() {return this.tableModel;}
+    public JButton getRetourButton() {return this.retourButton;}
+    public JButton getSoumettreButton() {return this.soumettreButton;}
+    public JButton getVoirMotifButton() {return this.voirMotifButton;}
+    public JButton getVoirAvisButton() {return this.voirAvisButton;}
+    public JButton getModifierAvisButton() {return this.modifierAvisButton;}
+    public int getID() {return this.utilisateurId;}
+
+    // Méthode pour soumettre une demande
     private void soumettreDemande() {
-        String utilisateurId = utilisateurIdField.getText();
-        String description = descriptionArea.getText();
+        String description = descriptionField.getText();
+        if (description.isEmpty()) {
+            JOptionPane.showMessageDialog(this, "Veuillez entrer une description.");
+            return;
+        }
 
         try (Connection connection = DatabaseConnection.getConnection()) {
-            String sql = "INSERT INTO demandes_aide (utilisateur_id, description, statut) VALUES (?, ?, 'en attente')";
+            String sql = "INSERT INTO demandes_aide (description, statut, utilisateur_id) VALUES (?, 'soumise', ?)";
             PreparedStatement statement = connection.prepareStatement(sql);
-            statement.setInt(1, Integer.parseInt(utilisateurId));
-            statement.setString(2, description);
+            statement.setString(1, description);
+            statement.setInt(2, utilisateurId);
             statement.executeUpdate();
-            JOptionPane.showMessageDialog(this, "Demande soumise avec succès !");
+
+            JOptionPane.showMessageDialog(this, "Demande soumise avec succès.");
+            descriptionField.setText("");  // Réinitialiser le champ après soumission
+            loadAnciennesDemandes();  // Recharger la liste des demandes
         } catch (SQLException e) {
             e.printStackTrace();
+            JOptionPane.showMessageDialog(this, "Erreur lors de la soumission de la demande.");
         }
     }
+
+    // Méthode pour charger les anciennes demandes
+    private void afficherMotifRefus() {
+        int selectedRow = demandesTable.getSelectedRow();
+        if (selectedRow == -1) {
+            JOptionPane.showMessageDialog(this, "Veuillez sélectionner une demande dont vous voulez afficher le motif de rejet.");
+            return;
+        }
+
+        int demandeId = (int) tableModel.getValueAt(selectedRow, 0);
+
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            // Verifier si la demande est bien 'rejetée' d'abord
+            String checkSql = "SELECT description, motif_rejet, statut FROM demandes_aide WHERE id = ? ";
+            PreparedStatement checkStatement = connection.prepareStatement(checkSql);
+            checkStatement.setInt(1, demandeId);
+            ResultSet resultSet = checkStatement.executeQuery();
+
+            if (resultSet.next()) {
+                String currentStatus = resultSet.getString("statut");
+
+                if ("rejetée".equals(currentStatus)) {
+                    // Affichage seulement si le statut est 'rejetée'
+                    String desc = resultSet.getString("description");
+                    String motif = resultSet.getString("motif_rejet");
+
+                    String texte_motif_refus =
+                            "Description de la demande:\n" +
+                            desc +
+                            "\n___________________________________________________\n" +
+                            "Motif de rejet :\n" +
+                            motif;
+
+                    JOptionPane.showMessageDialog(this, texte_motif_refus);
+                } else {
+                    // Statut n'est pas 'rejetée'
+                    JOptionPane.showMessageDialog(this, "Motif non affiché car la demande n'est pas 'rejetée'. (Statut actuel : " + currentStatus + ")");
+                }
+                loadAnciennesDemandes();  // Recharger les demandes après tentative/réssuite de l'affichage du motif
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+            JOptionPane.showMessageDialog(this, "Erreur lors de l'affichage du motif.");
+        }
+    }
+
+    private void afficherAvis() {
+        int selectedRow = demandesTable.getSelectedRow();
+        if (selectedRow == -1) {
+            JOptionPane.showMessageDialog(this, "Veuillez sélectionner une demande dont vous voulez afficher les avis.");
+            return;
+        }
+
+        int demandeId = (int) tableModel.getValueAt(selectedRow, 0);
+
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            // Verifier si la demande est bien 'finalisée' d'abord
+            String checkSql = "SELECT description, statut, avis_besoin, avis_benevole FROM demandes_aide WHERE id = ? ";
+            PreparedStatement checkStatement = connection.prepareStatement(checkSql);
+            checkStatement.setInt(1, demandeId);
+            ResultSet resultSet = checkStatement.executeQuery();
+
+            if (resultSet.next()) {
+                String currentStatus = resultSet.getString("statut");
+
+                if ("finalisée".equals(currentStatus)) {
+                    // Affichage seulement si le statut est 'finalisée'
+                    String desc = resultSet.getString("description");
+                    String avis_besoin = resultSet.getString("avis_besoin");
+                    String avis_benevole = resultSet.getString("avis_benevole");
+
+                    String texte_avis =
+                                    "Description de la demande:\n" +
+                                    desc +
+                                    "\n___________________________________________________\n" +
+                                    "Avis de la personne dans le besoin :\n" +
+                                    avis_besoin +
+                                    "\n___________________________________________________\n" +
+                                    "Avis du benevole en charge de la demande :\n" +
+                                    avis_benevole;
+
+                    JOptionPane.showMessageDialog(this, texte_avis);
+                } else {
+                    // Statut n'est pas 'finalisée'
+                    JOptionPane.showMessageDialog(this, "Avis non affichés car la demande n'est pas 'finalisée'. (Statut actuel : " + currentStatus + ")");
+                }
+                loadAnciennesDemandes();  // Recharger les demandes après tentative/réssuite de l'affichage des avis
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+            JOptionPane.showMessageDialog(this, "Erreur lors de l'affichage des avis.");
+        }
+    }
+
+    // Méthode pour rejeter une demande
+    private void modifierAvis() {
+        int selectedRow = demandesTable.getSelectedRow();
+        if (selectedRow == -1) {
+            JOptionPane.showMessageDialog(this, "Veuillez sélectionner une demande dont vous voulez modifier l'avis.");
+            return;
+        }
+
+        int demandeId = (int) tableModel.getValueAt(selectedRow, 0);
+
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            // Verifier si la demande est bien 'finalisée' d'abord
+            String checkSql = "SELECT statut FROM demandes_aide WHERE id = ? ";
+            PreparedStatement checkStatement = connection.prepareStatement(checkSql);
+            checkStatement.setInt(1, demandeId);
+            ResultSet resultSet = checkStatement.executeQuery();
+
+            if (resultSet.next()) {
+                String currentStatus = resultSet.getString("statut");
+
+                if ("finalisée".equals(currentStatus)) {
+                    String avis = JOptionPane.showInputDialog(this, "Veuillez entrer votre avis (500 caractères max):", "Modification de l'avis", JOptionPane.PLAIN_MESSAGE);
+
+                    if (!avis.isEmpty()) {
+                        String sql = "UPDATE demandes_aide SET avis_besoin = ? WHERE id = ?";
+                        PreparedStatement statement = connection.prepareStatement(sql);
+                        statement.setString(1, avis);
+                        statement.setInt(2, demandeId);
+                        statement.executeUpdate();
+
+                        JOptionPane.showMessageDialog(this, "Avis modifié avec succès.");
+                    } else {
+                        JOptionPane.showMessageDialog(this, "Votre avis ne peut pas être vide.");
+                    }
+                } else {
+                    // Statut n'est pas 'finalisée'
+                    JOptionPane.showMessageDialog(this, "Vous ne pouvez pas modifier l'avis car la demande n'est pas 'finalisée'. (Statut actuel : " + currentStatus + ")");
+                }
+                loadAnciennesDemandes();  // Recharger les demandes après tentative/réssuite de modification de l'avis
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+            JOptionPane.showMessageDialog(this, "Erreur lors de la modification de l'avis.");
+        }
+    }
+
+    // Méthode pour charger les anciennes demandes
+    private void loadAnciennesDemandes() {
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            String sql =
+                    "SELECT demandes_aide.id, demandes_aide.description, demandes_aide.statut, utilisateur.nom " +
+                    "FROM demandes_aide " +
+                    "LEFT JOIN utilisateur " +
+                    "ON demandes_aide.benevole_id = utilisateur.id " +
+                    "AND utilisateur.role = 'benevole' " +
+                    "WHERE demandes_aide.utilisateur_id = ? " +
+                    "ORDER BY demandes_aide.statut ;";
+            PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setInt(1, utilisateurId);
+            ResultSet resultSet = statement.executeQuery();
+
+            tableModel.setRowCount(0);  // Réinitialiser le tableau
+            while (resultSet.next()) {
+                int id = resultSet.getInt("id");
+                String description = resultSet.getString("description");
+                String statut = resultSet.getString("statut");
+                String nom = resultSet.getString("nom");
+
+                tableModel.addRow(new Object[]{id, description, statut, nom});
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+            JOptionPane.showMessageDialog(this, "Erreur lors du chargement des demandes.");
+        }
+    }
+
+    public static void main(String[] args) {
+        SoumettreDemande soumettreDemande = new SoumettreDemande(1);  // Test avec un utilisateur par défaut
+        soumettreDemande.setVisible(true);
+    }
 }

src/main/java/controller/Validateur.java

@@ -0,0 +1,159 @@
+package controller;
+
+import database.DatabaseConnection;
+
+import javax.swing.*;
+import javax.swing.table.DefaultTableModel;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+public class Validateur extends JFrame {
+    private JTable table;
+    private DefaultTableModel tableModel;
+    private JButton validerButton;
+    private JButton rejeterButton; // Nouveau bouton pour rejeter
+    private JButton retourButton;  // Bouton pour retourner à la connexion
+    private int utilisateurId;
+
+    public Validateur(int utilisateurId) {
+        this.utilisateurId = utilisateurId;
+        setTitle("Page de validation des demandes");
+        setSize(600, 400);
+        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        setLocationRelativeTo(null);
+
+        // Tableau pour afficher les demandes
+        tableModel = new DefaultTableModel(new String[]{"ID", "Description", "Statut"}, 0);
+        table = new JTable(tableModel);
+        JScrollPane scrollPane = new JScrollPane(table);
+
+        // Boutons pour valider, rejeter et retourner
+        validerButton = new JButton("Valider la demande");
+        rejeterButton = new JButton("Rejeter la demande");  // Ajout du bouton pour rejeter
+        retourButton = new JButton("Retour à la connexion");
+
+        JPanel buttonPanel = new JPanel();
+        buttonPanel.add(validerButton);
+        buttonPanel.add(rejeterButton);  // Ajouter le bouton de rejet
+        buttonPanel.add(retourButton);
+
+        getContentPane().add(scrollPane, "Center");
+        getContentPane().add(buttonPanel, "South");
+
+        // Charger les demandes en attente
+        loadDemandesEnAttente();
+
+        // ActionListener pour valider une demande
+        validerButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                validerDemande();
+            }
+        });
+
+        // ActionListener pour rejeter une demande
+        rejeterButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                rejeterDemande();
+            }
+        });
+
+        // ActionListener pour retourner à la page de connexion
+        retourButton.addActionListener(new ActionListener() {
+            @Override
+            public void actionPerformed(ActionEvent e) {
+                LoginPage loginPage = new LoginPage();
+                loginPage.setVisible(true);
+                dispose();  // Fermer la page validateur
+            }
+        });
+    }
+
+    //Méthodes de type get()
+    public JTable getTable() {return this.table;}
+    public DefaultTableModel getTableModel() {return this.tableModel;}
+    public JButton getValiderButton() {return this.validerButton;}
+    public JButton getRejeterButton() {return this.rejeterButton;}
+    public JButton getRetourButton() {return this.retourButton;}
+    public int getID() {return this.utilisateurId;}
+
+    // Méthode pour charger les demandes en attente
+    private void loadDemandesEnAttente() {
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            String sql = "SELECT id, description, statut FROM demandes_aide WHERE statut = 'soumise'";
+            PreparedStatement statement = connection.prepareStatement(sql);
+            ResultSet resultSet = statement.executeQuery();
+
+            tableModel.setRowCount(0);
+            while (resultSet.next()) {
+                int id = resultSet.getInt("id");
+                String description = resultSet.getString("description");
+                String statut = resultSet.getString("statut");
+
+                tableModel.addRow(new Object[]{id, description, statut});
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+    }
+
+    // Méthode pour valider une demande
+    private void validerDemande() {
+        int selectedRow = table.getSelectedRow();
+        if (selectedRow == -1) {
+            JOptionPane.showMessageDialog(this, "Veuillez sélectionner une demande à valider.");
+            return;
+        }
+
+        int demandeId = (int) tableModel.getValueAt(selectedRow, 0);
+
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            String sql = "UPDATE demandes_aide SET statut = 'acceptée' WHERE id = ?";
+            PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setInt(1, demandeId);
+            statement.executeUpdate();
+
+            JOptionPane.showMessageDialog(this, "Demande validée avec succès.");
+            loadDemandesEnAttente();  // Recharger les demandes
+        } catch (SQLException e) {
+            e.printStackTrace();
+            JOptionPane.showMessageDialog(this, "Erreur lors de la validation de la demande.");
+        }
+    }
+
+    // Méthode pour rejeter une demande
+    private void rejeterDemande() {
+        int selectedRow = table.getSelectedRow();
+        if (selectedRow == -1) {
+            JOptionPane.showMessageDialog(this, "Veuillez sélectionner une demande à rejeter.");
+            return;
+        }
+
+        int demandeId = (int) tableModel.getValueAt(selectedRow, 0);
+        String motif_rejet = JOptionPane.showInputDialog(this, "Veuillez entrer un motif de rejet (500 caractères max):", "Motif de rejet", JOptionPane.PLAIN_MESSAGE);
+
+        if (!motif_rejet.isEmpty()) {
+            try (Connection connection = DatabaseConnection.getConnection()) {
+                String sql = "UPDATE demandes_aide SET statut = 'rejetée', motif_rejet = ? WHERE id = ?";
+                PreparedStatement statement = connection.prepareStatement(sql);
+                statement.setString(1, motif_rejet);
+                statement.setInt(2, demandeId);
+                statement.executeUpdate();
+
+                JOptionPane.showMessageDialog(this, "Demande rejetée avec succès.");
+                loadDemandesEnAttente();  // Recharger les demandes
+            } catch (SQLException e) {
+                e.printStackTrace();
+                JOptionPane.showMessageDialog(this, "Erreur lors du rejet de la demande.");
+            }
+        } else {
+            JOptionPane.showMessageDialog(this, "Le motif de rejet ne peut pas être vide.");
+        }
+    }
+
+}

src/main/java/database/DatabaseConnection.java

@@ -5,11 +5,23 @@ import java.sql.DriverManager;
 import java.sql.SQLException;
 
 public class DatabaseConnection {
-    private static final String URL = "jdbc:mysql://localhost:3306/aide_personnes_db";
-    private static final String USER = "root";
-    private static final String PASSWORD = "@Abdo2001elouali"; 
+
+    static final String URL = System.getenv("DB_URL") != null ?
+            System.getenv("DB_URL") : "jdbc:mysql://srv-bdens.insa-toulouse.fr:3306/projet_gei_023?useUnicode=true&characterEncoding=UTF-8";
+    private static final String USER = System.getenv("DB_USER") != null ?
+            System.getenv("DB_USER") : "projet_gei_023";
+    private static final String PASSWORD = System.getenv("DB_PASSWORD") != null ?
+            System.getenv("DB_PASSWORD") : "ohQu4ood";
 
     public static Connection getConnection() throws SQLException {
-        return DriverManager.getConnection(URL, USER, PASSWORD);
+        return DriverManager.getConnection(URL, getUser(), getPassword());
+    }
+
+	public static String getUser() {
+		return USER;
+	}
+
+	public static String getPassword() {
+		return PASSWORD;
 	}
 }

src/test/java/controller/BenevoleDemandesEncoursPageTest.java

@@ -0,0 +1,192 @@
+
+
+package controller;
+import database.DatabaseConnection;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.BeforeEach;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class BenevoleDemandesEncoursPageTest {
+    private BenevoleDemandesEncoursPage page;
+    private int utilisateurID = 1;  // ID utilisateur arbitraire pour le test
+    private int benevoleID = 2;
+    private int demandeID;      // ID de demande fictif pour le test
+
+    @BeforeEach
+    void setUp() throws SQLException {
+        // Initialiser la page de test
+        page = new BenevoleDemandesEncoursPage(benevoleID);
+    }
+
+    @Test
+    void testFinaliserDemande() {
+        //on crée une demande avec le statut 'en cours' pour tester la méthode finaliserDemande()
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            String insertSQL = "INSERT INTO demandes_aide (statut, utilisateur_id, benevole_id, description) VALUES (?, ?, ?, ?)";
+            PreparedStatement insertStatement = connection.prepareStatement(insertSQL, PreparedStatement.RETURN_GENERATED_KEYS);
+            insertStatement.setString(1, "en cours");
+            insertStatement.setInt(2, utilisateurID); // Aucun utilisateur affecté
+            insertStatement.setInt(3, benevoleID);  // Aucun bénévole affecté initialement
+            insertStatement.setString(4, "Demande de test pour JUnit / Test finaliserDemande");
+            insertStatement.executeUpdate();
+
+            // Récupération de l'ID généré pour pouvoir le supprimer après
+            ResultSet generatedKeys = insertStatement.getGeneratedKeys();
+            if (generatedKeys.next()) {
+                demandeID = generatedKeys.getInt(1);
+            }
+
+            // on met à jour la table avec la nouvelle demande rajoutée
+            // on utilise une méthode détournée pour accéder à la méthode private 'loadDemandesEnCours()'
+            Method loadDemandesEnCoursMethod = BenevoleDemandesEncoursPage.class.getDeclaredMethod("loadDemandesEnCours");
+            loadDemandesEnCoursMethod.setAccessible(true); // permet d'appeler la méthode même si elle est private
+            loadDemandesEnCoursMethod.invoke(page); // on l'appele
+
+            //test de prendreDemande(); on sélectionne la dernière ligne de la table car elle correspond à la demande test
+            int lastRow = page.getTable().getRowCount()-1;
+            page.getTable().setRowSelectionInterval(lastRow, lastRow);
+
+            // idem que pour loadDemandesEnCours() comme finaliserDemande() est aussi en private
+            Method finaliserDemandeMethod = BenevoleDemandesEncoursPage.class.getDeclaredMethod("finaliserDemande");
+            finaliserDemandeMethod.setAccessible(true);  // permet d'appeler la méthode même si elle est private
+            finaliserDemandeMethod.invoke(page);  // on l'appele
+
+            // on attend un moment pour que la base de données se mette à jour
+            Thread.sleep(1000);
+
+            String sql = "SELECT statut FROM demandes_aide WHERE id = ?";
+            PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setInt(1, demandeID);
+            ResultSet resultSet = statement.executeQuery();
+
+            String currentStatus = "";
+            if (resultSet.next()) {
+                currentStatus = resultSet.getString("statut");
+            }
+
+            assertEquals("finalisée", currentStatus, "Le statut doit être 'finalisée'.");
+
+            // Suppression de la demande de test après le test de prendreDemande()
+            String deleteSQL = "DELETE FROM demandes_aide WHERE id = ?";
+            PreparedStatement deleteStatement = connection.prepareStatement(deleteSQL);
+            deleteStatement.setInt(1, demandeID);
+            deleteStatement.executeUpdate();
+        } catch (InterruptedException | InvocationTargetException | NoSuchMethodException | IllegalAccessException |
+                 SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Test
+    void testLoadDemandesEnCours() {
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            //on crée un utilisateur test pour charger et tester uniquement les demandes de test, pas celles existantes
+            int testUserID = -1;
+            String testUserNom = "Test Mc Testy";
+            String testUserEmail = "test@example.com";
+            String testUserRole = "benevole"; // l'utilisateur de test doit être un bénévole pour pouvoir tester la méthode
+            String insertSQL0 = "INSERT INTO utilisateur (nom, email, role) VALUES (?, ?, ?)";
+            PreparedStatement insertStatement0 = connection.prepareStatement(insertSQL0, PreparedStatement.RETURN_GENERATED_KEYS);
+            insertStatement0.setString(1, testUserNom);
+            insertStatement0.setString(2, testUserEmail);
+            insertStatement0.setString(3, testUserRole);
+            insertStatement0.executeUpdate();
+
+            // Récupération de l'ID du user de test généré pour pouvoir le supprimer après
+            ResultSet generatedKeysUser = insertStatement0.getGeneratedKeys();
+            if (generatedKeysUser.next()) {
+                testUserID = generatedKeysUser.getInt(1);
+            }
+
+            //on met une première demande test dans la bdd
+            String desc = "Demande de test pour JUnit / Test loadDemandesEnCours";
+            String insertSQL = "INSERT INTO demandes_aide (statut, utilisateur_id, benevole_id, description) VALUES (?, ?, ?, ?)";
+            PreparedStatement insertStatement = connection.prepareStatement(insertSQL, PreparedStatement.RETURN_GENERATED_KEYS);
+            insertStatement.setString(1, "en cours");
+            insertStatement.setInt(2, utilisateurID);
+            insertStatement.setInt(3, benevoleID);
+            insertStatement.setString(4, desc);
+            insertStatement.executeUpdate();
+
+            // Récupération de l'ID généré pour pouvoir le supprimer après
+            ResultSet generatedKeys = insertStatement.getGeneratedKeys();
+            if (generatedKeys.next()) {
+                demandeID = generatedKeys.getInt(1);
+            }
+
+            //on rajoute deux autres demandes pour tester l'affichage
+            String desc2 = "Demande de test pour JUnit / Test loadDemandesEnCours 2";
+            String insertSQL2 = "INSERT INTO demandes_aide (statut, utilisateur_id, benevole_id, description) VALUES (?, ?, ?, ?)";
+            PreparedStatement insertStatement2 = connection.prepareStatement(insertSQL2, PreparedStatement.RETURN_GENERATED_KEYS);
+            insertStatement2.setString(1, "en cours");
+            insertStatement2.setInt(2, utilisateurID);
+            insertStatement2.setInt(3, benevoleID);
+            insertStatement2.setString(4, desc2);
+            insertStatement2.executeUpdate();
+
+            String desc3 = "Demande de test pour JUnit / Test loadDemandesEnCours 2";
+            String insertSQL3 = "INSERT INTO demandes_aide (statut, utilisateur_id, benevole_id, description) VALUES (?, ?, ?, ?)";
+            PreparedStatement insertStatement3 = connection.prepareStatement(insertSQL3, PreparedStatement.RETURN_GENERATED_KEYS);
+            insertStatement3.setString(1, "en cours");
+            insertStatement3.setInt(2, utilisateurID);
+            insertStatement3.setInt(3, benevoleID);
+            insertStatement3.setString(4, desc3);
+            insertStatement3.executeUpdate();
+
+            // on met à jour la table avec les nouvelles demandes rajoutées
+            // on utilise une méthode détournée pour accéder à la méthode private 'loadDemandesEnCours()'
+            Method loadDemandesEnCoursMethod = BenevoleDemandesEncoursPage.class.getDeclaredMethod("loadDemandesEnCours");
+            loadDemandesEnCoursMethod.setAccessible(true); // permet d'appeler la méthode même si elle est private
+            loadDemandesEnCoursMethod.invoke(page); // on l'appele
+
+            //on marque l'id de la dernière ligne du tableau affiché
+            int lastRow = page.getTable().getRowCount()-1;
+
+            //on sélectionne les descriptions des 3 dernières lignes de la table car elles correspondent aux 3 demandes test
+            //on récupère toutes les descriptions chargées dans la page (chaque ligne uniquement pour la colonne description)
+            String desc_actual;
+            desc_actual = (String) page.getTableModel().getValueAt((lastRow-2), 1) +
+                          page.getTableModel().getValueAt((lastRow-1), 1) +
+                          page.getTableModel().getValueAt(lastRow, 1);
+
+
+            String desc_expected = desc + desc2 + desc3;
+            assertEquals(desc_expected, desc_actual, "La description combinée doit être : " + desc_expected);
+
+            // Suppression des demande de test après le test de prendreDemande()
+            //les id se suivent donc on a juste besoin de un seul demandeID
+            String deleteSQL = "DELETE FROM demandes_aide WHERE id = ?";
+            PreparedStatement deleteStatement = connection.prepareStatement(deleteSQL);
+            deleteStatement.setInt(1, demandeID);
+            deleteStatement.executeUpdate();
+
+            String deleteSQL2 = "DELETE FROM demandes_aide WHERE id = ?";
+            PreparedStatement deleteStatement2 = connection.prepareStatement(deleteSQL2);
+            deleteStatement2.setInt(1, (demandeID+1));
+            deleteStatement2.executeUpdate();
+
+            String deleteSQL3 = "DELETE FROM demandes_aide WHERE id = ?";
+            PreparedStatement deleteStatement3 = connection.prepareStatement(deleteSQL3);
+            deleteStatement3.setInt(1, (demandeID+2));
+            deleteStatement3.executeUpdate();
+
+            //on supprime également l'user test
+            String deleteSQLUser = "DELETE FROM utilisateur WHERE id = ?";
+            PreparedStatement deleteStatementUser = connection.prepareStatement(deleteSQLUser);
+            deleteStatementUser.setInt(1, testUserID);
+            deleteStatementUser.executeUpdate();
+        } catch (InvocationTargetException | NoSuchMethodException | IllegalAccessException |
+                 SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+}

src/test/java/controller/BenevoleDemandesFinaliseesPageTest.java

@@ -0,0 +1,197 @@
+package controller;
+
+import database.DatabaseConnection;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class BenevoleDemandesFinaliseesPageTest {
+    private BenevoleDemandesFinaliseesPage page;
+    private int utilisateurID = 1;  // ID utilisateur arbitraire pour le test
+    private int benevoleID = 2;     // ID du bénévole pour le test
+    private int demandeID;          // ID de la demande de test
+
+    @BeforeEach
+    void setUp() throws SQLException {
+        // Initialiser la page de test
+        page = new BenevoleDemandesFinaliseesPage(benevoleID);
+    }
+
+    @Test
+    void testLoadDemandesFinalisees() {
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            // Créer trois demandes tests
+            String desc1 = "Demande de test 1 pour JUnit / Test loadDemandesFinalisees";
+            String desc2 = "Demande de test 2 pour JUnit / Test loadDemandesFinalisees";
+            String desc3 = "Demande de test 3 pour JUnit / Test loadDemandesFinalisees";
+
+            // Insertion de la première demande
+            String insertSQL = "INSERT INTO demandes_aide (statut, utilisateur_id, benevole_id, description) VALUES (?, ?, ?, ?)";
+            PreparedStatement insertStatement = connection.prepareStatement(insertSQL, PreparedStatement.RETURN_GENERATED_KEYS);
+            insertStatement.setString(1, "finalisée");
+            insertStatement.setInt(2, utilisateurID);
+            insertStatement.setInt(3, benevoleID);
+            insertStatement.setString(4, desc1);
+            insertStatement.executeUpdate();
+
+            ResultSet generatedKeys = insertStatement.getGeneratedKeys();
+            if (generatedKeys.next()) {
+                demandeID = generatedKeys.getInt(1);
+            }
+
+            // Insertion des autres demandes
+            insertStatement.setString(4, desc2);
+            insertStatement.executeUpdate();
+            insertStatement.setString(4, desc3);
+            insertStatement.executeUpdate();
+
+            // Charger les demandes dans la table
+            Method loadDemandesFinaliseesMethod = BenevoleDemandesFinaliseesPage.class.getDeclaredMethod("loadDemandesFinalisees");
+            loadDemandesFinaliseesMethod.setAccessible(true);
+            loadDemandesFinaliseesMethod.invoke(page);
+
+            // Vérifier que les descriptions sont bien chargées
+            int lastRow = page.getTable().getRowCount() - 1;
+            String desc_actual = (String) page.getTableModel().getValueAt(lastRow-2, 1) +
+                               (String) page.getTableModel().getValueAt(lastRow-1, 1) +
+                               (String) page.getTableModel().getValueAt(lastRow, 1);
+
+            String desc_expected = desc1 + desc2 + desc3;
+            assertEquals(desc_expected, desc_actual, "Les descriptions doivent correspondre");
+
+            // Nettoyage des données de test
+            for (int i = 0; i < 3; i++) {
+                String deleteSQL = "DELETE FROM demandes_aide WHERE id = ?";
+                PreparedStatement deleteStatement = connection.prepareStatement(deleteSQL);
+                deleteStatement.setInt(1, demandeID + i);
+                deleteStatement.executeUpdate();
+            }
+
+        } catch (SQLException | NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Test
+    void testModifierAvisForFinalizedRequest() {
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            // Créer une demande finalisée de test
+            String insertSQL = "INSERT INTO demandes_aide (statut, utilisateur_id, benevole_id, description, avis_benevole) VALUES (?, ?, ?, ?, ?)";
+            PreparedStatement insertStatement = connection.prepareStatement(insertSQL, PreparedStatement.RETURN_GENERATED_KEYS);
+            insertStatement.setString(1, "finalisée");
+            insertStatement.setInt(2, utilisateurID);
+            insertStatement.setInt(3, benevoleID);
+            insertStatement.setString(4, "Demande de test pour modification d'avis");
+            insertStatement.setString(5, "Avis initial");
+            insertStatement.executeUpdate();
+
+            ResultSet generatedKeys = insertStatement.getGeneratedKeys();
+            if (generatedKeys.next()) {
+                demandeID = generatedKeys.getInt(1);
+            }
+
+            // Charger la demande dans la table
+            Method loadDemandesFinaliseesMethod = BenevoleDemandesFinaliseesPage.class.getDeclaredMethod("loadDemandesFinalisees");
+            loadDemandesFinaliseesMethod.setAccessible(true);
+            loadDemandesFinaliseesMethod.invoke(page);
+
+            // Sélectionner la demande
+            int lastRow = page.getTable().getRowCount() - 1;
+            page.getTable().setRowSelectionInterval(lastRow, lastRow);
+
+            // Modifier l'avis
+            Method modifierAvisMethod = BenevoleDemandesFinaliseesPage.class.getDeclaredMethod("modifierAvis");
+            modifierAvisMethod.setAccessible(true);
+            modifierAvisMethod.invoke(page);
+
+            Thread.sleep(1000); // Attendre la mise à jour
+
+            // Vérifier la modification
+            String checkSQL = "SELECT avis_benevole FROM demandes_aide WHERE id = ?";
+            PreparedStatement checkStatement = connection.prepareStatement(checkSQL);
+            checkStatement.setInt(1, demandeID);
+            ResultSet resultSet = checkStatement.executeQuery();
+
+            assertTrue(resultSet.next(), "La demande doit exister");
+            String nouvelAvis = resultSet.getString("avis_benevole");
+            assertNotEquals("Avis initial", nouvelAvis, "L'avis doit être modifié");
+
+            // Nettoyage
+            String deleteSQL = "DELETE FROM demandes_aide WHERE id = ?";
+            PreparedStatement deleteStatement = connection.prepareStatement(deleteSQL);
+            deleteStatement.setInt(1, demandeID);
+            deleteStatement.executeUpdate();
+
+        } catch (SQLException | NoSuchMethodException | IllegalAccessException | InvocationTargetException | InterruptedException e) {
+            throw new RuntimeException(e);
+        }
+    }
+    
+    @Test
+    void testAfficherAvis() {
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            // Créer une demande finalisée avec des avis
+            String description = "Demande test pour affichage des avis";
+            String avisBenevole = "Avis du bénévole test";
+            String avisBesoin = "Avis de la personne test";
+            
+            String insertSQL = "INSERT INTO demandes_aide (statut, utilisateur_id, benevole_id, description, avis_benevole, avis_besoin) VALUES (?, ?, ?, ?, ?, ?)";
+            PreparedStatement insertStatement = connection.prepareStatement(insertSQL, PreparedStatement.RETURN_GENERATED_KEYS);
+            insertStatement.setString(1, "finalisée");
+            insertStatement.setInt(2, utilisateurID);
+            insertStatement.setInt(3, benevoleID);
+            insertStatement.setString(4, description);
+            insertStatement.setString(5, avisBenevole);
+            insertStatement.setString(6, avisBesoin);
+            insertStatement.executeUpdate();
+
+            // Récupérer l'ID de la demande créée
+            ResultSet generatedKeys = insertStatement.getGeneratedKeys();
+            if (generatedKeys.next()) {
+                demandeID = generatedKeys.getInt(1);
+            }
+
+            // Charger la demande dans la table
+            Method loadDemandesFinaliseesMethod = BenevoleDemandesFinaliseesPage.class.getDeclaredMethod("loadDemandesFinalisees");
+            loadDemandesFinaliseesMethod.setAccessible(true);
+            loadDemandesFinaliseesMethod.invoke(page);
+
+            // Sélectionner la demande
+            int lastRow = page.getTable().getRowCount() - 1;
+            page.getTable().setRowSelectionInterval(lastRow, lastRow);
+
+            // Exécuter l'affichage des avis
+            Method afficherAvisMethod = BenevoleDemandesFinaliseesPage.class.getDeclaredMethod("afficherAvis");
+            afficherAvisMethod.setAccessible(true);
+            afficherAvisMethod.invoke(page);
+
+            // Vérifier que les avis sont corrects dans la base de données
+            String checkSQL = "SELECT avis_benevole, avis_besoin, description FROM demandes_aide WHERE id = ?";
+            PreparedStatement checkStatement = connection.prepareStatement(checkSQL);
+            checkStatement.setInt(1, demandeID);
+            ResultSet resultSet = checkStatement.executeQuery();
+
+            assertTrue(resultSet.next(), "La demande doit exister");
+            assertEquals(avisBenevole, resultSet.getString("avis_benevole"), "TEST L'avis du bénévole doit correspondre");
+            assertEquals(avisBesoin, resultSet.getString("avis_besoin"), "TEST L'avis de la personne doit correspondre");
+            assertEquals(description, resultSet.getString("description"), "TEST La description doit correspondre");
+
+            // Nettoyage
+            String deleteSQL = "DELETE FROM demandes_aide WHERE id = ?";
+            PreparedStatement deleteStatement = connection.prepareStatement(deleteSQL);
+            deleteStatement.setInt(1, demandeID);
+            deleteStatement.executeUpdate();
+
+        } catch (SQLException | NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/test/java/controller/BenevoleDemandesPageTest.java

@@ -0,0 +1,199 @@
+package controller;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import javax.swing.*;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.sql.SQLException;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+
+import database.DatabaseConnection;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class BenevoleDemandesPageTest {
+
+    private BenevoleDemandesPage benevoleDemandesPage;
+    private int benevoleID = 2; //pour tester on prend arbitrairement un utilisateur qui est un bénévole
+    private int demandeID; //on crée manuellment une demande pour les tests (on la supprime après)
+
+    @BeforeEach
+    void setUp() {
+        //on crée la page des demandes acceptés
+        benevoleDemandesPage = new BenevoleDemandesPage(benevoleID);
+    }
+
+    @Test
+    void testBenevoleDemandesPage() {
+        // Vérifier si la page des demandes de bénévoles est bien créée
+        assertNotNull(benevoleDemandesPage);
+        assertEquals(benevoleID,benevoleDemandesPage.getID(),"id pas correct");
+    }
+
+    @Test
+    void testListeDemandesNonVide() {
+        try {
+            // on utilise une méthode détournée pour accéder à la méthode private 'loadDemandesAcceptees()'
+            Method loadDemandesAccepteesMethod = BenevoleDemandesPage.class.getDeclaredMethod("loadDemandesAcceptees");
+            loadDemandesAccepteesMethod.setAccessible(true); // permet d'appeler la méthode même si elle est private
+            loadDemandesAccepteesMethod.invoke(benevoleDemandesPage); // on l'appele
+
+            // Vérifie si la liste des demandes a bien été chargée
+            assertNotNull(benevoleDemandesPage.getTable());
+            assertNotNull(benevoleDemandesPage.getTableModel());
+        } catch (InvocationTargetException | NoSuchMethodException | IllegalAccessException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Test
+    void testPrendreDemande() {
+        //on crée une demande avec le statut 'acceptée' pour tester la méthode prendreDemande()
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            String insertSQL = "INSERT INTO demandes_aide (statut, utilisateur_id, benevole_id, description) VALUES (?, ?, ?, ?)";
+            PreparedStatement insertStatement = connection.prepareStatement(insertSQL, PreparedStatement.RETURN_GENERATED_KEYS);
+            insertStatement.setString(1, "acceptée");
+            insertStatement.setNull(2, java.sql.Types.INTEGER); // Aucun utilisateur affecté
+            insertStatement.setNull(3, java.sql.Types.INTEGER);  // Aucun bénévole affecté initialement
+            insertStatement.setString(4, "Demande de test pour JUnit / Test prendreDemande");
+            insertStatement.executeUpdate();
+
+            // Récupération de l'ID généré pour pouvoir le supprimer après
+            ResultSet generatedKeys = insertStatement.getGeneratedKeys();
+            if (generatedKeys.next()) {
+                demandeID = generatedKeys.getInt(1);
+            }
+
+            // on met à jour la table avec la nouvelle demande rajoutée
+            // on utilise une méthode détournée pour accéder à la méthode private 'loadDemandesAcceptees()'
+            Method loadDemandesAccepteesMethod = BenevoleDemandesPage.class.getDeclaredMethod("loadDemandesAcceptees");
+            loadDemandesAccepteesMethod.setAccessible(true); // permet d'appeler la méthode même si elle est private
+            loadDemandesAccepteesMethod.invoke(benevoleDemandesPage); // on l'appele
+
+            //test de prendreDemande(); on sélectionne la dernière ligne de la table car elle correspond à la demande test
+            int lastRow = benevoleDemandesPage.getTable().getRowCount()-1;
+            benevoleDemandesPage.getTable().setRowSelectionInterval(lastRow, lastRow);
+
+            // idem que pour loadDemandesAcceptees() comme prendreDemande() est aussi en private
+            Method prendreDemandeMethod = BenevoleDemandesPage.class.getDeclaredMethod("prendreDemande");
+            prendreDemandeMethod.setAccessible(true);  // permet d'appeler la méthode même si elle est private
+            prendreDemandeMethod.invoke(benevoleDemandesPage);  // on l'appele
+
+            // on attend un moment pour que la base de données se mette à jour
+            Thread.sleep(1000);
+
+            String sql = "SELECT statut, benevole_id FROM demandes_aide WHERE id = ?";
+            PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setInt(1, demandeID);
+            ResultSet resultSet = statement.executeQuery();
+
+            String currentStatus = "";
+            int currentBenevole = -1;
+            if (resultSet.next()) {
+                currentStatus = resultSet.getString("statut");
+                currentBenevole = resultSet.getInt("benevole_id");
+            }
+
+            assertEquals("en cours", currentStatus, "Le statut doit être 'en cours'.");
+            assertEquals(benevoleID, currentBenevole, "L'id du bénévole n'a pas correctement été attribué.");
+
+            // Suppression de la demande de test après le test de prendreDemande()
+            String deleteSQL = "DELETE FROM demandes_aide WHERE id = ?";
+            PreparedStatement deleteStatement = connection.prepareStatement(deleteSQL);
+            deleteStatement.setInt(1, demandeID);
+            deleteStatement.executeUpdate();
+        } catch (InterruptedException | InvocationTargetException | NoSuchMethodException | IllegalAccessException |
+                 SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+
+    @Test
+    void testPrendreDemandeNonSelectionnee() {
+        // Désélectionner toute ligne pour simuler l'absence de sélection
+        benevoleDemandesPage.getTable().clearSelection();
+
+        // on enregistre l'état avant l'appel de la méthode
+        int rowCountBefore = benevoleDemandesPage.getTableModel().getRowCount();
+
+        //test de prendreDemande() sans rien sélectionner
+        JButton prendreButton = benevoleDemandesPage.getPrendreDemandeButton();
+        prendreButton.doClick();
+
+        // on vérifier que l'état de la table n'a pas changé (la table n'a pas été modifiée)
+        int rowCountAfter = benevoleDemandesPage.getTableModel().getRowCount();
+        assertEquals(rowCountBefore, rowCountAfter, "La table ne doit pas être modifiée si aucune demande n'est sélectionnée.");
+    }
+    
+    
+    @Test
+    void testLoadDemandesAcceptees() {
+        try (Connection connection = DatabaseConnection.getConnection()) {
+        	//commit test
+            // Créer trois demandes tests avec le statut 'acceptée'
+            String desc1 = "Demande 1 test pour JUnit / Test loadDemandesAcceptees";
+            String desc2 = "Demande 2 test pour JUnit / Test loadDemandesAcceptees";
+            String desc3 = "Demande 3 test pour JUnit / Test loadDemandesAcceptees";
+
+            // Création des demandes tests
+            String insertSQL = "INSERT INTO demandes_aide (statut, description) VALUES (?, ?)";
+            PreparedStatement insertStatement = connection.prepareStatement(insertSQL, PreparedStatement.RETURN_GENERATED_KEYS);
+            
+            // Première demande
+            insertStatement.setString(1, "acceptée");
+            insertStatement.setString(2, desc1);
+            insertStatement.executeUpdate();
+
+            // Récupérer l'ID de la première demande
+            ResultSet generatedKeys = insertStatement.getGeneratedKeys();
+            if (generatedKeys.next()) {
+                demandeID = generatedKeys.getInt(1);
+            }
+
+            // Deuxième et troisième demandes
+            insertStatement.setString(2, desc2);
+            insertStatement.executeUpdate();
+            insertStatement.setString(2, desc3);
+            insertStatement.executeUpdate();
+
+            // Charger les demandes dans la table
+            Method loadDemandesAccepteesMethod = BenevoleDemandesPage.class.getDeclaredMethod("loadDemandesAcceptees");
+            loadDemandesAccepteesMethod.setAccessible(true);
+            loadDemandesAccepteesMethod.invoke(benevoleDemandesPage);
+
+            // Vérifier que les descriptions sont bien chargées
+            int lastRow = benevoleDemandesPage.getTable().getRowCount() - 1;
+            
+            // Vérifier que les trois dernières lignes correspondent à nos demandes de test
+            String desc_actual = (String) benevoleDemandesPage.getTableModel().getValueAt(lastRow-2, 1) +
+                               (String) benevoleDemandesPage.getTableModel().getValueAt(lastRow-1, 1) +
+                               (String) benevoleDemandesPage.getTableModel().getValueAt(lastRow, 1);
+
+            String desc_expected = desc1 + desc2 + desc3;
+            assertEquals(desc_expected, desc_actual, "Les descriptions doivent correspondre");
+
+            // Vérifier que le statut est 'acceptée' pour chaque demande
+            for (int i = 0; i < 3; i++) {
+                String status = (String) benevoleDemandesPage.getTableModel().getValueAt(lastRow-i, 2);
+                assertEquals("acceptée", status, "Le statut doit être 'acceptée'");
+            }
+
+            // Nettoyage des données de test
+            for (int i = 0; i < 3; i++) {
+                String deleteSQL = "DELETE FROM demandes_aide WHERE id = ?";
+                PreparedStatement deleteStatement = connection.prepareStatement(deleteSQL);
+                deleteStatement.setInt(1, demandeID + i);
+                deleteStatement.executeUpdate();
+            }
+
+        } catch (SQLException | NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+}

src/test/java/controller/CreateAccountPageTest.java

@@ -0,0 +1,125 @@
+package controller;
+
+import database.DatabaseConnection;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import javax.swing.*;
+import java.awt.event.ActionEvent;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class CreateAccountPageTest {
+
+    private CreateAccountPage createAccountPage;
+    private JTextField nomField;
+    private JTextField emailField;
+    private JComboBox<String> roleComboBox;
+    private JButton createAccountButton;
+    private JButton retourLoginButton;
+
+    @BeforeEach
+    void setUp() throws NoSuchFieldException, IllegalAccessException {
+        createAccountPage = new CreateAccountPage();
+
+        // Access private fields using reflection
+        nomField = (JTextField) getField("nomField");
+        emailField = (JTextField) getField("emailField");
+        roleComboBox = (JComboBox<String>) getField("roleComboBox");
+        createAccountButton = (JButton) getField("createAccountButton");
+        retourLoginButton = (JButton) getField("retourLoginButton");
+    }
+
+    // Helper method to access private fields
+    private Object getField(String fieldName) throws NoSuchFieldException, IllegalAccessException {
+        Field field = CreateAccountPage.class.getDeclaredField(fieldName);
+        field.setAccessible(true);
+        return field.get(createAccountPage);
+    }
+
+    @Test
+    void testCreateAccountPageComponents() {
+        assertNotNull(createAccountPage);
+        assertNotNull(nomField);
+        assertNotNull(emailField);
+        assertNotNull(roleComboBox);
+        assertNotNull(createAccountButton);
+        assertNotNull(retourLoginButton);
+
+        // Check default values and UI setup
+        assertEquals("", nomField.getText());
+        assertEquals("", emailField.getText());
+        assertEquals("benevole", roleComboBox.getSelectedItem());
+    }
+
+    @Test
+    void testCreateAccountWithValidData() throws SQLException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
+        // Set field values
+        nomField.setText("Test User");
+        emailField.setText("test@example.com");
+        roleComboBox.setSelectedItem("benevole");
+
+        // Access and invoke the createAccount() method using reflection
+        Method createAccountMethod = CreateAccountPage.class.getDeclaredMethod("createAccount");
+        createAccountMethod.setAccessible(true);
+        createAccountMethod.invoke(createAccountPage);
+
+        // Check that the user was added to the database
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            String sql = "SELECT * FROM utilisateur WHERE nom = ? AND email = ?";
+            PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setString(1, "Test User");
+            statement.setString(2, "test@example.com");
+            ResultSet resultSet = statement.executeQuery();
+
+            assertTrue(resultSet.next(), "L'utilisateur doit être ajouté à la base de données.");
+
+            // Clean up the inserted test data
+            String deleteSQL = "DELETE FROM utilisateur WHERE nom = ? AND email = ?";
+            PreparedStatement deleteStatement = connection.prepareStatement(deleteSQL);
+            deleteStatement.setString(1, "Test User");
+            deleteStatement.setString(2, "test@example.com");
+            deleteStatement.executeUpdate();
+        }
+    }
+
+    @Test
+    void testCreateAccountWithEmptyFields() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, SQLException {
+        // Set empty fields to simulate missing input
+        nomField.setText("");
+        emailField.setText("");
+
+        // Access and invoke the createAccount() method using reflection
+        Method createAccountMethod = CreateAccountPage.class.getDeclaredMethod("createAccount");
+        createAccountMethod.setAccessible(true);
+        createAccountMethod.invoke(createAccountPage);
+
+        // Check if the error message dialog was displayed (mocked by asserting the lack of database change)
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            String sql = "SELECT * FROM utilisateur WHERE nom = ? AND email = ?";
+            PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setString(1, "");
+            statement.setString(2, "");
+            ResultSet resultSet = statement.executeQuery();
+
+            assertFalse(resultSet.next(), "Aucun utilisateur ne doit être ajouté lorsque les champs sont vides.");
+        }
+    }
+
+    @Test
+    void testRetourLoginButton() {
+        // Simulate clicking the "Retour à la connexion" button
+        retourLoginButton.doClick();
+
+        // Check that the current frame is disposed
+        assertFalse(createAccountPage.isVisible(), "La page de création de compte devrait être fermée après avoir cliqué sur 'Retour à la connexion'.");
+    }
+
+}

src/test/java/controller/LoginPageTest.java

@@ -0,0 +1,78 @@
+package controller;
+
+import database.DatabaseConnection;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import javax.swing.*;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class LoginPageTest {
+
+    private LoginPage loginPage;
+    private JTextField emailField;
+    private JButton loginButton;
+    private JButton createAccountButton;
+
+    @BeforeEach
+    void setUp() {
+        loginPage = new LoginPage();
+        emailField = loginPage.getEmailField();
+        loginButton = loginPage.getLoginButton();
+        createAccountButton = loginPage.getCreateAccountButton();
+    }
+
+    @Test
+    void testLoginWithValidUser() throws SQLException {
+        // Set up a valid test user in the database
+        String email = "test@example.com";
+        
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            // Remove the user if it already exists (to avoid duplicates)
+            String deleteSQL = "DELETE FROM utilisateur WHERE email = ?";
+            PreparedStatement deleteStatement = connection.prepareStatement(deleteSQL);
+            deleteStatement.setString(1, email);
+            deleteStatement.executeUpdate();
+
+            // Insert a test user
+            String insertSQL = "INSERT INTO utilisateur (email, role, nom) VALUES (?, 'benevole', 'TestUser')";
+            PreparedStatement insertStatement = connection.prepareStatement(insertSQL);
+            insertStatement.setString(1, email);
+            insertStatement.executeUpdate();
+        }
+
+        // Simulate entering the email and clicking the login button
+        emailField.setText(email);
+        loginButton.doClick();
+
+        // Check if the login page closed after a successful login
+        assertFalse(loginPage.isVisible(), "LoginPage should close after a successful login.");
+
+        //delete user after test
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            String deleteSQL = "DELETE FROM utilisateur WHERE email = ?";
+            PreparedStatement deleteStatement = connection.prepareStatement(deleteSQL);
+            deleteStatement.setString(1, email);
+            deleteStatement.executeUpdate();
+        }
+    }
+
+    @Test
+    void testLoginWithInvalidEmail() {
+        emailField.setText("nonexistent@example.com");
+        loginButton.doClick();
+
+        // Verify that the email field contains the invalid email entered
+        assertEquals("nonexistent@example.com", emailField.getText(), "The entered email should remain in the email field.");
+    }
+
+    @Test
+    void testCreateAccountButtonAction() {
+        createAccountButton.doClick();
+        assertFalse(loginPage.isVisible(), "LoginPage should close after clicking 'Create Account'.");
+    }
+}

src/test/java/controller/MenuBenevoleTest.java

@@ -0,0 +1,62 @@
+package controller;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.function.Executable;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+
+class MenuBenevoleTest {
+    private MenuBenevole menu;
+    private int utilisateurId = 2; // ID fictif d'utilisateur pour les tests
+
+    @BeforeEach
+    void setUp() {
+        // Initialiser l'instance de MenuBenevole
+        menu = new MenuBenevole(utilisateurId);
+    }
+
+    @Test
+    void testVoirDemandesAcceptesButton() {
+        // Vérifie si l'action liée au bouton Voir demandes acceptées peut être exécutée sans exception
+        assertDoesNotThrow(new Executable() {
+			@Override
+			public void execute() throws Throwable {
+				menu.getVoirDemandesAcceptesButton().doClick();
+			}
+		});
+    }
+
+    @Test
+    void testVoirDemandesEnCoursButton() {
+        // Vérifie si l'action liée au bouton Voir demandes en cours peut être exécutée sans exception
+        assertDoesNotThrow(new Executable() {
+			@Override
+			public void execute() throws Throwable {
+				menu.getVoirDemandesEnCoursButton().doClick();
+			}
+		});
+    }
+
+    @Test
+    void testVoirDemandesFinaliseesButton() {
+        // Vérifie si l'action liée au bouton Voir demandes finalisées peut être exécutée sans exception
+        assertDoesNotThrow(new Executable() {
+			@Override
+			public void execute() throws Throwable {
+				menu.getVoirDemandesFinaliseesButton().doClick();
+			}
+		});
+    }
+
+    @Test
+    void testRetourButton() {
+        // Vérifie si l'action liée au bouton de retour peut être exécutée sans exception
+        assertDoesNotThrow(new Executable() {
+			@Override
+			public void execute() throws Throwable {
+				menu.getRetourButton().doClick();
+			}
+		});
+    }
+}

src/test/java/controller/SoumettreDemandeTest.java

@@ -0,0 +1,255 @@
+package controller;
+
+import database.DatabaseConnection;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import javax.swing.*;
+import javax.swing.table.DefaultTableModel;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class SoumettreDemandeTest {
+
+    private SoumettreDemande soumettreDemande;
+    private JTextField descriptionField;
+    private DefaultTableModel tableModel;
+    private int utilisateurID = 1; // utilisateur arbitraire qui va créer les demandes de test
+    private int demandeID;
+    private int benevoleID = 2;
+
+    @BeforeEach
+    void setUp() throws NoSuchFieldException, IllegalAccessException {
+        soumettreDemande = new SoumettreDemande(utilisateurID);
+
+        // Access private fields using reflection
+        descriptionField = (JTextField) getField("descriptionField");
+        tableModel = (DefaultTableModel) getField("tableModel");
+    }
+
+    // Helper method to access private fields
+    private Object getField(String fieldName) throws NoSuchFieldException, IllegalAccessException {
+        Field field = SoumettreDemande.class.getDeclaredField(fieldName);
+        field.setAccessible(true);
+        return field.get(soumettreDemande);
+    }
+
+    @Test
+    void testSoumettreDemandeWithValidDescription() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, SQLException {
+        descriptionField.setText("Test request description");
+
+        Method soumettreDemandeMethod = SoumettreDemande.class.getDeclaredMethod("soumettreDemande");
+        soumettreDemandeMethod.setAccessible(true);
+        soumettreDemandeMethod.invoke(soumettreDemande);
+
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            String sql = "SELECT description FROM demandes_aide WHERE description = ? AND utilisateur_id = ?";
+            PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setString(1, "Test request description");
+            statement.setInt(2, utilisateurID);
+            ResultSet resultSet = statement.executeQuery();
+
+            assertTrue(resultSet.next(), "The request should be added to the database.");
+
+            // Clean up test data
+            String deleteSQL = "DELETE FROM demandes_aide WHERE description = ?";
+            PreparedStatement deleteStatement = connection.prepareStatement(deleteSQL);
+            deleteStatement.setString(1, "Test request description");
+            deleteStatement.executeUpdate();
+        }
+    }
+
+    @Test
+    void testSoumettreDemandeWithEmptyDescription() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
+        descriptionField.setText("");
+        tableModel.setRowCount(0); // Clear the table before the test
+        
+        Method soumettreDemandeMethod = SoumettreDemande.class.getDeclaredMethod("soumettreDemande");
+        soumettreDemandeMethod.setAccessible(true);
+        soumettreDemandeMethod.invoke(soumettreDemande);
+
+        assertEquals(0, tableModel.getRowCount(), "No request should be submitted if the description is empty.");
+    }
+
+    @Test
+    void testModifierAvisForFinalizedRequest() {
+        //on crée une demande avec le statut 'finalisée' pour tester la méthode modifierAvis(), et avec un avis original
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            String insertSQL = "INSERT INTO demandes_aide (statut, utilisateur_id, benevole_id, description, avis_besoin) VALUES (?, ?, ?, ?, ?)";
+            PreparedStatement insertStatement = connection.prepareStatement(insertSQL, PreparedStatement.RETURN_GENERATED_KEYS);
+            insertStatement.setString(1, "finalisée");
+            insertStatement.setInt(2, utilisateurID);
+            insertStatement.setInt(3, benevoleID);
+            insertStatement.setString(4, "Demande de test pour JUnit / Test modif avis_besoin");
+            insertStatement.setString(5, "Avis_besoin à modifier");
+            insertStatement.executeUpdate();
+
+            // Récupération de l'ID généré pour pouvoir le supprimer après
+            ResultSet generatedKeys = insertStatement.getGeneratedKeys();
+            if (generatedKeys.next()) {
+                demandeID = generatedKeys.getInt(1);
+            }
+
+            // on met à jour la table avec la nouvelle demande rajoutée
+            // on utilise une méthode détournée pour accéder à la méthode private 'loadAnciennesDemandes()'
+            Method loadAnciennesDemandesMethod = SoumettreDemande.class.getDeclaredMethod("loadAnciennesDemandes");
+            loadAnciennesDemandesMethod.setAccessible(true); // permet d'appeler la méthode même si elle est private
+            loadAnciennesDemandesMethod.invoke(soumettreDemande); // on l'appele
+
+            //test de modifierAvis(); on sélectionne la dernière ligne de la table car elle correspond à la demande test
+            int lastRow = soumettreDemande.getTable().getRowCount()-1;
+            soumettreDemande.getTable().setRowSelectionInterval(lastRow, lastRow);
+
+            // idem que pour loadAnciennesDemandes() comme modifierAvis() est aussi en private
+            Method modifierAvisMethod = SoumettreDemande.class.getDeclaredMethod("modifierAvis");
+            modifierAvisMethod.setAccessible(true);  // permet d'appeler la méthode même si elle est private
+            modifierAvisMethod.invoke(soumettreDemande);  // on l'appele
+
+            // on attend un moment pour que la base de données se mette à jour
+            Thread.sleep(1000);
+
+            String sql = "SELECT avis_besoin FROM demandes_aide WHERE id = ?";
+            PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setInt(1, demandeID);
+            ResultSet resultSet = statement.executeQuery();
+
+            assertTrue(resultSet.next(), "La demande doit exister.");
+            String nouvelAvis = resultSet.getString("avis_besoin");
+            assertNotEquals("Avis_besoin à modifier", nouvelAvis, "L'avis doit être modifié.");
+
+            // Suppression de la demande de test après le test de prendreDemande()
+            String deleteSQL = "DELETE FROM demandes_aide WHERE id = ?";
+            PreparedStatement deleteStatement = connection.prepareStatement(deleteSQL);
+            deleteStatement.setInt(1, demandeID);
+            deleteStatement.executeUpdate();
+        } catch (InterruptedException | InvocationTargetException | NoSuchMethodException | IllegalAccessException |
+                 SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Test
+    void testLoadAnciennesDemandes() {
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            // Créer trois demandes tests
+            String desc1 = "Demande de test 1 pour JUnit / Test loadAnciennesDemandes";
+            String desc2 = "Demande de test 2 pour JUnit / Test loadAnciennesDemandes";
+            String desc3 = "Demande de test 3 pour JUnit / Test loadAnciennesDemandes";
+
+            // Insertion de la première demande
+            String insertSQL = "INSERT INTO demandes_aide (statut, utilisateur_id, benevole_id, description) VALUES (?, ?, ?, ?)";
+            PreparedStatement insertStatement = connection.prepareStatement(insertSQL, PreparedStatement.RETURN_GENERATED_KEYS);
+            insertStatement.setString(1, "soumise");
+            insertStatement.setInt(2, utilisateurID);
+            insertStatement.setNull(3, java.sql.Types.INTEGER);
+            insertStatement.setString(4, desc1);
+            insertStatement.executeUpdate();
+
+            ResultSet generatedKeys = insertStatement.getGeneratedKeys();
+            if (generatedKeys.next()) {
+                demandeID = generatedKeys.getInt(1);
+            }
+
+            // Insertion des autres demandes
+            insertStatement.setString(4, desc2);
+            insertStatement.executeUpdate();
+            insertStatement.setString(4, desc3);
+            insertStatement.executeUpdate();
+
+            // Charger les demandes dans la table
+            Method loadAnciennesDemandes = SoumettreDemande.class.getDeclaredMethod("loadAnciennesDemandes");
+            loadAnciennesDemandes.setAccessible(true);
+            loadAnciennesDemandes.invoke(soumettreDemande);
+
+            // Vérifier que les descriptions sont bien chargées
+            int lastRow = soumettreDemande.getTable().getRowCount() - 1;
+            String desc_actual = (String) soumettreDemande.getTableModel().getValueAt(lastRow-2, 1) +
+                    (String) soumettreDemande.getTableModel().getValueAt(lastRow-1, 1) +
+                    (String) soumettreDemande.getTableModel().getValueAt(lastRow, 1);
+
+            String desc_expected = desc1 + desc2 + desc3;
+            assertEquals(desc_expected, desc_actual, "Les descriptions doivent correspondre.");
+
+            // Nettoyage des données de test
+            for (int i = 0; i < 3; i++) {
+                String deleteSQL = "DELETE FROM demandes_aide WHERE id = ?";
+                PreparedStatement deleteStatement = connection.prepareStatement(deleteSQL);
+                deleteStatement.setInt(1, demandeID + i);
+                deleteStatement.executeUpdate();
+            }
+
+        } catch (SQLException | NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Test
+    void testAfficherAvis() {
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            // Créer une demande finalisée avec des avis
+            String description = "Demande test pour affichage des avis";
+            String avisBenevole = "Avis du bénévole test";
+            String avisBesoin = "Avis de la personne test";
+
+            String insertSQL = "INSERT INTO demandes_aide (statut, utilisateur_id, benevole_id, description, avis_benevole, avis_besoin) VALUES (?, ?, ?, ?, ?, ?)";
+            PreparedStatement insertStatement = connection.prepareStatement(insertSQL, PreparedStatement.RETURN_GENERATED_KEYS);
+            insertStatement.setString(1, "finalisée");
+            insertStatement.setInt(2, utilisateurID);
+            insertStatement.setInt(3, benevoleID);
+            insertStatement.setString(4, description);
+            insertStatement.setString(5, avisBenevole);
+            insertStatement.setString(6, avisBesoin);
+            insertStatement.executeUpdate();
+
+            // Récupérer l'ID de la demande créée
+            ResultSet generatedKeys = insertStatement.getGeneratedKeys();
+            if (generatedKeys.next()) {
+                demandeID = generatedKeys.getInt(1);
+            }
+
+            // Charger les demandes dans la table
+            Method loadAnciennesDemandes = SoumettreDemande.class.getDeclaredMethod("loadAnciennesDemandes");
+            loadAnciennesDemandes.setAccessible(true);
+            loadAnciennesDemandes.invoke(soumettreDemande);
+
+            // Sélectionner la demande
+            int lastRow = soumettreDemande.getTable().getRowCount() - 1;
+            soumettreDemande.getTable().setRowSelectionInterval(lastRow, lastRow);
+
+            // Exécuter l'affichage des avis
+            Method afficherAvisMethod = SoumettreDemande.class.getDeclaredMethod("afficherAvis");
+            afficherAvisMethod.setAccessible(true);
+            afficherAvisMethod.invoke(soumettreDemande);
+
+            // Vérifier que les avis sont corrects dans la base de données
+            String checkSQL = "SELECT avis_benevole, avis_besoin, description FROM demandes_aide WHERE id = ?";
+            PreparedStatement checkStatement = connection.prepareStatement(checkSQL);
+            checkStatement.setInt(1, demandeID);
+            ResultSet resultSet = checkStatement.executeQuery();
+
+            assertTrue(resultSet.next(), "La demande doit exister");
+            assertEquals(avisBenevole, resultSet.getString("avis_benevole"), "TEST L'avis du bénévole doit correspondre");
+            assertEquals(avisBesoin, resultSet.getString("avis_besoin"), "TEST L'avis de la personne doit correspondre");
+            assertEquals(description, resultSet.getString("description"), "TEST La description doit correspondre");
+
+            // Nettoyage
+            String deleteSQL = "DELETE FROM demandes_aide WHERE id = ?";
+            PreparedStatement deleteStatement = connection.prepareStatement(deleteSQL);
+            deleteStatement.setInt(1, demandeID);
+            deleteStatement.executeUpdate();
+
+        } catch (SQLException | NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+
+
+}

src/test/java/controller/ValidateurTest.java

@@ -0,0 +1,200 @@
+package controller;
+
+import database.DatabaseConnection;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class ValidateurTest {
+
+    private Validateur validateur;
+    private int validateurID = 3; // utilisateur arbitraire qui va valider les demandes de test
+    private int utilisateurID = 1; // utilisateur arbitraire qui va créer les demandes de test
+    private int demandeID; //on crée manuellment une demande pour les tests (on la supprime après)
+
+    @BeforeEach
+    void setUp() {
+        validateur = new Validateur(validateurID);
+    }
+
+    @Test
+    void testValiderDemande() throws SQLException {
+        //on crée une demande avec le statut 'soumise' pour tester la méthode validerDemande()
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            String insertSQL = "INSERT INTO demandes_aide (statut, utilisateur_id, benevole_id, description) VALUES (?, ?, ?, ?)";
+            PreparedStatement insertStatement = connection.prepareStatement(insertSQL, PreparedStatement.RETURN_GENERATED_KEYS);
+            insertStatement.setString(1, "soumise");
+            insertStatement.setInt(2, utilisateurID);
+            insertStatement.setNull(3, java.sql.Types.INTEGER);  // Aucun bénévole affecté initialement
+            insertStatement.setString(4, "Demande de test pour JUnit / Test validation");
+            insertStatement.executeUpdate();
+
+            // Récupération de l'ID généré pour pouvoir le supprimer après
+            ResultSet generatedKeys = insertStatement.getGeneratedKeys();
+            if (generatedKeys.next()) {
+                demandeID = generatedKeys.getInt(1);
+            }
+
+            // on met à jour la table avec la nouvelle demande rajoutée
+            // on utilise une méthode détournée pour accéder à la méthode private 'loadDemandesEnAttente()'
+            Method loadDemandesEnAttenteMethod = Validateur.class.getDeclaredMethod("loadDemandesEnAttente");
+            loadDemandesEnAttenteMethod.setAccessible(true); // permet d'appeler la méthode même si elle est private
+            loadDemandesEnAttenteMethod.invoke(validateur); // on l'appele
+
+            //test de validerDemande(); on sélectionne la dernière ligne de la table car elle correspond à la demande test
+            int lastRow = validateur.getTable().getRowCount()-1;
+            validateur.getTable().setRowSelectionInterval(lastRow, lastRow);
+
+            // idem que pour loadDemandesEnAttente() comme rejeterDemande() est aussi en private
+            Method rejeterDemandeMethod = Validateur.class.getDeclaredMethod("validerDemande");
+            rejeterDemandeMethod.setAccessible(true);  // permet d'appeler la méthode même si elle est private
+            rejeterDemandeMethod.invoke(validateur);  // on l'appele
+
+            // on attend un moment pour que la base de données se mette à jour
+            Thread.sleep(1000);
+
+            String sql = "SELECT statut FROM demandes_aide WHERE id = ?";
+            PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setInt(1, demandeID);
+            ResultSet resultSet = statement.executeQuery();
+
+            String currentStatus = "";
+            if (resultSet.next()) {
+                currentStatus = resultSet.getString("statut");
+            }
+
+            assertEquals("acceptée", currentStatus, "Le statut doit être 'acceptée'.");
+
+            // Suppression de la demande de test après le test de prendreDemande()
+            String deleteSQL = "DELETE FROM demandes_aide WHERE id = ?";
+            PreparedStatement deleteStatement = connection.prepareStatement(deleteSQL);
+            deleteStatement.setInt(1, demandeID);
+            deleteStatement.executeUpdate();
+        } catch (InterruptedException | InvocationTargetException | NoSuchMethodException | IllegalAccessException |
+                 SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+    
+    @Test
+    void testRejeterDemande() {
+        //on crée une demande avec le statut 'soumise' pour tester la méthode rejeterDemande()
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            String insertSQL = "INSERT INTO demandes_aide (statut, utilisateur_id, benevole_id, description) VALUES (?, ?, ?, ?)";
+            PreparedStatement insertStatement = connection.prepareStatement(insertSQL, PreparedStatement.RETURN_GENERATED_KEYS);
+            insertStatement.setString(1, "soumise");
+            insertStatement.setInt(2, utilisateurID);
+            insertStatement.setNull(3, java.sql.Types.INTEGER);  // Aucun bénévole affecté initialement
+            insertStatement.setString(4, "Demande de test pour JUnit / Test rejet");
+            insertStatement.executeUpdate();
+
+            // Récupération de l'ID généré pour pouvoir le supprimer après
+            ResultSet generatedKeys = insertStatement.getGeneratedKeys();
+            if (generatedKeys.next()) {
+                demandeID = generatedKeys.getInt(1);
+            }
+
+            // on met à jour la table avec la nouvelle demande rajoutée
+            // on utilise une méthode détournée pour accéder à la méthode private 'loadDemandesEnAttente()'
+            Method loadDemandesEnAttenteMethod = Validateur.class.getDeclaredMethod("loadDemandesEnAttente");
+            loadDemandesEnAttenteMethod.setAccessible(true); // permet d'appeler la méthode même si elle est private
+            loadDemandesEnAttenteMethod.invoke(validateur); // on l'appele
+
+            //test de rejeterDemande(); on sélectionne la dernière ligne de la table car elle correspond à la demande test
+            int lastRow = validateur.getTable().getRowCount()-1;
+            validateur.getTable().setRowSelectionInterval(lastRow, lastRow);
+
+            // idem que pour loadDemandesEnAttente() comme rejeterDemande() est aussi en private
+            Method rejeterDemandeMethod = Validateur.class.getDeclaredMethod("rejeterDemande");
+            rejeterDemandeMethod.setAccessible(true);  // permet d'appeler la méthode même si elle est private
+            rejeterDemandeMethod.invoke(validateur);  // on l'appele
+
+            // on attend un moment pour que la base de données se mette à jour
+            Thread.sleep(1000);
+
+            String sql = "SELECT statut FROM demandes_aide WHERE id = ?";
+            PreparedStatement statement = connection.prepareStatement(sql);
+            statement.setInt(1, demandeID);
+            ResultSet resultSet = statement.executeQuery();
+
+            String currentStatus = "";
+            if (resultSet.next()) {
+                currentStatus = resultSet.getString("statut");
+            }
+
+            assertEquals("rejetée", currentStatus, "Le statut doit être 'rejetée'.");
+
+            // Suppression de la demande de test après le test de prendreDemande()
+            String deleteSQL = "DELETE FROM demandes_aide WHERE id = ?";
+            PreparedStatement deleteStatement = connection.prepareStatement(deleteSQL);
+            deleteStatement.setInt(1, demandeID);
+            deleteStatement.executeUpdate();
+        } catch (InterruptedException | InvocationTargetException | NoSuchMethodException | IllegalAccessException |
+                 SQLException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Test
+    void testLoadDemandesEnAttente() {
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            // Créer trois demandes tests
+            String desc1 = "Demande de test 1 pour JUnit / Test loadDemandesEnAttente";
+            String desc2 = "Demande de test 2 pour JUnit / Test loadDemandesEnAttente";
+            String desc3 = "Demande de test 3 pour JUnit / Test loadDemandesEnAttente";
+
+            // Insertion de la première demande
+            String insertSQL = "INSERT INTO demandes_aide (statut, utilisateur_id, benevole_id, description) VALUES (?, ?, ?, ?)";
+            PreparedStatement insertStatement = connection.prepareStatement(insertSQL, PreparedStatement.RETURN_GENERATED_KEYS);
+            insertStatement.setString(1, "soumise");
+            insertStatement.setInt(2, utilisateurID);
+            insertStatement.setNull(3, java.sql.Types.INTEGER); //pas de benevole attribué
+            insertStatement.setString(4, desc1);
+            insertStatement.executeUpdate();
+
+            ResultSet generatedKeys = insertStatement.getGeneratedKeys();
+            if (generatedKeys.next()) {
+                demandeID = generatedKeys.getInt(1);
+            }
+
+            // Insertion des autres demandes
+            insertStatement.setString(4, desc2);
+            insertStatement.executeUpdate();
+            insertStatement.setString(4, desc3);
+            insertStatement.executeUpdate();
+
+            // Charger les demandes dans la table
+            Method loadDemandesEnAttenteMethod = Validateur.class.getDeclaredMethod("loadDemandesEnAttente");
+            loadDemandesEnAttenteMethod.setAccessible(true);
+            loadDemandesEnAttenteMethod.invoke(validateur);
+
+            // Vérifier que les descriptions sont bien chargées
+            int lastRow = validateur.getTable().getRowCount()-1;
+            String desc_actual = (String) validateur.getTableModel().getValueAt(lastRow-2, 1) +
+                    (String) validateur.getTableModel().getValueAt(lastRow-1, 1) +
+                    (String) validateur.getTableModel().getValueAt(lastRow, 1);
+
+            String desc_expected = desc1 + desc2 + desc3;
+            assertEquals(desc_expected, desc_actual, "Les descriptions doivent correspondre");
+
+            // Nettoyage des données de test
+            for (int i = 0; i < 3; i++) {
+                String deleteSQL = "DELETE FROM demandes_aide WHERE id = ?";
+                PreparedStatement deleteStatement = connection.prepareStatement(deleteSQL);
+                deleteStatement.setInt(1, demandeID + i);
+                deleteStatement.executeUpdate();
+            }
+
+        } catch (SQLException | NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

src/test/java/database/DatabaseConnectionTest.java

@@ -0,0 +1,48 @@
+package database;
+
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Executable;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class DatabaseConnectionTest {
+
+    @Test
+    void testGetConnectionSuccess() {
+        try (Connection connection = DatabaseConnection.getConnection()) {
+            assertNotNull(connection, "La connexion ne doit pas être nulle.");
+            assertTrue(connection.isValid(2), "La connexion doit être valide.");
+        } catch (SQLException e) {
+            fail("Une SQLException ne devrait pas se produire avec des détails de connexion valides.");
+        }
+    }
+
+    @Test
+    void testInvalidCredentials() {
+        // Test with invalid credentials by directly setting incorrect parameters
+        final String invalidUser = "invalid_user";
+        final String invalidPassword = "invalid_password";
+
+        SQLException exception = assertThrows(SQLException.class, () -> {
+            DriverManager.getConnection(DatabaseConnection.URL, invalidUser, invalidPassword);
+        }, "A SQLException is expected due to invalid credentials.");
+
+        assertNotNull(exception.getMessage(), "The exception message should not be null.");
+    }
+
+    @Test
+    void testConnectionFailureWithInvalidUrl() {
+        // Test with an invalid URL by directly setting incorrect parameters
+        final String invalidUrl = "jdbc:mysql://invalid_url:3306/test_db";
+
+        SQLException exception = assertThrows(SQLException.class, () -> {
+            DriverManager.getConnection(invalidUrl, DatabaseConnection.getUser(), DatabaseConnection.getPassword());
+        }, "A SQLException is expected due to an invalid URL.");
+
+        assertNotNull(exception.getMessage(), "The exception message should not be null.");
+    }
+}