Testning på avancerad nivå: JUnit, Mockito och integrationstester · Lektion

Inbäddade databaser för tester

Konfigurera och använd minnesdatabaser eller inbäddade databaser för snabb och isolerad integrationstestning.

Lektion 3 av 411 steg

Inbäddade databaser för tester är en gratis lektion i Testning på avancerad nivå: JUnit, Mockito och integrationstester på CoddyKit. Detta är lektion 3 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Testning på avancerad nivå: JUnit, Mockito och integrationstester, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Testning på avancerad nivå: JUnit, Mockito och integrationstester innehåller totalt 4 lektioner.

Inbäddade databaser för tester

När du skriver integrationstester för Spring Boot-applikationer, särskilt sådana som interagerar med en databas, behöver du en databasinstans som testerna kan köras mot.

Inbäddade databaser tillhandahåller en lättviktig lösning i minnet som passar perfekt för detta scenario.

Varför använda inbäddade databaser?

Inbäddade databaser ger flera viktiga fördelar vid testning:

  • Isolering: Varje testkörning får en ren och ny databas, vilket förhindrar sidoeffekter.
  • Hastighet: Eftersom de körs i minnet är de mycket snabba, vilket minskar testkörningstiden.
  • Enkelhet: Det behövs inga externa databasservrar eller någon komplicerad konfiguration.
  • Upprepbarhet: Testerna blir konsekventa eftersom de alltid startar med samma datatillstånd.

Alternativen H2 och HSQLDB

Två populära alternativ för inbäddade databaser i Java-applikationer är H2 Database och HSQLDB.

  • H2: En snabb, öppen källkodsbaserad och JDBC-kompatibel databas i minnet. Den används ofta med Spring Boot.
  • HSQLDB: En annan lättviktig relationsdatabas skriven i Java.

Vi fokuserar på H2 eftersom det är ett vanligt standardalternativ i Spring Boot.

Lägga till H2-beroendet

För att använda H2 i ditt Spring Boot-projekt lägger du vanligtvis till det som ett beroende med test-omfattning i pom.xml (för Maven) eller build.gradle (för Gradle).

Det säkerställer att det bara är tillgängligt under testning.

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>test</scope>
</dependency>

Spring Boot-autokonfiguration

Ett av Spring Boots praktiska funktioner är autokonfiguration. När Spring Boot upptäcker H2 på classpath under tester konfigurerar det automatiskt en H2-databas i minnet åt dig.

Du behöver ofta inte ange någon databas-URL i application.properties för tester, vilket gör konfigurationen mycket enkel!

User-entitet och repository

Vi utgår från en enkel User-entitet och ett UserRepository. Vi vill testa om vårt repository sparar och hämtar användare korrekt.

Det här är standardkomponenter i JPA.

// User.java
package com.coddykit.demo;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String name;
    private String email;

    public User() {}
    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }

    // Getters and Setters
    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

// UserRepository.java
package com.coddykit.demo;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    User findByName(String name);
}

@DataJpaTest med H2

Spring Boot tillhandahåller @DataJpaTest specifikt för testning av JPA-komponenter. Den autokonfigurerar en databas i minnet, till exempel H2 om den finns tillgänglig, samt en EntityManager.

Den återställer även transaktioner efter varje test, vilket säkerställer ett rent tillstånd.

Exempel på test av UserRepository

Så här kan du skriva ett integrationstest för vårt UserRepository med H2 och @DataJpaTest:

package com.coddykit.demo;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.boot.test.autoconfigure.orm.jpa.TestEntityManager;
import static org.assertj.core.api.Assertions.assertThat;

@DataJpaTest
class UserRepositoryTest {

    @Autowired
    private TestEntityManager entityManager;

    @Autowired
    private UserRepository userRepository;

    @Test
    void whenFindByName_thenReturnUser() {
        // given
        User alice = new User("Alice", "alice@example.com");
        entityManager.persist(alice);
        entityManager.flush();

        // when
        User found = userRepository.findByName(alice.getName());

        // then
        assertThat(found.getName()).isEqualTo(alice.getName());
        assertThat(found.getEmail()).isEqualTo(alice.getEmail());
    }

    @Test
    void whenInvalidName_thenReturnNull() {
        // when
        User found = userRepository.findByName("InvalidName");

        // then
        assertThat(found).isNull();
    }
}

Initiering av schema och data

I mer komplexa scenarier kan du behöva fylla databasen i minnet med ett schema eller initiala data.

  • Placera schema.sql i src/test/resources för DDL (Data Definition Language).
  • Placera data.sql i src/test/resources för DML (Data Manipulation Language).

Spring Boot hittar och använder automatiskt dessa filer i dina tester.

Snabb kontroll

Vilket av följande är INTE en huvudsaklig fördel med att använda en inbäddad databas som H2 i Spring Boot-integrationstester?

Sammanfattning och nästa steg

Vi har undersökt hur inbäddade databaser som H2 är ovärderliga för snabba och isolerade Spring Boot-integrationstester.

  • De ger snabbhet, isolering och enkelhet.
  • Spring Boot autokonfigurerar dem med minimal arbetsinsats.
  • @DataJpaTest förenklar testning av JPA-repositories med dessa databaser.
  • Du kan initiera scheman och data med schema.sql och data.sql.

Därefter kan du utforska testning av RESTful API:er med MockMvc!

Gratis att börja

Lär dig Testning på avancerad nivå: JUnit, Mockito och integrationstester med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser
12
Lektioner
48

Vanliga frågor

Är lektionen ”Inbäddade databaser för tester” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Testning på avancerad nivå: JUnit, Mockito och integrationstester, inklusive ”Inbäddade databaser för tester”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Testning på avancerad nivå: JUnit, Mockito och integrationstester innehåller totalt 4 lektioner.

Vad lär jag mig i ”Inbäddade databaser för tester”?

Konfigurera och använd minnesdatabaser eller inbäddade databaser för snabb och isolerad integrationstestning. Ni övar på Testning på avancerad nivå: JUnit, Mockito och integrationstester med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Testning på avancerad nivå: JUnit, Mockito och integrationstester?

Du behöver inga förkunskaper. Utbildningen i Testning på avancerad nivå: JUnit, Mockito och integrationstester på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Inbäddade databaser för tester”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Testning på avancerad nivå: JUnit, Mockito och integrationstester-lektionen?

Ja. Varje Testning på avancerad nivå: JUnit, Mockito och integrationstester-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

  1. Spring Test Context Framework
  2. Testa REST-API:er
  3. Inbäddade databaser för tester
  4. Testa webblager med @WebMvcTest och MockMvc
← Tillbaka till Testning på avancerad nivå: JUnit, Mockito och integrationstester