[JAVA] Premiers pas avec DBUnit

Qu'est-ce que DBUnit

Vous aurez souvent beaucoup de mal à créer un programme de test pour un test unitaire d'une classe qui référence ou met à jour la base de données. Les problèmes suivants ont tendance à se produire lors de la vérification de la base de données pour les tests unitaires.

• Il faut du temps pour mettre les données du test dans le DB, ou pour supprimer les données après le test et restaurer le DB.
• "Saisie et nettoyage des données de test" complique le programme et réduit la maintenabilité. Quoi qu'il en soit, je ne peux pas lire ou corriger les programmes de test écrits par d'autres.
• Parce que le programme devient compliqué, il est difficile de comprendre si la méthode est exécutée et évaluée correctement.

Par conséquent, je vais introduire un framework appelé `` DBUnit ''. DBUnit est un framework pour créer des programmes de test pour les classes qui opèrent sur des bases de données et étend JUnit.

• Possibilité de saisir des données de test dans DB
• Fonction pour nettoyer DB
• Fonction pour vérifier l'état de la base de données après l'exécution de la méthode

Il a des fonctions telles que. Ce chapitre décrit comment utiliser DBUnit pour décrire les classes de test qui effectuent le traitement de la base de données.

Installation de DBUtil

S'il s'agit d'un projet maven, vous pouvez utiliser DBUtil en écrivant ce qui suit dans pom.xml.

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>8.0.22</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.dbunit</groupId>
			<artifactId>dbunit</artifactId>
			<version>2.6.0</version>
		</dependency>

JUnit utilise la version 4.13.

Si vous souhaitez utiliser DBUtil au lieu du projet maven, vous pouvez l'utiliser en téléchargeant le fichier jar à partir du lien ci-dessous et en le passant par le chemin de classe. (Bien que non recommandé) http://www.dbunit.org/

Cette fois, nous utiliserons DBUnit pour effectuer les opérations suivantes:

• Supprimer les données de base de données avant de tester, insérer des données à partir de XML
• Obtenez des données de test pour la confirmation de mise à jour à partir de XML et exécutez la classe de test
• Supprimer les données de test

Créer une table de test

Puisque nous utilisons la base de données mysql cette fois, créez une table avec le SQL suivant.

CREATE TABLE user (
  Id INT NOT NULL,
  name  VARCHAR(255) NOT NULL,
  age INT NOT NULL,
  salary INT,
  job_type VARCHAR(20),
  hiredate  TIMESTAMP(6),
  department_id INT
);

Implémentation à tester

Créez une classe pour METTRE À JOUR un enregistrement.

TestMain

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 *Une classe avec main pour les tests DBUnit.
 */
public class TestMain {
  /**Enregistreur*/
  private static Logger logger = LoggerFactory.getLogger(TestMain.class);

  /**SQL à exécuter*/
  private static final String SQL
      = " update user set name = 'abc' where id = 1";

  /**
   * @param args
   */
  public static void main(String[] args) {
    logger.info("Commencer le traitement");

    // ---------------------------------
    //Mettre à jour la base de données
    // ---------------------------------
    try {
    	Class.forName("com.mysql.jdbc.Driver");
    	Connection conn = DriverManager.getConnection(
    	        "jdbc:mysql://localhost:3306/[Nom de la base de données]?serverTimezone=JST", "[Nom d'utilisateur]", "[mot de passe]");
    	        PreparedStatement stmt = conn.prepareStatement(SQL);

      conn.setAutoCommit(false);
      int i = stmt.executeUpdate();

      //Afficher le nombre de traitements
      logger.info("Nombre de dossiers traités:[" + i + "]");

      conn.commit();
    } catch(Exception e) {
      logger.error("Erreur", e);
    }

    logger.info("Sortie de traitement");
  }
}

Création d'un fichier XML à utiliser lors de l'exécution du test

Before.xml

<?xml version="1.0" encoding="UTF-8"?>
<dataset>
  <!--
Les données numériques sont également incluses dans XML pour les ensembles de données""Entourez de
Les dates de type DATE et TIMESTAMP sont "-Précisez en vous connectant
  -->
  <user
      ID="1"
      NAME="scott"
      AGE="22"
      SALARY="200000"
      JOB_TYPE="employee"
      HIREDATE="2017-01-01 12:34:56"
      DEPARTMENT_ID="1"
  />
</dataset>

After.xml

<?xml version="1.0" encoding="UTF-8"?>
<dataset>
  <!--
La date n'est pas sujette à vérification, mais je la listerai pour le moment.
Saisissez une date différente pour vérifier qu'elle a été filtrée.
  -->
  <user
      ID="1"
      NAME="abc"
      AGE="22"
      SALARY="200000"
      JOB_TYPE="employee"
      HIREDATE="2017-12-31 24:12:36"
      DEPARTMENT_ID="1"
  />
