Como baixar o Jar io.restassured
Se você estiver trabalhando com APIs REST em Java, talvez já tenha ouvido falar io.restaurado jar. Esta é uma biblioteca que simplifica o teste e a validação de APIs REST, fornecendo uma DSL (linguagem específica de domínio) altamente influenciada por técnicas de teste usadas em linguagens dinâmicas, como Ruby e Groovy. Neste artigo, mostraremos como baixar io.restaurado jar e como usá-lo em seus projetos.
download io.restassured jar
Pré-requisitos
Antes de poder baixar io.restaurado jar, você precisa ter alguns pré-requisitos instalados em seu sistema:
Maven: Esta é uma ferramenta de construção que gerencia as dependências e o ciclo de vida do projeto. Você pode baixá-lo de .
Java: Esta é a linguagem de programação que io.restaurado jar está escrito. Você precisa ter o Java 8 ou superior instalado em seu sistema. Você pode baixá-lo de .
IDE: Este é um ambiente de desenvolvimento integrado que ajuda você a escrever, compilar e executar o código Java. Você pode usar qualquer IDE de sua escolha, como Eclipse, IntelliJ IDEA, NetBeans, etc.
Baixando o Jar io.restassured usando o Maven
A maneira mais fácil de baixar io.restaurado jar é usar o Maven como sua ferramenta de gerenciamento de dependência. Tudo o que você precisa fazer é adicionar a seguinte dependência em seu pom.xml arquivo:
<dependency> <groupId>io.rest-assured</groupId> <artifactId>rest-assured</artifactId> <version>5.3.1</version> <scope>test</scope> </dependency>
Isso dirá ao Maven para baixar io.restaurado jar e suas dependências transitivas, como json-path, caminho xml, hamcrest-all, etc., do Repositório Central Maven. Você pode encontrar a versão mais recente do io.restaurado jarra Depois de adicionar a dependência, você precisa atualizar seu projeto para que o Maven possa baixar os arquivos jar. Você pode fazer isso clicando com o botão direito do mouse em seu projeto em seu IDE e selecionando Maven -> Atualizar Projeto. Como alternativa, você pode executar o seguinte comando em seu terminal:
mvn instalação limpa
Isso limpará seu projeto, instalará as dependências e construirá seu projeto.
Baixando o Jar io.restassured manualmente
Se você não quiser usar o Maven, você também pode baixar io.restaurado jar manualmente no site oficial. Você pode encontrar o link para download . Você precisa baixar o fique tranquilo-5.3.1-dist.zip arquivo, que contém os arquivos jar e o código-fonte. Você pode descompactar o arquivo e copiar os arquivos jar para uma pasta de sua escolha.
No entanto, baixando io.restaurado jar manualmente não é suficiente. Você também precisa baixar suas dependências, como json-path, caminho xml, hamcrest-all, etc., e adicione-os ao classpath do seu projeto. Você pode encontrar a lista de dependências . Você precisa baixar cada dependência e copiar os arquivos jar para a mesma pasta que io.restaurado jar.
Depois de baixar todos os arquivos jar, você precisa adicioná-los ao classpath do seu projeto. Esta é uma lista de pastas e arquivos que informam ao seu IDE onde encontrar as classes e métodos que você usa em seu código. Você pode fazer isso clicando com o botão direito do mouse em seu projeto em seu IDE e selecionando Caminho de construção -> Configurar caminho de construção. Então, você precisa clicar em Adicionar JARs externos e selecione todos os arquivos jar que você baixou. Isso irá adicioná-los ao classpath do seu projeto e disponibilizá-los para uso.
Verificando o download
Para verificar se você baixou com sucesso io.restaurado jar e suas dependências, você pode tentar importar algumas classes e métodos da biblioteca em seu código. Por exemplo, você pode tentar importar o seguinte:
import io.restassured.RestAssured; import io.restassured.response.Response; importar io.restassured.matcher.RestAssuredMatchers.*; import org.hamcrest.Matchers.*;
Se você não vir nenhum erro ou aviso em seu IDE, isso significa que você baixou com sucesso io.restaurado jar e suas dependências e você está pronto para usá-los em seus projetos.
Como usar o jar io.restassured
Agora que você baixou io.restaurado jar e suas dependências, você deve estar se perguntando como usá-los em seus projetos.Nesta seção, daremos a você uma visão geral dos principais recursos e benefícios do io.restaurado jar e mostro alguns exemplos de como escrever casos de teste com ele.
Configurando com garantia REST
A primeira coisa que você precisa fazer antes de usar io.restaurado jar é definir algumas configurações básicas para o teste da API REST. Isso inclui configurar o URI base e a porta de sua API, que são as partes comuns de cada solicitação que você faz. Você pode fazer isso usando os métodos estáticos do Tenha certeza classe, como:
// Defina o URI base de sua API RestAssured.baseURI = " // Defina a porta de sua API RestAssured.port = 8080;
Você também pode definir outras configurações, como autenticação, registro, proxy, etc., usando o RestAssured.config() método. Para mais detalhes, você pode consultar o .
Escrevendo um caso de teste simples com garantia REST
Para escrever um caso de teste simples com garantia REST, você precisa usar a sintaxe dada quando então, que é inspirada em estruturas BDD (desenvolvimento orientado a comportamento), como Cucumber e JBehave. Essa sintaxe permite escrever casos de teste de maneira natural e legível, usando três palavras-chave principais:
dado(): é aqui que você especifica as pré-condições do seu caso de teste, como parâmetros, cabeçalhos, cookies etc., que deseja enviar com sua solicitação.
quando(): é aqui que você especifica a ação do seu caso de teste, como o método HTTP, o endpoint, o corpo etc., que deseja executar com sua solicitação.
então(): é aqui que você especifica o resultado esperado de seu caso de teste, como o código de status, o corpo da resposta, os cabeçalhos, etc., que deseja verificar com sua resposta.
Por exemplo, digamos que você queira escrever um caso de teste simples que verifique se você pode obter uma lista de usuários de sua API. Você pode escrevê-lo da seguinte forma:
// Importar as classes e métodos necessários import io.restassured.RestAssured; import io.restassured.response.Response; importar io.restassured.matcher.RestAssuredMatchers.*; import org.hamcrest.Matchers.*; // Defina o URI base e a porta de sua API RestAssured.baseURI = " RestAssured.port = 8080; // Escreva o caso de teste usando a sintaxe dada quando-então dada() // Especifique as pré-condições .param("page", 1) // Envie um parâmetro de consulta .header("Accept", "application/json") // Envie um cabeçalho .when() // Especifique a ação .get("/users") // Faça uma solicitação GET para /users endpoint .then() // Especifique o resultado esperado .statusCode(200) // Verifique se o código de status é 200 .body("data .size()", Matchers.equalTo(10)) // Verifique se o corpo da resposta contém 10 usuários .body("data[0].name", Matchers.equalTo("John Doe")) // Verifique se o nome do primeiro usuário é John Doe .header("Content-Type", "application/json"); // Verifique se o cabeçalho de resposta contém Content-Type: application/json
Como você pode ver, este caso de teste é muito fácil de ler e entender e abrange todos os aspectos do teste de uma API REST. Você também pode encadear vários então() cláusulas para verificar diferentes aspectos de sua resposta.
Escrevendo um caso de teste mais complexo com garantia REST
Às vezes, pode ser necessário escrever um caso de teste mais complexo que envolva enviar ou receber mais dados, como parâmetros, cabeçalhos, cookies, corpo, etc. Nesse caso, você pode usar o método Especificação do pedido e Especificação da resposta interfaces para criar especificações reutilizáveis que podem ser aplicadas a várias solicitações ou respostas. Você também pode usar o JsonPathGenericName ou XmlPath classes para extrair e validar dados de respostas JSON ou XML.
Por exemplo, digamos que você queira escrever um caso de teste que verifique se você pode criar um novo usuário em sua API. Você pode escrevê-lo da seguinte forma:
// Importar as classes e métodos necessários import io.restassured.RestAssured; import io.restassured.response.Response; import io.restassured.specification.RequestSpecification; import io.restassured.specification.ResponseSpecification; // Defina o URI base e a porta de sua API RestAssured.baseURI = " RestAssured.port = 8080; // Cria uma especificação de solicitação que contém dados comuns para todas as solicitações RequestSpecification requestSpec = Given() .header("Content-Type", "application/json") // Envia um cabeçalho .cookie("session_id", "1234567890") // Envia um cookie .log().all(); // Registra todos os detalhes da solicitação // Cria uma especificação de resposta que contém dados comuns para todas as respostas ResponseSpecification responseSpec = then() .header("Content-Type", "application/json") // Verifique se o cabeçalho da resposta contém Content-Type: application/json .log().all(); // Registre todos os detalhes da resposta // Escreva o caso de teste usando a sintaxe dada quando-então e aplicando as especificações dadas() // Especifique as pré-condições .spec(requestSpec) // Aplique a especificação da solicitação .body("\n" + // Envie um corpo JSON " \"name\": \"Jane Doe\",\n" + " \"email\": \"jane.doe@example.com\",\n" + " \"password\": \"secret\"\n" + " ") .when() // Especifique a ação .post("/users") // Faça uma solicitação POST para /users endpoint .then() // Especifique o resultado esperado .spec(responseSpec) // Aplique a especificação de resposta .statusCode(201) // Verifique se o código de status é 201 .body("id", Matchers.notNull Value()) // Verifique se o corpo da resposta contém um id não nulo .body("name", Matchers.equalTo("Jane Do e")) // Verifique se o corpo da resposta contém o nome Jane Doe .body("email", Matchers.equalTo("jane.doe@example.com")) // Verifique se o corpo da resposta contém o email jane.doe@example.com .body("password", Matchers.nullValue()); // Verifique se oo corpo da resposta não contém a senha // Extraia e valide os dados da resposta usando JsonPath Response response = Given() .spec(requestSpec) .get("/users/id", 1); // Faça uma solicitação GET para /users/1 endpoint JsonPath jsonPath = response.jsonPath(); // Cria um objeto JsonPath a partir da resposta int id = jsonPath.getInt("id"); // Extrai o id da resposta String name = jsonPath.getString("name"); // Extrai o nome da resposta String email = jsonPath.getString("email"); // Extrai o e-mail da resposta assertThat(id, Matchers.equalTo(1)); // Afirma que o id é 1 assertThat(name, Matchers.equalTo("John Doe")); // Afirma que o nome é John Doe assertThat(email, Matchers.equalTo("john.doe@example.com")); // Afirma que o e-mail é john.doe@example.com
Como você pode ver, este caso de teste é mais complexo e envolve enviar e receber mais dados, mas ainda é fácil de ler e entender, graças ao DSL do REST-assured e à sintaxe do JsonPath. Você também pode usar XmlPath para extrair e validar dados de respostas XML.
Escrevendo um caso de teste com validação de esquema JSON
Outro recurso de garantia REST é que ele permite que você valide se uma resposta JSON está em conformidade com um esquema JSON, que é uma maneira de descrever a estrutura e o formato dos dados JSON. Isso pode ser útil quando você deseja verificar se sua API retorna dados consistentes e válidos, sem precisar escrever várias asserções para cada campo. Para usar esse recurso, você precisa adicionar outra dependência em seu pom.xml arquivo:
<dependency> <groupId>io.rest-assured</groupId> <artifactId>json-schema-validator</artifactId> <version>5.3.1</version> </dependency>
Isso fará o download do json-schema-validator módulo, que é um wrapper para o biblioteca. Você também precisa criar um arquivo de esquema JSON que defina a estrutura e o formato esperados de sua resposta JSON. Por exemplo, você pode criar um arquivo chamado user-schema.json que se parece com isso:
"$schema": " "type": "object", "properties": "id": "type": "integer" , "name": "type": "string" , "email": "type": "string", "format": "email" , "required": ["id", "name", "email"]
Este esquema JSON define que a resposta JSON deve ser um objeto com três propriedades: eu ia, nome, e e-mail. O eu ia deve ser um número inteiro, o nome deve ser uma string, e o e-mail deve ser uma string com um formato de e-mail. Todas as três propriedades são necessárias.
Para usar este esquema JSON para validar sua resposta JSON, você precisa usar o matchJsonSchemaInClasspath() ou matchJsonSchema() métodos de REST-assured. Por exemplo, você pode escrever um caso de teste como este:
// Importar as classes e métodos necessários import io.restassured.RestAssured; import io.restassured.response.Response; import static io.restassured.module.jsv.JsonSchemaValidator.*; // Defina o URI base e a porta de sua API RestAssured.baseURI = " RestAssured.port = 8080; // Escreva o caso de teste usando a sintaxe dada quando-então e a validação do esquema JSON dada() // Especifique as pré-condições .param("page", 1) // Envie um parâmetro de consulta .when() // Especifique a ação .get("/users") // Faça uma solicitação GET para /users endpoint .then() // Especifique o resultado esperado .statusCode(200) // Verifique se o código de status é 200 .body(matchesJsonSchemaInClasspath("user-schema. json")); // Verifique se o corpo da resposta corresponde ao esquema JSON no classpath
Este caso de teste verificará se o corpo da resposta corresponde ao esquema JSON armazenado no classpath, que é a pasta onde estão localizados seu código-fonte e recursos. Você também pode usar o matchJsonSchema() para passar um esquema JSON como uma string ou um arquivo.
Escrevendo um caso de teste com validação de esquema JSON
A validação do esquema JSON é um recurso poderoso que pode ajudá-lo a garantir que sua API retorne dados consistentes e válidos. No entanto, nem sempre é suficiente verificar a estrutura e o formato da sua resposta JSON. Às vezes, você também pode querer verificar os valores e a lógica de sua resposta JSON, como se um campo contém um valor específico, se um campo é maior que outro campo, se um campo está presente ou ausente etc. corpo() método de garantia REST para escrever asserções mais específicas usando correspondentes Hamcrest.
Matchers Hamcrest são um conjunto de classes e métodos que permitem escrever asserções expressivas e legíveis para diferentes tipos de dados, como strings, números, coleções, etc. Você pode usá-los com o corpo() para acessar e verificar diferentes partes de sua resposta JSON. Por exemplo, você pode escrever um caso de teste como este:
// Importar as classes e métodos necessários import io.restassured.RestAssured; import io.restassured.response.Response; import static io.restassured.module.jsv.JsonSchemaValidator.*; importar estático org.hamcrest.Matchers.*; // Defina o URI base e a porta de sua API RestAssured.baseURI = " RestAssured.port = 8080; // Escreva o caso de teste usando a sintaxe dada quando-então, validação de esquema JSON e correspondências Hamcrest dadas() // Especifique as pré-condições .param("page", 1) // Envie um parâmetro de consulta .when() // Especifique a ação .get("/users") // Faça uma solicitação GET para /users endpoint .then() // Especifique o resultado esperado .statusCode(200) // Verifique se o código de status é 200 .body(matchesJsonSchemaInClasspath(" user-schema.json")) // Verifique se o corpo da resposta corresponde ao esquema JSON no caminho de classe .body("data[0].id", equalTo(1)) // Verifique se o id do primeiro usuário é 1 .body("data[0].name", equalTo("John Doe")) // Verifique se o nome do primeiro usuário é John Doe .body("data[0].email", equalTo("john.doe@example.com")) // Verifique se o nome do primeiro usuário s email é john.doe@example.com .body("data[0].id", lessThan(10)) // Verifique se o id do primeiro usuário é menor que 10 .body("data[0].name", notNullValue()) // Verifique se o nome do primeiro usuário não é nulo .body("data[0].email", containsString("@")) // Verifique se o email do primeiro usuário contém "@" .body("data.size()", maior ThanOrEqualTo(10)); // Verifique se o corpo da resposta contém pelo menos 10 usuários
Como você pode ver, este caso de teste usa correspondentes Hamcrest para escrever asserções mais específicas para diferentes partes da resposta JSON. Você pode usar qualquer matcher Hamcrest que atenda às suas necessidades, como igual a(), menor que(), notNullValue(), contémString(), Melhor que ou igual a(), etc. Você também pode combinar vários correspondentes usando operadores lógicos, como e(), ou(), não(), etc
Conclusão
Neste artigo, mostramos como baixar io.restaurado jar e como usá-lo em seus projetos. Também mostramos como escrever casos de teste simples e complexos com garantia de REST usando a sintaxe dada quando, validação de esquema JSON e correspondentes Hamcrest. Esperamos que este artigo tenha ajudado você a entender como usar a garantia REST para simplificar e melhorar o teste da API REST.
perguntas frequentes
Aqui estão algumas perguntas frequentes sobre io.restaurado jar e suas respostas:
P: Quais são as vantagens de usar a garantia REST em relação a outras ferramentas?
R: Algumas das vantagens de usar a garantia REST são:
Ele fornece uma DSL (linguagem específica de domínio) que é fácil de ler e escrever.
Ele suporta respostas JSON e XML.
0517a86e26