Compare commits
No commits in common. "master" and "sprint2" have entirely different histories.
33 changed files with 307 additions and 1646 deletions
|
|
@ -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.8">
|
||||
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.7">
|
||||
<attributes>
|
||||
<attribute name="maven.pomderived" value="true"/>
|
||||
</attributes>
|
||||
|
|
|
|||
|
|
@ -1,47 +0,0 @@
|
|||
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
|
||||
2
.gitignore
vendored
2
.gitignore
vendored
|
|
@ -1,3 +1 @@
|
|||
/target/
|
||||
/.idea/
|
||||
/.settings/
|
||||
|
|
|
|||
3
.idea/.gitignore
vendored
Normal file
3
.idea/.gitignore
vendored
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
# Default ignored files
|
||||
/shelf/
|
||||
/workspace.xml
|
||||
13
.idea/compiler.xml
Normal file
13
.idea/compiler.xml
Normal file
|
|
@ -0,0 +1,13 @@
|
|||
<?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>
|
||||
20
.idea/jarRepositories.xml
Normal file
20
.idea/jarRepositories.xml
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
<?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>
|
||||
12
.idea/misc.xml
Normal file
12
.idea/misc.xml
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
<?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>
|
||||
7
.idea/vcs.xml
Normal file
7
.idea/vcs.xml
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
<?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>
|
||||
11
.project
11
.project
|
|
@ -20,15 +20,4 @@
|
|||
<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>
|
||||
|
|
|
|||
8
.settings/org.eclipse.jdt.core.prefs
Normal file
8
.settings/org.eclipse.jdt.core.prefs
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
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
|
||||
4
.settings/org.eclipse.m2e.core.prefs
Normal file
4
.settings/org.eclipse.m2e.core.prefs
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
activeProfiles=
|
||||
eclipse.preferences.version=1
|
||||
resolveWorkspaceProjects=true
|
||||
version=1
|
||||
95
README.md
95
README.md
|
|
@ -1,95 +0,0 @@
|
|||
# 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
|
||||
```
|
||||
6
pom.xml
6
pom.xml
|
|
@ -8,11 +8,6 @@
|
|||
<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>
|
||||
|
|
@ -35,7 +30,6 @@
|
|||
<artifactId>mysql-connector-java</artifactId>
|
||||
<version>8.0.28</version>
|
||||
</dependency>
|
||||
|
||||
</dependencies>
|
||||
|
||||
</project>
|
||||
|
|
|
|||
108
src/main/java/controller/AjoutUtilisateur.java
Normal file
108
src/main/java/controller/AjoutUtilisateur.java
Normal file
|
|
@ -0,0 +1,108 @@
|
|||
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();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -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(final int utilisateurId) { // Ajout du paramètre utilisateurId
|
||||
public BenevoleDemandesEncoursPage(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,13 +65,6 @@ 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()) {
|
||||
|
|
|
|||
|
|
@ -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(final int utilisateurId) { // Ajout du paramètre utilisateurId
|
||||
public BenevoleDemandesFinaliseesPage(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,14 +75,6 @@ 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) {
|
||||
|
|
|
|||
|
|
@ -1,5 +1,9 @@
|
|||
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;
|
||||
|
|
@ -7,25 +11,14 @@ import java.sql.PreparedStatement;
|
|||
import java.sql.ResultSet;
|
||||
import java.sql.SQLException;
|
||||
|
||||
import javax.swing.JButton;
|
||||
import javax.swing.JFrame;
|
||||
import javax.swing.JOptionPane;
|
||||
import javax.swing.JPanel;
|
||||
import javax.swing.JScrollPane;
|
||||
import javax.swing.JTable;
|
||||
import javax.swing.table.DefaultTableModel;
|
||||
|
||||
import database.DatabaseConnection;
|
||||
|
||||
public class BenevoleDemandesPage extends JFrame {
|
||||
private JTable table;
|
||||
private DefaultTableModel tableModel;
|
||||
private JButton prendreDemandeButton;
|
||||
private JButton retourBenevoleButton;
|
||||
|
||||
final int utilisateurId ; // Ajout de l'ID du bénévole
|
||||
private int utilisateurId; // Ajout de l'ID du bénévole
|
||||
|
||||
public BenevoleDemandesPage(final int utilisateurId) { // Ajout du paramètre utilisateurId
|
||||
public BenevoleDemandesPage(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);
|
||||
|
|
@ -72,13 +65,6 @@ 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()) {
|
||||
|
|
|
|||
|
|
@ -5,16 +5,15 @@ import database.DatabaseConnection;
|
|||
import javax.swing.*;
|
||||
import java.awt.event.ActionEvent;
|
||||
import java.awt.event.ActionListener;
|
||||
import java.nio.charset.Charset;
|
||||
import java.sql.Connection;
|
||||
import java.sql.PreparedStatement;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.SQLException;
|
||||
|
||||
public class LoginPage extends JFrame {
|
||||
private JTextField emailField;
|
||||
private JButton loginButton;
|
||||
private JButton createAccountButton;
|
||||
private JTextField emailField;
|
||||
private JButton loginButton;
|
||||
private JButton createAccountButton;
|
||||
|
||||
public LoginPage() {
|
||||
setTitle("Page de connexion");
|
||||
|
|
@ -55,13 +54,6 @@ 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();
|
||||
|
|
|
|||
72
src/main/java/controller/MainMenu.java
Normal file
72
src/main/java/controller/MainMenu.java
Normal file
|
|
@ -0,0 +1,72 @@
|
|||
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);
|
||||
}
|
||||
}
|
||||
|
|
@ -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(final int utilisateurId) {
|
||||
public MenuBenevole(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;
|
||||
|
||||
setVoirDemandesAcceptesButton(new JButton("Voir demandes acceptés"));
|
||||
voirDemandesAcceptesButton = new JButton("Voir demandes acceptés");
|
||||
gbc.gridx = 0;
|
||||
gbc.gridy = 0;
|
||||
add(getVoirDemandesAcceptesButton(), gbc);
|
||||
add(voirDemandesAcceptesButton, gbc);
|
||||
|
||||
setVoirDemandesEnCoursButton(new JButton("Voir demandes personelles en cours"));
|
||||
voirDemandesEnCoursButton = new JButton("Voir demandes personelles en cours");
|
||||
gbc.gridx = 0;
|
||||
gbc.gridy = 1;
|
||||
add(getVoirDemandesEnCoursButton(), gbc);
|
||||
add(voirDemandesEnCoursButton, gbc);
|
||||
|
||||
setVoirDemandesFinaliseesButton(new JButton("Voir demandes personelles finalisées"));
|
||||
voirDemandesFinaliseesButton = new JButton("Voir demandes personelles finalisées");
|
||||
gbc.gridx = 0;
|
||||
gbc.gridy = 2;
|
||||
add(getVoirDemandesFinaliseesButton(), gbc);
|
||||
add(voirDemandesFinaliseesButton, gbc);
|
||||
|
||||
setRetourButton(new JButton("Retour à l'acceuil"));
|
||||
retourButton = new JButton("Retour à l'acceuil");
|
||||
gbc.gridx = 0;
|
||||
gbc.gridy = 3;
|
||||
add(getRetourButton(), gbc);
|
||||
add(retourButton, gbc);
|
||||
|
||||
getVoirDemandesAcceptesButton().addActionListener(new ActionListener() {
|
||||
voirDemandesAcceptesButton.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{
|
|||
}
|
||||
});
|
||||
|
||||
getVoirDemandesEnCoursButton().addActionListener(new ActionListener() {
|
||||
voirDemandesEnCoursButton.addActionListener(new ActionListener() {
|
||||
@Override
|
||||
public void actionPerformed(ActionEvent e) {
|
||||
BenevoleDemandesEncoursPage benevoleDemandesEncoursPage = new BenevoleDemandesEncoursPage(utilisateurId);
|
||||
|
|
@ -62,7 +62,7 @@ public class MenuBenevole extends JFrame{
|
|||
}
|
||||
});
|
||||
|
||||
getVoirDemandesFinaliseesButton().addActionListener(new ActionListener() {
|
||||
voirDemandesFinaliseesButton.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
|
||||
getRetourButton().addActionListener(new ActionListener() {
|
||||
retourButton.addActionListener(new ActionListener() {
|
||||
@Override
|
||||
public void actionPerformed(ActionEvent e) {
|
||||
LoginPage loginPage = new LoginPage();
|
||||
|
|
@ -84,38 +84,6 @@ 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);
|
||||
|
|
|
|||
|
|
@ -113,16 +113,6 @@ 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();
|
||||
|
|
|
|||
|
|
@ -74,14 +74,6 @@ 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()) {
|
||||
|
|
@ -155,5 +147,4 @@ public class Validateur extends JFrame {
|
|||
JOptionPane.showMessageDialog(this, "Le motif de rejet ne peut pas être vide.");
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,23 +5,11 @@ import java.sql.DriverManager;
|
|||
import java.sql.SQLException;
|
||||
|
||||
public class DatabaseConnection {
|
||||
|
||||
static final String URL = System.getenv("DB_URL") != null ?
|
||||
System.getenv("DB_URL") : "jdbc:mysql://srv-bdens.insa-toulouse.fr:3306/projet_gei_023?useUnicode=true&characterEncoding=UTF-8";
|
||||
private static final String USER = System.getenv("DB_USER") != null ?
|
||||
System.getenv("DB_USER") : "projet_gei_023";
|
||||
private static final String PASSWORD = System.getenv("DB_PASSWORD") != null ?
|
||||
System.getenv("DB_PASSWORD") : "ohQu4ood";
|
||||
private static final String URL = "jdbc:mysql://srv-bdens.insa-toulouse.fr:3306/projet_gei_023";
|
||||
private static final String USER = "projet_gei_023";
|
||||
private static final String PASSWORD = "ohQu4ood";
|
||||
|
||||
public static Connection getConnection() throws SQLException {
|
||||
return DriverManager.getConnection(URL, getUser(), getPassword());
|
||||
return DriverManager.getConnection(URL, USER, PASSWORD);
|
||||
}
|
||||
|
||||
public static String getUser() {
|
||||
return USER;
|
||||
}
|
||||
|
||||
public static String getPassword() {
|
||||
return PASSWORD;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
31
src/test/java/controller/AjoutUtilisateurTest.java
Normal file
31
src/test/java/controller/AjoutUtilisateurTest.java
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
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
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -1,192 +0,0 @@
|
|||
|
||||
|
||||
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);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,197 +0,0 @@
|
|||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,199 +0,0 @@
|
|||
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);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,125 +0,0 @@
|
|||
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'.");
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,78 +0,0 @@
|
|||
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'.");
|
||||
}
|
||||
}
|
||||
|
|
@ -1,62 +0,0 @@
|
|||
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();
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
|
@ -1,255 +0,0 @@
|
|||
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);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
|
@ -1,200 +0,0 @@
|
|||
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);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
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.");
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue