push final

.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/

.idea/.gitignore

@@ -1,3 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml

.idea/compiler.xml

@@ -1,13 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="CompilerConfiguration">
-    <annotationProcessing>
-      <profile name="Maven default annotation processors profile" enabled="true">
-        <sourceOutputDir name="target/generated-sources/annotations" />
-        <sourceTestOutputDir name="target/generated-test-sources/test-annotations" />
-        <outputRelativeToContentRoot value="true" />
-        <module name="AidePersonnesApp" />
-      </profile>
-    </annotationProcessing>
-  </component>
-</project>

.idea/jarRepositories.xml

@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="RemoteRepositoriesConfiguration">
-    <remote-repository>
-      <option name="id" value="central" />
-      <option name="name" value="Central Repository" />
-      <option name="url" value="https://repo.maven.apache.org/maven2" />
-    </remote-repository>
-    <remote-repository>
-      <option name="id" value="central" />
-      <option name="name" value="Maven Central repository" />
-      <option name="url" value="https://repo1.maven.org/maven2" />
-    </remote-repository>
-    <remote-repository>
-      <option name="id" value="jboss.community" />
-      <option name="name" value="JBoss Community repository" />
-      <option name="url" value="https://repository.jboss.org/nexus/content/repositories/public/" />
-    </remote-repository>
-  </component>
-</project>

.idea/misc.xml

@@ -1,12 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ExternalStorageConfigurationManager" enabled="true" />
-  <component name="MavenProjectsManager">
-    <option name="originalFiles">
-      <list>
-        <option value="$PROJECT_DIR$/pom.xml" />
-      </list>
-    </option>
-  </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_23" default="true" project-jdk-name="openjdk-23" project-jdk-type="JavaSDK" />
-</project>

.idea/vcs.xml

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
-    <mapping directory="$PROJECT_DIR$" vcs="Git" />
-  </component>
-</project>

.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,6 +8,11 @@
   <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>
@@ -30,6 +35,7 @@
       <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

@@ -18,7 +18,7 @@ public class BenevoleDemandesEncoursPage extends JFrame {
     private JButton retourBenevoleButton;
     private int utilisateurId; // Ajout de l'ID du bénévole
 
-    public BenevoleDemandesEncoursPage(int utilisateurId) { // Ajout du paramètre utilisateurId
+    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);
@@ -65,6 +65,13 @@ public class BenevoleDemandesEncoursPage extends JFrame {
         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()) {

src/main/java/controller/BenevoleDemandesFinaliseesPage.java

@@ -19,7 +19,7 @@ public class BenevoleDemandesFinaliseesPage extends JFrame {
     private JButton retourBenevoleButton;
     private int utilisateurId; // Ajout de l'ID du bénévole
 
-    public BenevoleDemandesFinaliseesPage(int utilisateurId) { // Ajout du paramètre utilisateurId
+    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);
@@ -75,6 +75,14 @@ public class BenevoleDemandesFinaliseesPage extends JFrame {
         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) {

src/main/java/controller/BenevoleDemandesPage.java

@@ -1,9 +1,5 @@
 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;
@@ -11,14 +7,25 @@ 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;
-    private int utilisateurId; // Ajout de l'ID du bénévole
     
-    public BenevoleDemandesPage(int utilisateurId) { // Ajout du paramètre utilisateurId
+    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);
@@ -65,6 +72,13 @@ public class BenevoleDemandesPage extends JFrame {
         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()) {

src/main/java/controller/LoginPage.java

@@ -5,15 +5,16 @@ 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 JTextField emailField;
-    private JButton loginButton;
+	 private JButton loginButton;
-    private JButton createAccountButton;
+     private JButton createAccountButton;
 
     public LoginPage() {
         setTitle("Page de connexion");
@@ -54,6 +55,13 @@ public class LoginPage extends JFrame {
         });
     }
 
+    //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();

src/main/java/controller/MainMenu.java

@@ -1,72 +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;
-    private JButton consulterDemandeButton;
-
-    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);
-
-        consulterDemandeButton = new JButton("Consulter les demandes d'aide acceptées");
-        gbc.gridx = 0;
-        gbc.gridy = 2;
-        add(consulterDemandeButton, 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(1); // Test avec un utilisateur par défaut
-                soumettreDemande.setVisible(true);
-                dispose();
-            }
-        });
-
-        consulterDemandeButton.addActionListener(new ActionListener() {
-            @Override
-            public void actionPerformed(ActionEvent e) {
-                BenevoleDemandesPage benevoleDemandesPage = new BenevoleDemandesPage(1);  // Test avec un utilisateur par défaut
-                benevoleDemandesPage.setVisible(true);
-                dispose();
-            }
-        });
-
-    }
-
-    public static void main(String[] args) {
-        MainMenu menu = new MainMenu();
-        menu.setVisible(true);
-    }
-}

src/main/java/controller/MenuBenevole.java

