Verbessern Sie Ihre Karate-Tests mit Spring Boot DI

Ein paar Jahre lang habe ich Cucumber für Tests auf höherem Niveau verwendet und erst vor Kurzem mit Karate begonnen. Während Cucumber ein großartiges Tool ist, denke ich, dass Karate wirklich glänzt, indem es den mit Schrittdefinitionen einhergehenden Boilerplate reduziert und es einfach macht, schnell aussagekräftige Tests zu schreiben, insbesondere wenn es um API-Tests geht.

Für einfache Anwendungen reicht es aus, Ihre Feature-Dateien in einfachem JavaScript zu schreiben. Wenn Ihre Anwendung und Ihre Tests wachsen, kann die Wiederverwendung von Java-Code jedoch wertvoll sein. Spring Boot-APIs können von Karate-Tests stark profitieren, aber wie wäre es, wenn Sie die Leistung von Spring Boot direkt in Ihren Karate-Tests nutzen würden?

Einige Beispielanwendungsfälle

• Während Karate die Konfiguration über karate-config.js-Dateien unterstützt, möchten einige möglicherweise stattdessen die Konfiguration über Spring YAML/properties. Dies kann auch hilfreich sein, um Dinge außerhalb der Code-Neuerstellung neu zu konfigurieren.
• Um bestimmte Spring Boot-Konfigurationseigenschaften zwischen Anwendung und Tests zu synchronisieren.
• Zur Überprüfung des Datenbankstatus zwischen API-Aufrufen. JPA-Repository/Entity-Beans könnten in den Karate-Tests verwendet werden.
• Einige Frühlingsbohnen können für die Verwendung in Tests nützlich sein.

Wie man den Frühling in Karate integriert

Vollständiges Beispielprojekt: https://github.com/trey-pero/karate-spring

Karate kann über einen einfachen JUnit-Test ausgeführt werden. Um mit der Verkabelung von Spring zu beginnen, richten Sie den JUnit-Test als @SpringBootTest ein.

@RequiredArgsConstructor
@SpringBootTest(classes = Main.class)
public class KarateTest {
    private final ApplicationContext applicationContext;

    @Test
    void test() {
        ApplicationContextHolder.setApplicationContext(this.applicationContext);

        // Since this one JUnit test runs all Karate tests,
        // fail the test if any underlying Karate tests fail
        assertEquals(0, Runner.path("classpath:org/tpero")
                .parallel(Optional.ofNullable(System.getProperty("karate.threads"))
                        .map(Integer::parseInt)
                        .orElse(5)
                ).getFailCount());
    }
}

Um auf den Spring-Kontext zuzugreifen (der Zugriff auf alle Beans und Konfigurationen bietet), muss er an einem Ort gespeichert werden, an dem Karate statisch darauf zugreifen kann.

/**
 * Provides Karate static access to the Spring application context.
 */
@UtilityClass
public class ApplicationContextHolder {
    @Setter
    @Getter
    private ApplicationContext applicationContext;
}

Über die Karate-Konfiguration kann auf den statischen Halter zugegriffen werden, um den Anwendungskontext mithilfe des folgenden Beispiels mit der globalen Konfigurationskarte von Karate zu verbinden:

/**
 * Define common feature file configuration here.
 * @returns Common configuration as a JSON object.
 */
function getConfig() {
    // Global values
    const appContext = Java.type("org.tpero.ApplicationContextHolder")
        .getApplicationContext()
    const environment = appContext.getEnvironment()

    return {
        appContext: appContext,
        environment: environment,

        baseUrl: `http://localhost:${environment.getProperty('app.server.port', '8080')}`
    }
}

Mit dem oben genannten Setup-Code kann über Karate-Funktionsdateien auf Beans und Konfiguration zugegriffen werden, wie in diesem Beispiel gezeigt, das eine einfache Anmelde-API testet, die ein JWT-Token zurückgibt.

Feature: Login
  Background:
    * url baseUrl
    * path '/login'
    # Load the JWT service bean from Spring DI
    * def jwtService = appContext.getBean('jwtService')

  Scenario: Login with valid credentials
    Given request { username: 'user', password: 'password' }
    When method post
    Then status 200
    * print response

    # Use the JWT service bean to decode the JWT from the response
    * def decodedJwt = jwtService.decode(response)
    * print decodedJwt
    * def decodedBody = decodedJwt.getBody()
    * print decodedBody

    And match decodedBody['sub'] == 'user'
    * def issuedAt = Number(decodedBody['iat'])
    # Ensure the issuedAt is in the past
    And assert issuedAt < Java.type('java.lang.System').currentTimeMillis()
    * def configuredExpirationInMinutes = Number(environment.getProperty('jwt.expiration.ms')) / 1000
    # Ensure the expiration is the configurable amount of minutes beyond the issuedAt
    And match Number(decodedBody['exp']) == issuedAt + configuredExpirationInMinutes

Dieses Beispiel zeigt, wie einfach es ist, die Leistung von Spring Boot in Karate zu integrieren, um leistungsfähigere Testsuiten zu erstellen.

Das obige ist der detaillierte Inhalt vonVerbessern Sie Ihre Karate-Tests mit Spring Boot DI. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!