Améliorez vos tests de karaté avec Spring Boot DI

Depuis quelques années, j'utilise Cucumber pour des tests de niveau supérieur, et ce n'est que plus récemment que j'ai commencé à utiliser le Karaté. Bien que Cucumber soit un excellent outil, je pense que le karaté brille vraiment en réduisant le passe-partout qui accompagne les définitions d'étapes et en facilitant l'écriture rapide de tests significatifs, en particulier lorsqu'il s'agit de tests d'API.

Pour les applications simples, écrire vos fichiers de fonctionnalités en simple JavaScript suffira. À mesure que votre application et vos tests se développent, la réutilisation d'une partie du code Java peut cependant devenir utile. Les API Spring Boot peuvent bénéficier grandement des tests de Karate, mais que diriez-vous de tirer parti de la puissance de Spring Boot directement dans vos tests de Karate ?

Quelques exemples de cas d'utilisation

• Bien que Karate prenne en charge la configuration via les fichiers karate-config.js, certains préféreront peut-être la configuration via Spring YAML/properties. Cela peut également être utile pour reconfigurer des éléments en dehors de la reconstruction du code.
• Pour synchroniser certaines propriétés de configuration Spring Boot entre l'application et les tests.
• Pour vérifier l'état de la base de données entre les appels d'API. Les beans de référentiel/entité JPA pourraient être utilisés dans les tests de Karaté.
• Certains haricots de printemps peuvent simplement être utiles à utiliser dans les tests.

Comment intégrer Spring dans le Karaté

Exemple de projet complet : https://github.com/trey-pero/karate-spring

Le karaté peut être exécuté via un simple test JUnit. Pour commencer à câbler Spring In, configurez le test JUnit en tant que @SpringBootTest.

@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());
    }
}

Afin d'accéder au contexte Spring (qui donne accès à tous les beans et à la configuration), il doit être stocké quelque part pour que Karate puisse y accéder de manière statique.

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

Depuis la configuration de Karate, le support statique est accessible pour câbler le contexte de l'application dans la carte de configuration globale de Karate à l'aide de l'exemple suivant :

/**
 * 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')}`
    }
}

Avec le code de configuration ci-dessus, les beans et la configuration sont accessibles à partir des fichiers de fonctionnalités de Karate, illustré par cet exemple qui teste une API de connexion simple qui renvoie un jeton JWT.

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

Cet exemple montre à quel point il est facile d'intégrer la puissance de Spring Boot dans Karate pour créer des suites de tests plus performantes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!