@@ -12,7 +12,7 @@ public class MenuBenevole extends JFrame{
     private JButton retourButton;
     private int utilisateurId; // Ajout de l'ID du bénévole
 
-    public MenuBenevole(int utilisateurId) {
+    public MenuBenevole(final int utilisateurId) {
         this.utilisateurId = utilisateurId;
         setTitle("Menu Benevole");
         setSize(400, 300);
@@ -24,27 +24,27 @@ public class MenuBenevole extends JFrame{
         gbc.insets = new Insets(10, 10, 10, 10);
         gbc.fill = GridBagConstraints.HORIZONTAL;
 
-        voirDemandesAcceptesButton = new JButton("Voir demandes acceptés");
+        setVoirDemandesAcceptesButton(new JButton("Voir demandes acceptés"));
         gbc.gridx = 0;
         gbc.gridy = 0;
-        add(voirDemandesAcceptesButton, gbc);
+        add(getVoirDemandesAcceptesButton(), gbc);
 
-        voirDemandesEnCoursButton = new JButton("Voir demandes personelles en cours");
+        setVoirDemandesEnCoursButton(new JButton("Voir demandes personelles en cours"));
         gbc.gridx = 0;
         gbc.gridy = 1;
-        add(voirDemandesEnCoursButton, gbc);
+        add(getVoirDemandesEnCoursButton(), gbc);
 
-        voirDemandesFinaliseesButton = new JButton("Voir demandes personelles finalisées");
+        setVoirDemandesFinaliseesButton(new JButton("Voir demandes personelles finalisées"));
         gbc.gridx = 0;
         gbc.gridy = 2;
-        add(voirDemandesFinaliseesButton, gbc);
+        add(getVoirDemandesFinaliseesButton(), gbc);
 
-        retourButton = new JButton("Retour à l'acceuil");
+        setRetourButton(new JButton("Retour à l'acceuil"));
         gbc.gridx = 0;
         gbc.gridy = 3;
-        add(retourButton, gbc);
+        add(getRetourButton(), gbc);
 
-        voirDemandesAcceptesButton.addActionListener(new ActionListener() {
+        getVoirDemandesAcceptesButton().addActionListener(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent e) {
                 BenevoleDemandesPage benevoleDemandesPage = new BenevoleDemandesPage(utilisateurId);  // Test avec un utilisateur par défaut
@@ -53,7 +53,7 @@ public class MenuBenevole extends JFrame{
             }
         });
 
-        voirDemandesEnCoursButton.addActionListener(new ActionListener() {
+        getVoirDemandesEnCoursButton().addActionListener(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent e) {
                 BenevoleDemandesEncoursPage benevoleDemandesEncoursPage = new BenevoleDemandesEncoursPage(utilisateurId);
@@ -62,7 +62,7 @@ public class MenuBenevole extends JFrame{
             }
         });
 
-        voirDemandesFinaliseesButton.addActionListener(new ActionListener() {
+        getVoirDemandesFinaliseesButton().addActionListener(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent e) {
                 BenevoleDemandesFinaliseesPage benevoleDemandesFinaliseesPage = new BenevoleDemandesFinaliseesPage(utilisateurId);
@@ -73,7 +73,7 @@ public class MenuBenevole extends JFrame{
 
         // Bouton de retour à la page d'accueil
         // ActionListener pour retourner à la page de connexion
-        retourButton.addActionListener(new ActionListener() {
+        getRetourButton().addActionListener(new ActionListener() {
             @Override
             public void actionPerformed(ActionEvent e) {
                 LoginPage loginPage = new LoginPage();
@@ -84,6 +84,38 @@ public class MenuBenevole extends JFrame{
 
     }
 
+    //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

@@ -113,6 +113,16 @@ public class SoumettreDemande extends JFrame {
         });
     }
 
+    //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 description = descriptionField.getText();

src/main/java/controller/Validateur.java

@@ -74,6 +74,14 @@ public class Validateur extends JFrame {
         });
     }
 
+    //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()) {
@@ -147,4 +155,5 @@ public class Validateur extends JFrame {
             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://srv-bdens.insa-toulouse.fr:3306/projet_gei_023";
+
-    private static final String USER = "projet_gei_023"; 
+    static final String URL = System.getenv("DB_URL") != null ?
-    private static final String PASSWORD = "ohQu4ood"; 
+            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/AjoutUtilisateurTest.java

@@ -1,31 +0,0 @@
-package controller;
-
-import controller.AjoutUtilisateur;
-
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
-
-import static org.junit.jupiter.api.Assertions.*;
-
-class AjoutUtilisateurTest {
-
-    private AjoutUtilisateur ajoutUtilisateur;
-
-    @BeforeEach
-    void setUp() {
-        ajoutUtilisateur = new AjoutUtilisateur();
-    }
-
-    @Test
-    void testAjoutUtilisateur() {
-        // Tester si l'interface est bien créée
-        assertNotNull(ajoutUtilisateur);
-    }
-    
-    
-    //beaucoup de test a ajouter aprés 
-    
-    
-
-    
-}

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.");
+    }
+}