Este titorial é unha introdución ás probas de API mediante Karate Framework. Obtén información sobre a estrutura do Karate Test Script e os pasos para crear o primeiro script de proba:
API é un acrónimo que significa Application Programming Interface. En termos sinxelos, podemos definilo como un intermediario de software que permite a comunicación entre aplicacións.
Necesitamos probas da API porque:
- Os resultados publícanse máis rápido, polo tanto, xa non hai que esperar para ver se a API funciona ben.
- Coa resposta máis rápida, a implantación destas API tamén se fai máis rápida, polo que permite un tempo de resposta rápido.
- Detección precoz de fallos. mesmo antes de crear a IU da aplicación, permítenos mitigar os riscos e corrixir fallos.
- Posible entrega a gran escala nun período máis curto.
Para poder traballar nas probas de API, temos varias ferramentas dispoñibles no mercado como Postman, Mocha e Chai. Estes demostraron bos resultados e un uso eficaz para probar as API, pero estes están moi influenciados polo código. Para poder utilizalos, hai que estar tecnicamente sólido e familiarizado coas linguaxes de programación.
O Karate Framework resolve moi ben este problema das súas ferramentas de software anteriores.
Que é o marco de karate
Karate? Falemos de Karate. É o de Xapón? Que opinas? Pode ser o gran Bruceeste script de proba básica de karate.
Escenario:
Probaremos unha API con este URL.
Ruta: api/users/2
Método: GET
E necesitamos validar , se a solicitude está devolvendo un código de éxito ( 200) ou non.
En termos sinxelos, só imos probar unha API de mostra para ver se se executa ou non con éxito.
Nota: Estamos tomando unha API de mostra que está dispoñible para probar. Podes escoller calquera RUTA ou facer referencia á túa API.
Fai clic aquí para ver a fonte.
#5) Agora o noso seguinte paso sería crear un Ficheiro .feature .
Como se comentou na sección de introdución, o ficheiro .feature é a propiedade que se herdou de Cucumber. Neste ficheiro, escribiremos os escenarios de proba que se deben executar para realizar a proba da API.
- Vai ao cartafol src/test/java do teu proxecto.
- Fai clic co botón dereito sobre el e crea un ficheiro novo: userDetails.feature. A continuación, fai clic no botón Finalizar.
Agora verás o seguinte ficheiro no cartafol src/test/java
A icona de cor verde aseméllase ao ficheiro .función en Pepino que acabamos de crear.
- Unha vez creado o ficheiro, agora escribiremos os nosos escenarios de proba que se comentarán na seguinte sección.
#6) Xa que temos o escenario elisto o ficheiro . función en branco, agora imos comezar co noso primeiro script. Comecemos a codificar
Escriba a seguinte liña de Código no ficheiro userDetails.feature que creamos no paso n.º 5:
Feature: fetching User Details Scenario: testing the get call for User Details Given url '//reqres.in/api/users/2' When method GET Then status 200
Imos tentar entender os compoñentes que están escritos no ficheiro anterior:
- Función: A palabra clave explica o nome da función que estamos a probar.
- Antecedentes: Esta é unha sección opcional que se trata como unha sección de requisitos previos. Isto pódese usar para definir todo o que se necesita para probar a API. Contén HEADER, URL e amp; Opcións PARAM .
- Escenario: Cada ficheiro de funcións que verá terá polo menos unha función (aínda que pode dar múltiples escenarios) . É a descrición do caso de proba.
- Dado: É o paso que se debe executar antes de realizar calquera outro paso de proba. É unha acción obrigatoria a realizar.
- Cando: Especifica a condición que se debe cumprir para realizar o seguinte paso da proba.
- Entón: Indícanos que debe ocorrer no caso de que se cumpra a condición mencionada no Cando .
Nota: todas as palabras clave mencionadas anteriormente son da lingua dos pepinos. Esta é a forma estándar de escribir os guións de proba usando Cucumber.
E algunhas palabras máis usadas no ficheiro de funcións son:
- 200: É o código de estado/resposta que somosesperando (Fai clic aquí para ver a lista de códigos de estado)
- GET: É o método API como POST, PUT, etc.
Esperamos que esta explicación foi fácil de entender para ti. Agora poderás relacionarte co que está escrito exactamente no ficheiro anterior.
Agora necesitamos crear un ficheiro TestRunner.java
Como se explica no anterior sección, Cucumber necesita un ficheiro Runner que sería necesario para executar o ficheiro .feature que contén os escenarios de proba.
- Vaia ao cartafol src/test/java no teu proxecto
- Fai clic co botón dereito sobre el e crea un novo ficheiro Java: TestRunner.java
- Unha vez creado o ficheiro, coloque as seguintes liñas de código debaixo del:
import org.junit.runner.RunWith; import com.intuit.karate.junit4.Karate; @RunWith(Karate.class) public class TestRunner { }- Test Runner é o ficheiro que agora se executará para realizar o escenario desexado que se escribiu no paso #5.
#7) Agora estamos listos cos ficheiros TestRunner.Java e userDeatils.feature. A única tarefa que nos queda é Executar o script.
- Vaia ao ficheiro TestRunner.java e fai clic co botón dereito no ficheiro como se mostra na imaxe de abaixo.
- Escolla Executar como -> Proba de Junit
- Agora, unha vez seleccionado, comezará a observar que o caso de proba xa comezou.
- Agarde a que se execute o script de proba. Unha vez feito, observará algo como o que se mostra na imaxe de abaixo na súa xanela.
- Por último, podemos dicirque creamos con éxito o noso primeiro Guión de proba básico usando o Marco de karate.
#8) Por último, o Karate framework tamén ofrece unha presentación de informe HTML para a execución que se realizou.
- Ir ao cartafol de destino -> seguro-informes-> Aquí verás o teu informe HTML que podes abrir.
** Tamén che suxerimos que abras o mesmo usando Chrome Navegador para un mellor aspecto.
- O seguinte informe HTML amosaraseche representando Escenarios e amp; Proba que se executou para o escenario mencionado:
Conclusión
Neste tutorial, discutimos probas de API, probas diferentes ferramentas dispoñibles no mercado e como o Karate Framework é unha opción mellor en comparación cos seus homólogos.
Seguimos un enfoque paso a paso para crear o noso primeiro guión de proba básico. Comezamos coa creación dun proxecto Maven básico en Eclipse IDE para crear un ficheiro .feature, que contén todo o escenario de proba e un ficheiro Runner para executar o caso de proba mencionado no ficheiro .feature.
Ao final dos múltiples pasos, puidemos ver o informe de execución dos resultados da proba.
Esperamos que este tutorial fose útil para os principiantes para aprender a crear o seu primeiro guión de proba usando o marco de karate. e realizar probas API. Este detallado paso a pasoé un xeito marabilloso de executar e executar varias probas na API.
SEGUINTE>>
Lee desenvolvera isto no seu tempo libre.Aínda que nos gustaría afondar nas interesantes raíces do Karate, de momento, imos falar da Ferramenta de Karate que se desenvolveu de Peter Thomas , unha das grandes ferramentas que chegan ao rescate dos probadores de API.
O marco de karate segue o estilo Cucumber de escribir o programa que segue o enfoque BDD. A sintaxe é fácil de entender para os non programadores. E este cadro é a única ferramenta de proba de API que combinou a automatización de API e as probas de rendemento nunha única ferramenta independente.
Ofrece aos usuarios a posibilidade de executar os casos de proba en paralelo e realizar o JSON & Comprobacións XML.
Con esta información, pódense deducir certos puntos clave para comprender mellor a ferramenta Karate en detalle:
- Karate é un marco de probas BDD. dun TDD.
- Está deseñado para ser sinxelo para os non programadores. Esta función é un cambio de xogo xa que permite un maior uso e acceso por parte de moitas persoas independentemente da súa formación técnica ou capacidade.
- Fai uso do ficheiro de funcións Cucumber e da linguaxe Gherkins para escribir a proba que é moi doado de entender.
Todas estas características convértena nunha das ferramentas de automatización máis favorables dispoñibles na actualidade.
History Of Karate Framework
Creado por ' Peter Thomas en 2017, este software ten como obxectivo facer probasfuncionalidades dispoñibles para todos. Estaba escrito en Java e a maioría da xente esperaba que os seus ficheiros tamén estivesen no mesmo idioma, pero, afortunadamente, non é o caso.
Máis ben, usa ficheiros Gherkins, que é resultado da súa relación co Marco de pepino. O software de automatización é unha extensión de Pepino, polo que herda o uso do ficheiro Gherkins no seu funcionamento. A gran diferenza entre os dous é que Karate non fai uso de Java durante as probas, pero Cucumber si.
Esta é a razón pola que atende aos non programadores xa que a sintaxe de Gherkins é moi lexible e completa. Esta é a razón pola que o karate é o máis axeitado e recomendado para entrar no mundo das probas automatizadas de API.
As seguintes son algunhas das características do marco de probas de karate:
- Fai uso da linguaxe Gherkins fácil de entender.
- Non require coñecementos técnicos de programación como Java.
- Baséase nos estándares populares de Cucumber.
- Fácil de crear un marco.
- As probas paralelas son a función principal que proporciona o propio Karate, polo que non necesitamos depender de Maven, Gradle , etc.
- UI para depurar a proba.
- Chamar a un ficheiro de funcións desde outro ficheiro.
- Ofrece soporte para a proba de controladores de datos que se crea internamente, polo que non hai que depender de marcos externos.
- Reposo nativo integradoInformes. Ademais, pódese integrar co Cucumber para obter mellores informes de interface de usuario e máis claridade.
- Ofrece soporte interno para cambiar a configuración en diferentes ambientes de proba (QA, Stage, Prod, Pre-Prod).
- Compatibilidade sen problemas para a integración CI/CD que pode ser útil.
- Capaz de xestionar varias chamadas HTTP:
- Compatibilidade con Web Socket
- Solicitude SOAP
- HTTP
- Xestión de cookies do navegador
- HTTPS
- Datos de formulario HTML
- Solicitude XML
Comparando Karate vs Rest-Assured
Rest Assured : é unha biblioteca baseada en Java para probar os servizos REST. Usa a linguaxe Java para escribir as liñas de código. Axuda a probar numerosas categorías de solicitudes, o que resulta ademais na verificación de diferentes combinacións de lóxica empresarial.
Karate Framework : unha ferramenta baseada en Pepino/Gherkins, que se usa para probar SOAP & Servizos REST.
A seguinte táboa recolle algunhas diferenzas máis destacadas entre Rest-Assured & Marco de karate:
| S.No | Base | Marco de karate | DESCANSO Seguro |
|---|---|---|---|
| 1 | Idioma | Utiliza unha combinación de pepino e pepinillos | Fai uso da linguaxe Java |
| 2 | Tamaño do código | Normalmente, a liña de o código é menor, xa que segue unha estrutura similar ao pepino | A liña de código é máis xa que implica ouso da linguaxe Java |
| 3 | Requírese coñecementos técnicos | Os non programadores poden escribir facilmente o código Gherkins | Requírese coñecementos técnicos para escribir código Java |
| 4 | Probas guiadas por datos | Cómpre facer uso de TestNG ou equivalente para admitir o mesmo | Pódense usar etiquetas internas para admitir a proba de datos |
| 5 | Proporciona soporte para chamadas SOAP | Si, proporciona | Só está relacionado cunha solicitude REST |
| 6 | Probas paralelas | Si, as probas paralelas son facilmente compatibles coa xeración de informes paralelos tamén | Non en gran medida. Aínda que a xente intentou facelo, a taxa de fracaso é máis que a taxa de éxito |
| 7 | Información | Fornece informes internos, polo que non necesita depender de complementos externos. Incluso podemos integralo co complemento de informes Cucumber para unha mellor interface de usuario. | Debe depender de complementos externos como Junit, TestNG |
| 8 | Compatible con CSV para datos externos | Si, desde Karate 0.9.0 | Non, hai que usar código ou biblioteca Java |
| 9 | Web UI Automation | Si, desde Karate 0.9.5 Web-UI Automation é posible | Non, non é compatible |
| 10 | Sample GET | Given param val1 = ‘name1’
| given().
|
Por tanto, como demostra o diferenzas anteriores, é seguro dicir que o karate é unha das cousas máis fáciles que calquera pode facer.
Ferramentas necesarias para traballar con Karate Framework
Agora, xa que temos o noso coñecemento básico sobre Marco de karate no punto, vexamos os procesos e ferramentas necesarios para configurar o ambiente de karate.
#1) Eclipse
Eclipse é un entorno de desenvolvemento integrado usado no campo da programación informática. Úsase principalmente para programación Java. Como se mencionou anteriormente, Karate está escrito en Java, polo que ten máis sentido que Eclipse sexa o IDE para o software de proba da API. Outra razón é que é unha ferramenta de código aberto, e esta é unha razón bastante forte para optar por esta ferramenta.
Nota: Podemos incluso usar IntelliJ, Visual Studio e outras diferentes. editores dispoñibles no mercado.
#2) Maven
Esta é unha ferramenta de automatización de compilación utilizada principalmente para construír proxectos Java. É unha forma de configurar un ambiente de Karate e escribir o código. Para configurar o teu Eclipse cos requisitos de Maven, podes facer clic aquí para a instalación de Maven.
Mentres traballas en Maven, usa dependencias de Maven que che axudarán a admitir Karate Framework.
O seguinte as dependencias empregaranse con Maven en pom.xml.
com.intuit.karate karate-apache 0.9.5 test com.intuit.karate karate-junit4 0.9.5 test
Nota: É posible que as últimas versiónsestar dispoñible no repositorio de Maven.
#3) Gradle
Gradle é unha alternativa a Maven e pódese usar con igual capacidade. Teñen as súas semellanzas e diferenzas, pero poden usarse igualmente para configurar un entorno para os nosos códigos de karate.
É máis fácil de usar, flexible e recoméndase cando a nosa aplicación ten algúns requisitos de modularización e xestión con unha morea de complementos. O código de configuración de Gradle sería así,
testCompile 'com.intuit.karate:karate-junit4:0.6.0' testCompile 'com.intuit.karate:karate-apache:0.6.0'
Nota: Podes usar MAVEN ou GRADLE.
#4) Configuración do entorno Java no teu sistema
Necesitas configurar o ambiente JDK e JRE para comezar cos scripts de Karate Framework.
Estrutura do script de proba de karate.
Un guión de proba de karate é coñecido pola posesión da extensión ".feature". Esta propiedade é herdada de Pepino. Tamén se permite a organización de ficheiros na convención Java. Podes organizar os teus ficheiros segundo as convencións do paquete Java.
Non obstante, as directrices de Maven indican que o almacenamento dos ficheiros que non sexan Java se faga por separado. Realízanse nunha estrutura src/test/resources . E os ficheiros Java gárdanse en src/main/java .
Pero, segundo os creadores do Karate Framework, cren firmemente que mantemos tanto os ficheiros Java como os que non son Java. lado. Segundo eles, é moito máis fácil mirar para fóraFicheiros *.java e *.feature cando se manteñen xuntos, en lugar de seguir a estrutura estándar de Maven.
Isto pódese facer facilmente modificando o teu pom.xml do seguinte xeito (Para Maven):
src/test/java **/*.java ...
O seguinte é o esquema da estrutura xeral do Karate Framework:
Agora, xa que este Karate Framework está a usar o ficheiro Runner, que tamén é necesario en Cucumber para executar os ficheiros de funcións, polo que a maioría da escritura seguirá os estándares de Cucumber.
Pero, a diferenza de Cucumber, os pasos non requiren unha definición clara en Karate e que , á súa vez, mellora a flexibilidade e a facilidade de operacións. Non necesitamos engadir o pegamento extra que temos que engadir normalmente cando seguimos o marco de Cucumber.
A clase "Runner" chámase na maioría das veces TestRunner.java.
Entón o ficheiro TestRunner.java terá a forma de:
import com.intuit.karate.junit4.Karate; import org.junit.runner.RunWith; @RunWith(Karate.class) public class TestRunner { }E falando do ficheiro .feature , contén todas as probas escenarios que se deben probar para asegurarse de que a API funciona segundo os requisitos esperados.
Un ficheiro *.feature xeral ten un aspecto similar ao que se mostra a continuación:
Feature: fetching User Details Scenario: testing the get call for User Details Given url '//reqres.in/api/users/2' When method GET Then status 200
Creando o primeiro script básico de proba de karate
Esta sección axudarache a comezar a crear o teu primeiro script de proba, que será útil para converter as API en forma de marco de karate.
Antes de escribir os guións básicos das probas de Karate,instale os seguintes requisitos na súa máquina:
- Eclipse IDE
- Maven. Establece a ruta de Maven adecuada.
- JDK & JRE. Establece o camiño axeitado.
Vexamos o enfoque paso a paso:
#1) Crea un novo proxecto MAVEN no Editor de Eclipse
- Abre Eclipse
- Fai clic en Ficheiro. Selecciona un novo proxecto.
- Selecciona o proxecto Maven
- Escolla a localización do espazo de traballo.
- Seleccione o Arquetipo (normalmente escollemos “ Maven-archetype-quickstart 1.1 ” para proxectos de Maven sinxelos).
- Proporcionar o ID do grupo & o ID de artefacto (utilizamos os seguintes valores no noso exemplo).
- ID de grupo : Karate
- ID de artefacto: KarateTestScriptsSample
- Fai clic en Finalizar para completar o configuración.
#2) Unha vez creada, agora poderás ver a seguinte estrutura na xanela do Explorador de proxectos.
#3) Inclúe todas as túas dependencias.
O noso primeiro paso, despois da configuración, imos incluír todas as dependencias que sexan necesarias para a execución. Manteremos toda a etiqueta baixo o POM.xml (supoñendo que xa coñeces o uso de POM.xml).
- Abre POM.xml e copia o seguinte código baixo a etiqueta de dependencia e garda o ficheiro.
com.intuit.karate karate-apache 0.9.5 test com.intuit.karate karate-junit4 0.9.5 test
Fai clic aquí para ver a fonte.
#4) Imos facer unha chuvia de ideas sobre o escenario, en que imos probar