Java >> Java-zelfstudie >  >> Java

Hoe spionnen te gebruiken in Mockito

Java

Hallo. In deze tutorial zullen we Spy in Mockito begrijpen. Aangezien stubbing nu achterhaald is, zal ik me concentreren op @Spy annotatie in deze tutorial.

1. Inleiding

Mockito is een populair raamwerk dat wordt gebruikt om de interfaces of klassen te bespotten, zodat dummy-functionaliteit kan worden toegevoegd tijdens het testen van eenheden. Het is een op Java gebaseerde bibliotheek die de ontwikkeling van testgevallen helpt vereenvoudigen door de externe afhankelijkheden te bespotten. In dit voorbeeld bekijken we de Spy (d.w.z. @Spy ) in Mockito.

  • Annotatie wordt gebruikt om een ​​bestaande instantie te bespioneren
  • Helpt om een ​​object gedeeltelijk te bespotten
  • Het bespioneren van een object resulteert in het aanroepen van de echte methoden, tenzij het wordt stopgezet

In Mockito komen ingenieurs soms NotAMockException tegen wat het meest voorkomt in het geval dat men vergeet het object te bespotten of te bespioneren en probeert de methode ervan te bespotten. bijv. de onderstaande code genereert de uitzondering als when verwacht dat het bespotte object wordt doorgegeven.

Snippet 

UserSrv objUndrTest = new UserSrv();
// UserSrv objUndrTest = Mockito.mock(UserSrv.class)
Mockito.when(objUndrTest.getUsers(Mockito.any())).thenReturn(Collections.emptyList());

2. Oefenen

Laten we vanaf hier wat oefenen en ik neem aan dat je Java 1.8 of hoger al op je lokale computer hebt geïnstalleerd. Ik gebruik JetBrains IntelliJ IDEA als mijn favoriete IDE. U bent vrij om de IDE van uw keuze te kiezen. De onderstaande afbeeldingen tonen de projectstructuur.

2.1 De pom instellen

Voeg de onderstaande code toe aan het pom-bestand waar we de afhankelijkheden zullen specificeren die nodig zijn voor dit Java-project.

pom.xml 

<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns="http://maven.apache.org/POM/4.0.0"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">

  <artifactId>java-mockito-spies</artifactId>
  <dependencies>
    <!-- https://mvnrepository.com/artifact/org.mockito/mockito-junit-jupiter -->
    <dependency>
      <artifactId>mockito-junit-jupiter</artifactId>
      <groupId>org.mockito</groupId>
      <scope>test</scope>
      <version>4.5.1</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.mockito/mockito-core -->
    <dependency>
      <artifactId>mockito-core</artifactId>
      <groupId>org.mockito</groupId>
      <scope>test</scope>
      <version>4.5.1</version>
    </dependency>
  </dependencies>

  <description>Spies in mockito</description>

  <groupId>com.learning</groupId>
  <modelVersion>4.0.0</modelVersion>
  <name>Spies in mockito</name>

  <properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
  </properties>

  <version>0.0.1-SNAPSHOT</version>
</project>

2.2 De modelklasse maken

Maak een modelklasse in de com.learning.service.model pakket onder de src/main/java map.

Gebruiker.java 

package com.learning.service.model;

import java.util.UUID;

public class User {

  final UUID id;
  final String fullName;

  public User(final UUID id, final String name) {
    this.id = id;
    this.fullName = name;
  }

  public UUID getId() {
    return id;
  }

  public String getFullName() {
    return fullName;
  }
}

2.3 De opstelling maken

Om de uitvoering van Spy te begrijpen en te implementeren, moeten we eerst een implementatieklasse maken in de com.learning.service pakket onder de src/main/java map. De onderstaande code helpt bij het maken van een gebruikerslijst.

UserSrv.java 

package com.learning.service;

import com.learning.service.model.User;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class UserSrv {

  public List<User> getUsers(final boolean fetch) {
    final List<User> users = new ArrayList<>();
    if (fetch) {
      System.out.println("Populating list with elements");
      for (int i = 0; i < 10; i++) {
        users.add(new User(UUID.randomUUID(), "Some name_" + i));
      }
    }
    return users;
  }
}

2.4 De testklasse maken

Om de uitvoering van de spion te begrijpen, zullen we een testklasse maken in de com.learning.service pakket onder de src/test/java map.

UserSrvTest.java 

package com.learning.service;

import com.learning.service.model.User;
import java.util.List;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Spy;
import org.mockito.junit.jupiter.MockitoExtension;

/*
@Spy annotation is used to spy on an existing resource. It helps to partially mock an object.
 */
@ExtendWith(MockitoExtension.class)
public class UserSrvTest {

  @Spy
  private UserSrv objUndrTest;

  @Test
  public void getUsersShouldReturnEmployeeListIfFetchIsTrue() {
    final List<User> response = objUndrTest.getUsers(true);
    Assertions.assertNotNull(response);
    Assertions.assertEquals(response.size(), 10);
  }

  @Test
  public void getUsersShouldReturnEmptyEmployeeListIfFetchIsFalse() {
    Assertions.assertEquals(objUndrTest.getUsers(false).size(), 0);
  }
}

Voer het bestand uit als een java-bestand onder het JUnit-framework en men kan de uitvoering ervan debuggen. Als alles goed gaat, moeten alle testgevallen doorstaan. Als algemene aanbeveling zou er geen of minder logboekregistratie moeten zijn tijdens het uitvoeren van de testgevallen en daarom volgen we hetzelfde.

Dat is alles voor deze tutorial en ik hoop dat het artikel je heeft gediend met alles waar je naar op zoek was. Veel plezier met leren en vergeet niet te delen!

3. Samenvatting

In deze tutorial hebben we de praktische implementatie van Spy in Mockito besproken. U kunt de broncode downloaden in de sectie Downloads.

4. Download het project

Dit was een tutorial onder Spy in het Mockito-framework.Java Java-basics mockito bespotten

Java-tag