[JAVA] [Für Super-Anfänger] DBUnit Super-Einführung
Einführung
Diesmal ist es ein großer Erfolg in der Programmentwicklung! Einführung in die Verwendung von "DBUnit", einem Framework, das in Unit-Tests verwendet werden kann.
DBUnit ist eines der in Java verwendeten Test-Frameworks, aber aus dem Gefühl heraus, dass ich es studiert habe, schien es, dass die Artikel alt waren und dass es nur wenige Websites gab, die völlig ausreichend waren, so dass es eine Erinnerung an den Autor war. Ich werde es hier zusammenfassen, um es mit denen zu teilen, die diesen Artikel lesen.
Es gibt viele nette Leute, die die Materialien als Referenz ins Internet gestellt haben, aber orz
1. Was ist DBUnit?
Wie bereits erwähnt, ist DBUnit eines der Java-Programmtest-Frameworks. Wenn Sie das Worttest-Framework hören, können Sie sich XUnit vorstellen. Da das Ziel dieser Zeit ein in Java implementiertes Programm ist, wird häufig JUnit verwendet, DBUnit wird jedoch auch zusammen mit JUnit verwendet.
In JUnit können Sie den Rückgabewert der im Programm verarbeiteten Methode und den übergebenen Parameter überprüfen, in DBUnit können Sie den in der DB aktualisierten Wert überprüfen. Außerdem können Testdaten vor Testbeginn in die DB geladen werden.
Es scheint, dass es viele Menschen gibt, die die Existenz selbst nicht kennen, aber wenn Sie sie beherrschen können, wird der Komponententest (im Folgenden UT) viel "einfacher und genauer" sein. Wenn Sie also interessiert sind, lesen Sie diesen Artikel bitte bis zum Ende ..
2. Erstellen Sie ein Testprojekt
Erstellen Sie zunächst ein Testprojekt zum Testen von DBUnit. Das Testen des Test-Frameworks klingt etwas seltsam, aber das interessiert mich nicht.
Ich habe Maven schon einmal studiert und jetzt drücke ich Maven, also wird dieses Testprojekt mit Maven und Eclipse erstellt.
Für den Bau des Maven-Projekts würde ich mich freuen, wenn Sie auf den Artikel hier verweisen könnten, den ich zuvor geschrieben habe. Ändern Sie den Projektnamen und die Konfiguration nach Ihren Wünschen. Dieses Mal nannte ich es "dbunit-test" und fügte die folgenden Bibliotheken als Abhängigkeiten hinzu.
Beschreiben Sie den Projektbaum und die Einstellungen von pom.xml.
Projektbaum
Projektstamm
├─src
│ ├─main
│ │ ├─java
│ │ │ └─test
│ │ │ └─main
│ │ │ TestMain.java
│ │ │
│ │ └─resources
│ │
│ └─test
│ ├─java
│ │ └─test
│ │ └─main
│ │ TestMainTest.java
│ │
│ └─resources
│ logback.xml
│
├─target
│ ├─classes
│ │ │ logback.xml
│ │ │
│ │ └─test
│ │ └─main
│ │ TestMain.class
│ │
│ └─test-classes
│ │ logback.xml
│ │
│ └─test
│ └─main
│ TestMainTest.class
│
├─data
│ Before.xml ---Vorbereitungsdaten
│ After.xml ---Ergebnisüberprüfungsdaten
└─pom.xml
pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>dbunit.test</groupId>
<artifactId>dbunit-test</artifactId>
<version>0.0.1-SNAPSHOT</version>
<!--Zeichencode und Java-Versionseinstellungen-->
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<!--Logger-Einstellungen-->
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.3</version>
</dependency>
<dependency>
<!--
Da diesmal Oracle für die Datenbank verwendet wird, wird als JDBC-Treiber der von Oracle verwendet.
Der JDBC-Treiber von Oracle befindet sich nicht im zentralen Repository von Maven. Verwenden Sie daher den in Ihrem lokalen Repository installierten.
Nicht direkt mit DBUnit verbunden, sondern wie die Bibliothek in einem lokalen Repository installiert wird
Abschließend werde ich es als Referenz beschreiben.
-->
<groupId>com.oracle</groupId>
<artifactId>ojdbc7</artifactId>
<version>11.2.0</version>
</dependency>
<!--Zum Testen verwendete Bibliothek-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.dbunit</groupId>
<artifactId>dbunit</artifactId>
<!--Spätestens zum Zeitpunkt des Schreibens des Artikels-->
<version>2.5.3</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.6.1</version>
<configuration>
<source>${java.version}</source>
<target>${java.version}</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
In diesem Artikel wird Maven verwendet, Sie müssen jedoch nicht Maven sein, solange Sie JUnit und DBUnit zu Ihrem Erstellungspfad hinzufügen. JUnit kann ein Eclipse-Plug-In sein. Ändern Sie daher die Projekteinstellungen nach Ihren Wünschen.
3. Erstellen Sie eine Testtabelle
Erstellen Sie eine Testtabelle, die im Testprogramm implementiert werden soll. Dieses Mal verwenden wir die Datenbank und den traditionellen SCOTT-Benutzer, die während der Oracle-Installation automatisch generiert werden. Die verwendete Tabelle ist auch die EMP-Tabelle, die in Lehrbüchern bekannt ist. Wenn Sie die Standardeinstellung mit der Oracle-Installation erstellt haben, wird sie von Anfang an automatisch erstellt, aber schreiben Sie die DDL der Tabelle.
EMP-Tabelle DDL
CREATE TABLE SCOTT.EMP (
ID NUMBER NOT NULL,
NAME VARCHAR2(255) NOT NULL,
AGE NUMBER NOT NULL,
SALARY NUMBER,
JOB_TYPE VARCHAR2(20),
HIREDATE TIMESTAMP(6),
DEPARTMENT_ID NUMBER
);
Wir werden die Tabelle erstellen, aber dieses Mal möchten wir die Testdaten als DBUnit laden, also lassen Sie die Tabelle leer.
4. Implementierung des Testprogramms
Nachdem Sie das Projektskelett erstellt haben, implementieren Sie das Testprogramm. Es ist nur ein Beispiel, es ist also ein Programm, das nur die Datensätze in einer Tabelle aktualisiert.
4.1. Durchführung des zu testenden Programms
Das zu testende Beispielprogramm ist "TestMain.java". Das Testprogramm verwendet Logback, dies ist jedoch ein Bonus, sodass Sie es nicht verwenden müssen. Wenn Sie Logback verwenden, können Sie das Debug-Protokoll von DBUnit sehen, was sehr praktisch ist.
TestMain.java
package test.main;
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.
* @author tarosa0001
*/
public class TestMain {
/**Logger*/
private static Logger logger = LoggerFactory.getLogger(TestMain.class);
/**SQL auszuführen*/
private static final String SQL
= " update "
+ " EMP "
+ " set "
+ " name = 'tiger' "
+ " where "
+ " id = 1";
/**
* @param args
*/
public static void main(String[] args) {
logger.info("Starten Sie die Verarbeitung");
// ---------------------------------
//Aktualisieren Sie die Datenbank
// ---------------------------------
try(Connection conn = DriverManager.getConnection(
"jdbc:oracle:thin:@localhost:1521:ORCL", "scott", "tiger");
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");
}
}
4.2. Implementierung der JUnit + DBUnit-Testquelle
Ab hier ist die Produktion. Implementieren Sie eine Testquelle mit JUnit und DBUnit. Das Implementierungsziel ist "TestMainTest.class". Beschreibt den Inhalt des Testprogramms. Hier werden die Testdaten in die Vorverarbeitung geladen und die Ergebnisdaten werden durch die Testmethode verifiziert, aber der Inhalt jeder Daten wird später beschrieben.
TestMainTest.class
package test.main;
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>
* @author tarosa0001
*/
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("oracle.jdbc.driver.OracleDriver",
"jdbc:oracle:thin:@localhost:1521:ORCL", "scott", "tiger", "scott");
// --------------------------------------
//Dateneingabe testen
// --------------------------------------
IDataSet dataSet = new FlatXmlDataSetBuilder().build(new File("./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("./data/After.xml"));
ITable expectedTable = expectedDataSet.getTable("EMP");
IDataSet databaseDataSet = databaseTester.getConnection().createDataSet();
ITable actualTable = databaseDataSet.getTable("EMP");
//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.");
}
}
4.3 Laden von Vorbereitungsdaten Verwenden Sie DBUnit, um die vorbereiteten Daten zu laden. Sowohl die Vorbereitungsdaten als auch die Ergebnisüberprüfungsdaten verwenden XML.
Ich hasse XML, deshalb möchte ich im Grunde genommen so etwas in Excel oder CSV erstellen, aber in CSV können Sie nur eine Datei und eine Tabelle definieren, und in Excel steht der Blattname für den Tabellennamen. DBUnit-Testdaten verwenden XML, da einige unangenehme Faktoren wie mangelnde Länge vorliegen.
Beschreibt den XML-Inhalt der Vorbereitungsdaten und der Ergebnisüberprüfungsdaten. Die Vorbereitungsdaten sind "Before.xml" und die Ergebnisüberprüfungsdaten sind "After.xml".
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
-->
<EMP
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.
-->
<EMP
ID="1"
NAME="tiger"
AGE="22"
SALARY="200000"
JOB_TYPE="employee"
HIREDATE="2017-12-31 24:12:36"
DEPARTMENT_ID="1"
/>
</dataset>
Oben sind Datum und Uhrzeit des DATE-Typs festgelegt, es ist jedoch auch möglich, das aktuelle Datum und die aktuelle Uhrzeit wie SYSDATE festzulegen. In diesem Fall [hier](https://hondou.homedns.org/pukiwiki/pukiwiki.php?xUnit%20DbUnit%20%A4%C7%A1%A2%BD%E9%B4%FC%A5%C7% A1% BC% A5% BF% A4% CB% B8% BD% BA% DF% BB% FE% B9% EF% A4% F2% C0% DF% C4% EA% A4% B7% A4% BF% A4% Siehe A4) als Referenz.
5. Führen Sie das Testprogramm aus
Nachdem wir die Vorbereitungsarbeiten abgeschlossen haben, führen wir das Testprogramm aus. Da wir jedoch die Änderungen in der Datenbank sehen möchten, zeichnen wir den Status vor der Ausführung auf.
5.1. Status vor der Ausführung
Die Pre-Execution-Tabelle enthält leere Datensätze. Es spielt keine Rolle, ob es Aufzeichnungen gibt, aber wir gehen von dem Zustand aus, in dem es leicht zu verstehen ist.
■ Tabellenstatus vor der Ausführung
5.2 Führen Sie den Test aus
Lassen Sie uns nun den Test ausführen. Führen Sie das erstellte Projekt als JUnit-Test aus. Das Ergebnis ist wie folgt, ich denke, dass es normal ohne Fehler endete.
■ Ergebnis der JUnit-Ausführung
Jetzt können Sie den Test mit JUnit + DBUnit erstellen und ausführen. Dieses Mal haben wir nur eine Vorbereitungs- und eine Ergebnisdatenvorbereitung vorbereitet. Wenn wir jedoch mehrere Daten aufbereiten und das für jeden Test zu lesende XML ändern, werden für jeden Testfall automatisch neue Daten geladen, und wir haben dies erwartet. Die Ergebnisse können automatisch überprüft werden.
6. Demontage testen
Bisher haben wir eingeführt, wie automatische Tests mit JUnit + DBUnit durchgeführt werden, aber wie wäre es damit? Auf die Frage, ob automatisierte Tests gut sind, ist dies nicht der Fall, aber es ist ziemlich mühsam, den Test immer wieder zu wiederholen und die Testergebnisse immer wieder zu erhalten, sodass so viele Tests automatisiert werden können. In einigen Fällen ist dies ein großer Vorteil.
Bisher haben wir nur darüber gesprochen, DBUnit in Eile auszuführen, aber von nun an werden wir die Lauftests Schritt für Schritt aufschlüsseln. Insbesondere werden wir es in die nächsten Schritte aufteilen und in jedem Schritt das Verhalten des Programms und den Status der Datenbank untersuchen.
- Laden der Vorbereitungsdaten
- Status im zu testenden Programm
- Überprüfung der Testergebnisse
Lassen Sie uns nun sehen, wie das Testprogramm beim Ausführen des Debugs unter Eclipse funktioniert.
6.1. Laden von Vorbereitungsdaten
Lassen Sie uns zunächst die Bewegung überprüfen, wenn Sie die Vorbereitungsdaten von DBUnit laden.
6.1.1 Status vor der Ausführung
Der Tisch wurde einmal geleert.
■ Tabellenstatus vor der Ausführung
6.1.2 Unmittelbar nach dem Ende der Vorverarbeitung
Unmittelbar nach Abschluss der Vorverarbeitung können Sie sehen, dass die aus Before.xml gelesenen Daten genau enthalten sind. Da das Testzielprogramm die Datenbank während der Verarbeitung AKTUALISIERT, handelt es sich um ein Masterdiagramm, das nicht gut funktioniert, wenn keine Datensätze vorhanden sind. Es funktioniert jedoch normal, da es in einem Zustand startet, in dem in dieser Vorverarbeitung keine Datensätze eingefügt werden. ist.
■ Programmausführungsschritte
■ DB-Status
6.1.3. Status während des Testprogramms
Mal sehen, wie das Testprogramm läuft. Da der zu aktualisierende Datensatz in die Vorverarbeitung eingefügt wird, können Sie sehen, dass UPDATE normal ausgeführt wurde und sich der Status der Datenbank geändert hat.
■ Vor dem Ausführen von UPDATE
■ Nach dem Ausführen von UPDATE
■ DB-Status nach Ausführung
6.1.4 Überprüfung der Testergebnisse
Schauen wir uns zum Schluss die Überprüfung der Testergebnisse an. Da der DB-Status wie erwartet ist, schlägt die DBUnit-Zusicherung den Test nicht fehl und der Zusicherungsprozess wird normal ausgeführt. Das Endergebnis nach Ausführung der Zusicherung ist wie oben beschrieben.
■ Vor dem Ausführen der Zusicherung
■ Nach dem Ausführen der Zusicherung
7. Schließlich
Dies ist der letzte Teil dieses langen Artikels. Ich habe DBunit schon lange eingeführt, aber wie wäre es damit? DBUnit ist ein Tool zum Automatisieren von Komponententests. Bei ordnungsgemäßer Verwendung kann es jedoch ein nützliches Tool zum Laden anderer Testdaten als Komponententests sein.
Es ist zwar praktisch, erfordert jedoch viel Zeit und Mühe, sodass es nicht immer verwendet werden kann. In diesem Artikel gab es nur einen Test, sodass es nicht allzu schwierig war. Wenn Sie jedoch viele Tabellen vorbereiten müssen oder ein Programm, das viele Datensätze gleichzeitig verarbeitet, automatisieren wir die Überprüfung. Es ist jedoch viel Arbeit, da eine große Menge an Testdaten vorbereitet werden muss.
In diesem Sinne wäre ich nicht so glücklich, wenn Sie es gut verwenden würden.
8. Referenz
Ich werde die Referenz beschreiben, die nicht direkt in diesem Artikel beschrieben wurde. Beim Schreiben des Artikels habe ich auf das folgende Web verwiesen. Vielen Dank an die Manager und Autoren für das Schreiben des Artikels.
■ So installieren Sie die Bibliothek im lokalen Repository von Maven http://sinsengumi.net/blog/2012/12/maven%E3%83%AA%E3%83%9D%E3%82%B8%E3%83%88%E3%83%AA%E3%81%A7%E6%8F%90%E4%BE%9B%E3%81%95%E3%82%8C%E3%81%A6%E3%81%84%E3%81%AA%E3%81%84%E3%82%B5%E3%83%BC%E3%83%89%E3%83%91%E3%83%BC%E3%83%86%E3%82%A3jar/
■ Mit DBUnit http://jyukutyo.hatenablog.com/entry/20060630/1151636345
Recommended Posts