Het maken van uw Zwitserse Zeldopje op de Java Test Stack

De code-testbaarheden garanderen verschillende uitstekende punten in een efficiënt codeontwerp, zoals onderhoudbaarheid; het helpt bij documentatie en maakt het gemakkelijker om te refactoren en een evolutionair ontwerp/architectuur te bouwen. Daarover bestaat geen twijfel, maar wat is een goede teststack om een project te starten? Deze video zal de minimale teststack uitleggen om uw project te starten met Java.

Het eerste punt om te begrijpen als we het over het minimum hebben, is dat er geen zilveren kogels zijn op de teststack. Uiteindelijk moeten we afhankelijkheden toevoegen of verwijderen, vooral als we het over legacy code hebben. Daarom zal ik mijn favoriete teststack in Java geven, en ik gebruik en beveel aan als minimum om te starten vanaf nul:

• JUnit-Jupiter: De vijfde versie van JUnit breekt compatibiliteit met de vorige versie; toch is het het waard omdat het verschillende functies meebrengt, voornamelijk om aangepaste extensies te creëren.

• Mockito: Een super populaire mock-framework met Java. Deze populariteit en enorme community maken verschillende extensies mogelijk, zoals met JUnit-Jupiter.

• AssertJ: Als je van vloeiende API houdt zoals ik, dan is AssertJ een buitengewone bibliotheek voor jou.  

Met behulp van het maven-project kun je de afhankelijkheden van deze bibliotheken toevoegen:

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-engine</artifactId>
    <version>${junit.version}</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-params</artifactId>
    <version>${junit.version}</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <version>${mockito.verson}</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-junit-jupiter</artifactId>
    <version>${mockito.verson}</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.assertj</groupId>
    <artifactId>assertj-core</artifactId>
    <version>${assertj.verson}</version>
    <scope>test</scope>
</dependency>

Gegeven een voetbalkampioenschapcontext, waar we een team hebben dat elf spelers moet hebben, waarvan elke naam uniek moet zijn in het kampioenschap. We kunnen tests hierop uitvoeren.

Met JMockito en test beginnen, moeten we de service testen waar we moeten controleren of de naam bestaat uit de database om de logica te verwerken. Op dit moment hebben we het niet nodig en willen we geen integratietest maken. 

We willen ons richten op het bedrijfsgedeelte, dus willen we de database of framework niet testen, maar alleen mijn code. Daarom maken we de repository dus na met twee scenario’s, wanneer de naam er is en wanneer deze niet bestaat.

Met Mockito integratie met JUnit-Jupiter kun je alleen maar mock-objecten injecteren met behulp van annotaties. Het onderstaande codefragment toont de test met JMockito, waar we geen database nodig hebben of ons concentratiepunt verliezen om het bedrijfsgedeelte te testen.

@ExtendWith(MockitoExtension.class)
class ChampionshipServiceTest {

    @Mock
    private ChampionRepository repository;

    @InjectMocks
    private ChampionshipService service;

    @Test
    public void shouldRegister() {
        Mockito.when(repository.existByName("Bahia")).thenReturn(false);
        Team bahia = Team.of("Bahia");
        service.register(bahia);

        Mockito.verify(repository).existByName("Bahia");
    }
    @Test
    @DisplayName("should return an exception when there is a team with a name")
    public void shouldThrownAnExceptionWhenTeamNameExists() {
        Mockito.when(repository.existByName("Bahia")).thenReturn(true);
        Team bahia = Team.of("Bahia");
        Assertions.assertThrows(IllegalArgumentException.class, () ->
                service.register(bahia));

        Mockito.verify(repository).existByName("Bahia");
    }
}

AssertJ maakt de asserties gemakkelijker te begrijpen, dankzij de door de bibliotheek ondersteunde vloeiende API. Je kunt collecties, kaarten of een enkele instantie testen. Zoals we kunnen controleren of een speler aan het team is toegevoegd met behulp van het.

@Test
public void shouldCreatePlayers() {
    Team bahia = Team.of("Bahia");
    bahia.add(Player.of("Neymar", "Santos", 10));
    bahia.add(Player.of("Cristiano Ronaldo", "Lisbon", 10));

    org.assertj.core.api.Assertions.assertThat(bahia.players())
            .hasSize(2)
            .map(Player::name)
            .contains("Neymar", "Cristiano Ronaldo");
}

Neem dit en meer informatie op deze video.

Hoofdpunten:

• A minimum test stack to start Java

• Leer meer over JUnit en waarom het een goede keuze is

• Leer over mocks verkennen met JMockito

• Maak je test mooi met de vloeiende-API Assert: AssertJ