fini tests unitaires pour Validateur et soumettreDemande

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()) {

src/test/java/controller/BenevoleDemandesPageTest.java

@@ -18,12 +18,11 @@ import static org.junit.jupiter.api.Assertions.*;
 class BenevoleDemandesPageTest {
 
     private BenevoleDemandesPage benevoleDemandesPage;
-    private JTable table;
     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() throws SQLException {
+    void setUp() {
         //on crée la page des demandes acceptés
         benevoleDemandesPage = new BenevoleDemandesPage(benevoleID);
     }
@@ -52,7 +51,7 @@ class BenevoleDemandesPageTest {
     }
 
     @Test
-    void testPrendreDemande() throws SQLException {
+    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 (?, ?, ?, ?)";
@@ -60,7 +59,7 @@ class BenevoleDemandesPageTest {
             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");
+            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
@@ -107,7 +106,8 @@ class BenevoleDemandesPageTest {
             PreparedStatement deleteStatement = connection.prepareStatement(deleteSQL);
             deleteStatement.setInt(1, demandeID);
             deleteStatement.executeUpdate();
-        } catch (InterruptedException | InvocationTargetException | NoSuchMethodException | IllegalAccessException e) {
+        } catch (InterruptedException | InvocationTargetException | NoSuchMethodException | IllegalAccessException |
+                 SQLException e) {
             throw new RuntimeException(e);
         }
     }

src/test/java/controller/CreateAccountPageTest.java

@@ -25,7 +25,8 @@ class CreateAccountPageTest {
     private JButton createAccountButton;
     private JButton retourLoginButton;
 
-   /* @BeforeEach
+    /*
+    @BeforeEach
     void setUp() throws NoSuchFieldException, IllegalAccessException {
         createAccountPage = new CreateAccountPage();
 
@@ -120,5 +121,6 @@ class CreateAccountPageTest {
 
         // 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

@@ -30,7 +30,8 @@ class LoginPageTest {
         loginPage.add(createAccountButton);
     }
 
- /*   @Test
+    /*
+    @Test
     void testLoginWithValidUser() throws SQLException {
         try (Connection connection = DatabaseConnection.getConnection()) {
             String email = "test@example.com";
@@ -63,8 +64,8 @@ class LoginPageTest {
 
         // Vérifiez que la page reste ouverte après une connexion échouée
         assertTrue(loginPage.isVisible(), "LoginPage devrait rester ouverte si la connexion échoue.");
-    }*/
+    }
-
+    */
 
     @Test
     void testCreateAccountButtonAction() {

src/test/java/controller/SoumettreDemandeTest.java

@@ -20,10 +20,9 @@ class SoumettreDemandeTest {
 
     private SoumettreDemande soumettreDemande;
     private JTextField descriptionField;
-    private JButton soumettreButton;
-    private JTable demandesTable;
     private DefaultTableModel tableModel;
-    private int utilisateurId = 1;
+    private int utilisateurId = 1; // utilisateur arbitraire qui va créer les demandes de test
+    private int demandeID;
 
     @BeforeEach
     void setUp() throws NoSuchFieldException, IllegalAccessException {
@@ -31,8 +30,6 @@ class SoumettreDemandeTest {
 
         // Access private fields using reflection
         descriptionField = (JTextField) getField("descriptionField");
-        soumettreButton = (JButton) getField("soumettreButton");
-        demandesTable = (JTable) getField("demandesTable");
         tableModel = (DefaultTableModel) getField("tableModel");
     }
 
@@ -82,47 +79,61 @@ class SoumettreDemandeTest {
 
     @Test
     void testModifierAvisForFinalizedRequest() throws SQLException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
-        int demandeId;
+        //on crée une demande avec le statut 'finalisée' pour tester la méthode modifierAvis(), et avec un avis original
-
-        // Step 1: Insert a test row in the database
         try (Connection connection = DatabaseConnection.getConnection()) {
-            String insertSQL = "INSERT INTO demandes_aide (description, statut, utilisateur_id, avis_besoin) VALUES (?, 'finalisée', ?, 'Initial avis besoin')";
+            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, "Finalized request for modify test");
+            insertStatement.setString(1, "finalisée");
             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 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();
-            generatedKeys.next();
+            if (generatedKeys.next()) {
-            demandeId = generatedKeys.getInt(1);
+                demandeID = generatedKeys.getInt(1);
-        }
+            }
 
-        // Step 2: Simulate table setup
+            // on met à jour la table avec la nouvelle demande rajoutée
-        tableModel.addRow(new Object[]{demandeId, "Finalized request for modify test", "finalisée", null});
+            // on utilise une méthode détournée pour accéder à la méthode private 'loadAnciennesDemandes()'
-        demandesTable.setRowSelectionInterval(0, 0);
+            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
 
-        // Step 3: Invoke the modifierAvis method
+            //test de modifierAvis(); on sélectionne la dernière ligne de la table car elle correspond à la demande test
-        Method modifierAvisMethod = SoumettreDemande.class.getDeclaredMethod("modifierAvis");
+            int lastRow = soumettreDemande.getTable().getRowCount()-1;
-        modifierAvisMethod.setAccessible(true);
+            soumettreDemande.getTable().setRowSelectionInterval(lastRow, lastRow);
-        modifierAvisMethod.invoke(soumettreDemande);
+
+            // 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);
 
-        // Step 4: Verify the update in the database
-        try (Connection connection = DatabaseConnection.getConnection()) {
             String sql = "SELECT avis_besoin FROM demandes_aide WHERE id = ?";
             PreparedStatement statement = connection.prepareStatement(sql);
-            statement.setInt(1, demandeId);
+            statement.setInt(1, demandeID);
             ResultSet resultSet = statement.executeQuery();
 
-            assertTrue(resultSet.next(), "The request should exist in the database.");
+            String currentAvis = "";
-            assertNotEquals("Initial avis besoin", resultSet.getString("avis_besoin"), "The avis_besoin should be updated.");
+            if (resultSet.next()) {
-        }
+                currentAvis = resultSet.getString("avis_besoin");
+            }
 
-        // Step 5: Clean up test data
+            assertNotEquals("Avis_besoin à modifier", currentAvis, "L'avis n'a pas été modifié.");
-        try (Connection connection = DatabaseConnection.getConnection()) {
+
+            // 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.setInt(1, demandeID);
             deleteStatement.executeUpdate();
+        } catch (InterruptedException | InvocationTargetException | NoSuchMethodException | IllegalAccessException |
+                 SQLException e) {
+            throw new RuntimeException(e);
         }
     }
 

src/test/java/controller/ValidateurTest.java

@@ -19,122 +19,131 @@ import static org.junit.jupiter.api.Assertions.*;
 class ValidateurTest {
 
     private Validateur validateur;
-    private JTable table;
+    private int utilisateurId = 1; // utilisateur arbitraire qui va créer les demandes de test
-    private DefaultTableModel tableModel;
+    private int demandeID; //on crée manuellment une demande pour les tests (on la supprime après)
-    private int utilisateurId = 1;
 
     @BeforeEach
-    void setUp() throws NoSuchFieldException, IllegalAccessException {
+    void setUp() {
         validateur = new Validateur(utilisateurId);
-        table = (JTable) getField("table");
-        tableModel = (DefaultTableModel) getField("tableModel");
-    }
-
-    private Object getField(String fieldName) throws NoSuchFieldException, IllegalAccessException {
-        Field field = Validateur.class.getDeclaredField(fieldName);
-        field.setAccessible(true);
-        return field.get(validateur);
     }
 
     @Test
     void testValiderDemande() throws SQLException {
-        int demandeId;
+        //on crée une demande avec le statut 'soumise' pour tester la méthode validerDemande()
-        
-        // Step 1: Insert a request with status 'soumise' for testing purposes
         try (Connection connection = DatabaseConnection.getConnection()) {
-            String insertSQL = "INSERT INTO demandes_aide (description, statut) VALUES (?, 'soumise')";
+            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, "Pending request to validate");
+            insertStatement.setString(1, "soumise");
+            insertStatement.setNull(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();
-            generatedKeys.next();
+            if (generatedKeys.next()) {
-            demandeId = generatedKeys.getInt(1);
+                demandeID = generatedKeys.getInt(1);
-        }
+            }
 
-        // Step 2: Directly update the status to 'acceptée'
+            // on met à jour la table avec la nouvelle demande rajoutée
-        try (Connection connection = DatabaseConnection.getConnection()) {
+            // on utilise une méthode détournée pour accéder à la méthode private 'loadDemandesEnAttente()'
-            String updateSQL = "UPDATE demandes_aide SET statut = 'acceptée' WHERE id = ?";
+            Method loadDemandesEnAttenteMethod = Validateur.class.getDeclaredMethod("loadDemandesEnAttente");
-            PreparedStatement updateStatement = connection.prepareStatement(updateSQL);
+            loadDemandesEnAttenteMethod.setAccessible(true); // permet d'appeler la méthode même si elle est private
-            updateStatement.setInt(1, demandeId);
+            loadDemandesEnAttenteMethod.invoke(validateur); // on l'appele
-            updateStatement.executeUpdate();
-        }
 
-        // Step 3: Verify that the status is now 'acceptée'
+            //test de validerDemande(); on sélectionne la dernière ligne de la table car elle correspond à la demande test
-        try (Connection connection = DatabaseConnection.getConnection()) {
+            int lastRow = validateur.getTable().getRowCount()-1;
-            String selectSQL = "SELECT statut FROM demandes_aide WHERE id = ?";
+            validateur.getTable().setRowSelectionInterval(lastRow, lastRow);
-            PreparedStatement selectStatement = connection.prepareStatement(selectSQL);
-            selectStatement.setInt(1, demandeId);
-            ResultSet resultSet = selectStatement.executeQuery();
 
-            assertTrue(resultSet.next(), "The request should exist in the database.");
+            // idem que pour loadDemandesEnAttente() comme rejeterDemande() est aussi en private
-            assertEquals("acceptée", resultSet.getString("statut"), "The request status should be 'acceptée'.");
+            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
 
-        // Step 4: Clean up by deleting the test request
+            // on attend un moment pour que la base de données se mette à jour
-        try (Connection connection = DatabaseConnection.getConnection()) {
+            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.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()
-
-  /*  @Test
-    void testRejeterDemande() throws Exception {
-        // Step 1: Add a sample request to reject for testing
-        int demandeId;
         try (Connection connection = DatabaseConnection.getConnection()) {
-            String insertSQL = "INSERT INTO demandes_aide (description, statut) VALUES (?, 'soumise')";
+            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, "Request to reject");
+            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();
-            generatedKeys.next();
+            if (generatedKeys.next()) {
-            demandeId = generatedKeys.getInt(1);
+                demandeID = generatedKeys.getInt(1);
-        }
+            }
 
-        // Step 2: Simulate selecting this row in the JTable
+            // on met à jour la table avec la nouvelle demande rajoutée
-        tableModel.addRow(new Object[]{demandeId, "Request to reject", "soumise"});
+            // on utilise une méthode détournée pour accéder à la méthode private 'loadDemandesEnAttente()'
-        table.setRowSelectionInterval(0, 0); // Select the first row
+            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
 
-        // Step 3: Set up for user input using a mock (you may need to use a mocking framework)
+            //test de rejeterDemande(); on sélectionne la dernière ligne de la table car elle correspond à la demande test
-        String motifRejet = "Reason for rejection";
+            int lastRow = validateur.getTable().getRowCount()-1;
-        JOptionPane.showInputDialog(null, "Veuillez entrer un motif de rejet (500 caractères max):");
+            validateur.getTable().setRowSelectionInterval(lastRow, lastRow);
-        assertNotNull(motifRejet, "Motif de rejet ne doit pas être nul");
 
-        // Step 4: Execute `rejeterDemande`
+            // idem que pour loadDemandesEnAttente() comme rejeterDemande() est aussi en private
-        Method method = Validateur.class.getDeclaredMethod("rejeterDemande");
+            Method rejeterDemandeMethod = Validateur.class.getDeclaredMethod("rejeterDemande");
-        method.setAccessible(true);
+            rejeterDemandeMethod.setAccessible(true);  // permet d'appeler la méthode même si elle est private
-        method.invoke(validateur);
+            rejeterDemandeMethod.invoke(validateur);  // on l'appele
 
-        // Step 5: Verify the status update in the database
+            // on attend un moment pour que la base de données se mette à jour
-        try (Connection connection = DatabaseConnection.getConnection()) {
+            Thread.sleep(1000);
-            String selectSQL = "SELECT statut, motif_rejet FROM demandes_aide WHERE id = ?";
-            PreparedStatement selectStatement = connection.prepareStatement(selectSQL);
-            selectStatement.setInt(1, demandeId);
-            ResultSet resultSet = selectStatement.executeQuery();
 
-            assertTrue(resultSet.next(), "La demande doit exister dans la base de données.");
+            String sql = "SELECT statut FROM demandes_aide WHERE id = ?";
-            assertEquals("rejetée", resultSet.getString("statut"), "Le statut de la demande doit être 'rejetée'.");
+            PreparedStatement statement = connection.prepareStatement(sql);
-            assertEquals(motifRejet, resultSet.getString("motif_rejet"), "Le motif de rejet doit correspondre.");
+            statement.setInt(1, demandeID);
-        }
+            ResultSet resultSet = statement.executeQuery();
 
-        // Step 6: Clean up by deleting the test request
+            String currentStatus = "";
-        try (Connection connection = DatabaseConnection.getConnection()) {
+            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.setInt(1, demandeID);
             deleteStatement.executeUpdate();
+        } catch (InterruptedException | InvocationTargetException | NoSuchMethodException | IllegalAccessException |
+                 SQLException e) {
+            throw new RuntimeException(e);
         }
-    }*/
+    }
-
-