[JAVA] Test de l'API REST à l'aide de REST Assured Part 2

introduction

J'ai utilisé REST Assured dans le précédent "REST API test using REST Assured". J'ai écrit une introduction sur la façon d'écrire des tests d'API REST. La dernière fois, je l'ai seulement touché, mais cette fois j'écrirai un contenu plus pratique.

Comment utiliser

À propos de la réponse

Valider la réponse à l'aide de JSONPath

Décrivez en utilisant la méthode d'analyse dans JSONPath. La requête est lancée comme d'habitude avec given (). Get () ou given (). Post (), et la réponse est analysée après then ().

    @Test
test du vide public() {
        given()
                .get("/v1/clients/15930/account-periods")
        .then()
                .body("accountPeriods", hasSize(3))
                .body("accountPeriods.accountPeriodId", hasItems(24216, 24582, 24583))
                .body("accountPeriods[0].accountPeriodId", equalTo(24216))

        ;
    }

hasSize () et hasItem (), ʻequalTo () sont ʻimport static org.hamcrest.Matchers. *; Vous pouvez l'appeler en définissant . L'analyse de JSON avec JSONPath découle essentiellement de Root avec . comme délimiteur. Il existe différentes notations, veuillez donc les essayer.

Analyser le JSON du corps de la réponse et recevoir la partie spécifique sous forme de chaîne

Dans l'exemple précédent, la réponse est directement affirmée, mais j'écrirai une méthode pour la recevoir en tant que variable une fois.

    @Test
test du vide public() {
        String response = get("/v1/clients/15930/account-periods").asString(); //Recevoir ResponseBody sous forme de chaîne
        int id = from(response).get("accountPeriods[0].accountPeriodId"); //Analyser en tant que JSON et obtenir la cible avec JSONPath
        out.println(id);
    }

Lancez une requête directement avec get () et recevez le résultat sous forme de chaîne comme ʻasString () . Puis analysez-le comme JSON avec from (String)puis utilisez JSONPath avecget ()` pour obtenir la partie spécifiée dans le JSON.

Vous pouvez l'écrire de cette manière, par exemple lorsque vous souhaitez inclure la valeur de Response dans la prochaine requête.

À propos de la demande

Ensuite, je vais expliquer la variation de la façon de lancer une requête.

Utiliser des paramètres de chemin (utiliser des arguments de longueur variable)

La première méthode d'utilisation du paramètre de chemin de l'URI consiste à transmettre la partie variable avec un argument de longueur variable. Suivez la Documentation officielle sur les paramètres de chemin.

Ici, le journal de la requête est également craché.

    @Test
paramètre de chemin public void() {
        given()
                .log()
                .all()
                .get("/v1/clients/{id}/account-periods", 15930)
        .then()
                .body("accountPeriods", hasSize(3))
        ;
    }

Dans la partie avec get (" / v1 / clients / {id} / account-period ", 15930), l'argument 15930 est appliqué à la partie avec {id}, et / v1 / clients / 15930 La méthode GET est appelée pour / account-period.

Puisqu'il est défini sur log (). All (), le journal Requst est sorti sur la sortie standard et peut être vérifié.

Utiliser les paramètres de chemin (utiliser la carte)

Explique comment transmettre les paramètres de chemin dans Map. Passez la carte comme argument comme get (" / v1 / clients / {id} / {api} ", params), obtenez la valeur de la carte avec les variables ʻid, ʻapi dans le chemin comme clé, et passez Est assemblé.

    @Test
Public void Path Parameta Map() {
        Map<String, String> params = new HashMap<String, String>();
        params.put("id", "15930");
        params.put("api", "account-periods");
        given()
                .log()
                .all()
                .get("/v1/clients/{id}/{api}", params)
        .then()
                .body("accountPeriods", hasSize(3))
        ;
    }

Inclure JSON dans le corps de la demande

Explique comment inclure JSON dans Request, ce qui est courant dans l'API REST. Tout comme Documentation officielle sur Request Body, vous pouvez définir JSON dans l'argument de body (). est. Comme la sortie du journal de Request est également définie, vous pouvez vérifier si elle a été réellement POSTÉE.

    private static String postJson = "{sessionId: \"abc\"}";

    @Test
test de transmission JSON public void() {
        given()
                .log() //Se déconnecter
                .all() //Tout
                .body(postJson) //Demander les paramètres du corps
                .post("/v1/clients/15930/account-periods")

        .then()
                .log()
                .body()
        ;
    }

À la fin

Nous avons introduit quelques exemples utilisant REST Assured. En réalité, divers modèles seront nécessaires pour les tests, mais le nom est intuitivement compris par l'API et Document officiel Assured / wiki / Usage) est si riche que vous ne vous perdrez pas.

Session Filter qui effectue un traitement de routine au moment de l'authentification et [Logging](https: /) qui a également été utilisé dans l'exemple /github.com/rest-assured/rest-assured/wiki/Usage#logging), [Validation de schéma JSON](https://github.com/rest-assured/rest-assured/wiki/Usage#json-schema- validation) etc. sont également expliqués. Veuillez lire la documentation officielle et essayez-la.