</dataset>

Before.xml correspond aux données à insérer avant d'exécuter la classe de test pour confirmer qu'un seul cas a été mis à jour. After.xml correspond aux données de base de données une fois la mise à jour effectuée. Il est utilisé lors de l'affirmation de la classe de test.

Implémentation de classe de test

TestMainTest

import static org.junit.Assert.*;

import java.io.File;

import org.dbunit.Assertion;
import org.dbunit.IDatabaseTester;
import org.dbunit.JdbcDatabaseTester;
import org.dbunit.dataset.IDataSet;
import org.dbunit.dataset.ITable;
import org.dbunit.dataset.filter.DefaultColumnFilter;
import org.dbunit.dataset.xml.FlatXmlDataSetBuilder;
import org.dbunit.operation.DatabaseOperation;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * [Classe d'essai]<br>
 *Test à l'aide de JUnit et DBUnit.<br>
 * <br>
 */
public class TestMainTest {
  /**Enregistreur*/
  private Logger logger = LoggerFactory.getLogger(TestMain.class);

  /**Testeur DBUnit*/
  private static IDatabaseTester databaseTester;

  /**
   * [Prétraitement]<br>
   *Préparez les données avancées dans DB.<br>
   * <br>
   * @throws java.lang.Exception
   */
  @Before
  public void setUp() throws Exception {
    logger.info("Commencer le prétraitement");

    // --------------------------------------
    //INSÉRER des données de préparation
    // --------------------------------------
    //Spécifiez le schéma pour INSERT des données de préparation
    databaseTester = new JdbcDatabaseTester("com.mysql.jdbc.Driver",
        "jdbc:mysql://localhost:3306/[Nom de la base de données]?serverTimezone=JST", "[Nom d'utilisateur]", "[mot de passe]");

    // --------------------------------------
    //Entrée de données de test
    // --------------------------------------
    IDataSet dataSet = new FlatXmlDataSetBuilder().build(new File("src/test/java/com/example/DBUnitDemo/data/Before.xml"));
    databaseTester.setDataSet(dataSet);
    //Préparer les données de préparation en SUPPRIMER → INSÉRER
    databaseTester.setSetUpOperation(DatabaseOperation.CLEAN_INSERT);
        databaseTester.onSetup();

    logger.info("Pré-traitement terminé");
  }

  /**
   * [Post-traitement]<br>
   *Effectuer un post-traitement post-test.<br>
   *Nettoyez l'unité DB.<br>
   * <br>
   * @throws java.lang.Exception
   */
  @After
  public void tearDown() throws Exception {
    databaseTester.setTearDownOperation(DatabaseOperation.NONE);
    databaseTester.onTearDown();
  }

  /**
   * [tester]<br>
   *Utilisez DBUnit pour vérifier le résultat de la mise à jour de la base de données.<br>
   */
  @Test
  public void test() {
    logger.info("JUnit +Commencez les tests avec DBUnit.");

    TestMain.main(null);

    try {
      // ----------------------------------
      //Contrôle des données après mise à jour avec DBUnit
      // ----------------------------------
      IDataSet expectedDataSet = new FlatXmlDataSetBuilder().build(new File("src/test/java/com/example/DBUnitDemo/data/After.xml"));
      ITable expectedTable = expectedDataSet.getTable("user");

      IDataSet databaseDataSet = databaseTester.getConnection().createDataSet();
      ITable actualTable = databaseDataSet.getTable("user");

      //L'assertion du temps échoue presque certainement, alors excluez-la de la vérification
      ITable filteredExpectedTable = DefaultColumnFilter.excludedColumnsTable(
          expectedTable, new String[]{"HIREDATE"});
      ITable filteredActualTable;
      filteredActualTable = DefaultColumnFilter.excludedColumnsTable(
          actualTable, new String[]{"HIREDATE"});

      // ---------------------------------------------------------------
      //Utilisez l'assertion DBUnit au lieu de JUnit pour valider les résultats de la mise à jour
      // ---------------------------------------------------------------
      Assertion.assertEquals(filteredExpectedTable, filteredActualTable);
    } catch (Exception e) {
      logger.error("Erreur", e);
      fail("Le test a échoué avec une erreur inattendue.");
    }

    logger.info("JUnit +Commencez le test avec DBUnit.");
  }
}

La méthode DBUnit utilisée cette fois est la suivante.

référence

Cette fois, nous avons présenté DBUnit et cet article est créé en faisant référence aux articles suivants. Il est écrit plus en détail, donc si vous voulez en savoir plus, veuillez vous y référer. [Pour les super débutants] Super introduction à DBUnit DBUnit Chargement de données d'Excel dans DB à l'aide de DBUnit avec Spring Boot