[JAVA] Erste Schritte mit DBUnit

Was ist DBUnit?

Sie haben häufig große Probleme beim Erstellen eines Testprogramms für einen Komponententest einer Klasse, die auf die Datenbank verweist oder diese aktualisiert. Die folgenden Probleme treten häufig auf, wenn die Datenbank auf Komponententests überprüft wird.

• Es braucht Zeit, um die Daten für den Test in die Datenbank zu stellen oder die Daten nach dem Test zu löschen und die Datenbank wiederherzustellen.
• "Eingabe und Bereinigung von Testdaten" erschwert das Programm und verringert die Wartbarkeit. Wie auch immer, ich kann keine Testprogramme lesen oder reparieren, die von anderen geschrieben wurden.
• Da das Programm kompliziert wird, ist es schwierig zu verstehen, ob die Methode korrekt ausgeführt und ausgewertet wird.

Daher werde ich ein Framework namens "DBUnit" einführen. DBUnit ist ein Framework zum Erstellen von Testprogrammen für Klassen, die mit Datenbanken arbeiten, und erweitert JUnit.

• Möglichkeit zur Eingabe von Testdaten in die DB
• Funktion zum Bereinigen der DB
• Funktion zum Überprüfen des DB-Status nach Ausführung der Methode

Es hat Funktionen wie. In diesem Kapitel wird beschrieben, wie Sie mit DBUnit Testklassen beschreiben, die die Datenbankverarbeitung durchführen.

DBUtil-Installation

Wenn es sich um ein Maven-Projekt handelt, können Sie DBUtil verwenden, indem Sie Folgendes in pom.xml schreiben.

		<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 verwendet Version 4.13.

Wenn Sie DBUtil anstelle des Maven-Projekts verwenden möchten, können Sie es verwenden, indem Sie die JAR-Datei über den folgenden Link herunterladen und über den Klassenpfad übergeben. (Obwohl nicht empfohlen) http://www.dbunit.org/

Dieses Mal verwenden wir DBUnit, um Folgendes zu tun:

• Löschen Sie die DB-Daten vor dem Testen und fügen Sie Daten aus XML ein
• Beziehen Sie Testdaten für die Aktualisierungsbestätigung aus XML und führen Sie die Testklasse aus
• Testdaten löschen

Erstellen einer Testtabelle

Da wir diesmal die MySQL-Datenbank verwenden, erstellen Sie eine Tabelle mit dem folgenden SQL.

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
);

Implementierung getestet werden

Erstellen Sie eine Klasse, um einen Datensatz zu aktualisieren.

TestMain

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

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

/**
 *Eine Klasse mit main für DBUnit-Tests.
 */
public class TestMain {
  /**Logger*/
  private static Logger logger = LoggerFactory.getLogger(TestMain.class);

  /**SQL auszuführen*/
  private static final String SQL
      = " update user set name = 'abc' where id = 1";

  /**
   * @param args
   */
  public static void main(String[] args) {
    logger.info("Starten Sie die Verarbeitung");

    // ---------------------------------
    //Aktualisieren Sie die Datenbank
    // ---------------------------------
    try {
    	Class.forName("com.mysql.jdbc.Driver");
    	Connection conn = DriverManager.getConnection(
    	        "jdbc:mysql://localhost:3306/[Name der Datenbank]?serverTimezone=JST", "[Nutzername]", "[Passwort]");
    	        PreparedStatement stmt = conn.prepareStatement(SQL);

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

      //Zeigen Sie die Anzahl der Verarbeitungen an
      logger.info("Anzahl der bearbeiteten Fälle:[" + i + "]");

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

    logger.info("Verarbeitung beenden");
  }
}

Erstellen einer XML-Datei zur Verwendung beim Ausführen des Tests

Before.xml

<?xml version="1.0" encoding="UTF-8"?>
<dataset>
  <!--
Numerische Daten sind auch in XML für Datensätze enthalten""Umgeben mit
Datumsangaben vom Typ DATE und TIMESTAMP sind "-Geben Sie durch Verbinden an
  -->
  <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>
  <!--
Das Datum unterliegt keiner Überprüfung, aber ich werde es vorerst auflisten.
Geben Sie absichtlich ein anderes Datum ein, um zu überprüfen, ob es gefiltert wurde.
  -->
  <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 sind die Daten, die vor dem Ausführen der Testklasse eingefügt werden müssen, um zu bestätigen, dass nur ein Fall aktualisiert wurde. After.xml sind die DB-Daten nach der Aktualisierung. Es wird verwendet, wenn die Testklasse aktiviert wird.

Implementierung der Testklasse

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;

/**
 * [Testklasse]<br>
 *Testen Sie mit JUnit und DBUnit.<br>
 * <br>
 */
public class TestMainTest {
  /**Logger*/
  private Logger logger = LoggerFactory.getLogger(TestMain.class);

  /**DBUnit-Tester*/
  private static IDatabaseTester databaseTester;

  /**
   * [Vorverarbeitung]<br>
   *Bereiten Sie Vorabdaten in der DB vor.<br>
   * <br>
   * @throws java.lang.Exception
   */
  @Before
  public void setUp() throws Exception {
    logger.info("Starten Sie die Vorverarbeitung");

    // --------------------------------------
    //EINFÜGEN von Vorbereitungsdaten
    // --------------------------------------
    //Geben Sie das Schema für INSERT der Vorbereitungsdaten an
    databaseTester = new JdbcDatabaseTester("com.mysql.jdbc.Driver",
        "jdbc:mysql://localhost:3306/[Name der Datenbank]?serverTimezone=JST", "[Nutzername]", "[Passwort]");

    // --------------------------------------
    //Dateneingabe testen
    // --------------------------------------
    IDataSet dataSet = new FlatXmlDataSetBuilder().build(new File("src/test/java/com/example/DBUnitDemo/data/Before.xml"));
    databaseTester.setDataSet(dataSet);
    //Bereiten Sie die Vorbereitungsdaten mit DELETE → INSERT vor
    databaseTester.setSetUpOperation(DatabaseOperation.CLEAN_INSERT);
        databaseTester.onSetup();

    logger.info("Vorverarbeitung beendet");
  }

  /**
   * [Nachbearbeitung]<br>
   *Führen Sie die Nachbearbeitung nach dem Test durch.<br>
   *Bereinigen Sie die DB-Einheit.<br>
   * <br>
   * @throws java.lang.Exception
   */
  @After
  public void tearDown() throws Exception {
    databaseTester.setTearDownOperation(DatabaseOperation.NONE);
    databaseTester.onTearDown();
  }

  /**
   * [Prüfung]<br>
   *Verwenden Sie DBUnit, um das Ergebnis der DB-Aktualisierung zu überprüfen.<br>
   */
  @Test
  public void test() {
    logger.info("JUnit +Starten Sie den Test mit DBUnit.");

    TestMain.main(null);

    try {
      // ----------------------------------
      //Datenprüfung nach Aktualisierung mit 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");

      //Die Behauptung für die Zeit schlägt mit ziemlicher Sicherheit fehl. Schließen Sie sie daher von der Überprüfung aus
      ITable filteredExpectedTable = DefaultColumnFilter.excludedColumnsTable(
          expectedTable, new String[]{"HIREDATE"});
      ITable filteredActualTable;
      filteredActualTable = DefaultColumnFilter.excludedColumnsTable(
          actualTable, new String[]{"HIREDATE"});

      // ---------------------------------------------------------------
      //Verwenden Sie DBUnit Assertion anstelle von JUnit, um die Aktualisierungsergebnisse zu überprüfen
      // ---------------------------------------------------------------
      Assertion.assertEquals(filteredExpectedTable, filteredActualTable);
    } catch (Exception e) {
      logger.error("Error", e);
      fail("Der Test schlug mit einem unerwarteten Fehler fehl.");
    }

    logger.info("JUnit +Starten Sie den Test mit DBUnit.");
  }
}

Die diesmal verwendete DBUnit-Methode lautet wie folgt.

Referenz

Dieses Mal haben wir DBUnit eingeführt. Dieser Artikel wurde unter Bezugnahme auf die folgenden Artikel erstellt. Es ist detaillierter geschrieben. Wenn Sie mehr wissen möchten, lesen Sie bitte. [Für Super-Anfänger] DBUnit Super-Einführung DBUnit Laden von Daten aus Excel in DB mit DBUnit mit Spring Boot