Primeros pasos con Allure gRPC

Enriquece tus reportes de pruebas de Allure Report con los detalles de las llamadas que tus pruebas realizan a través de gRPC Java.

Esta página describe Allure gRPC 3.0.0 y versiones más nuevas, que requiere Java 17 o más nuevo.

Allure gRPC es compatible con todas las integraciones de Allure basadas en JVM, incluyendo Allure JUnit Jupiter, Allure TestNG, Allure Cucumber-JVM, y más.

Para habilitar la integración en tu proyecto:

1. Asegúrate de tener habilitada la integración de Allure Report para el framework de pruebas que usas.

   Consulta las instrucciones en la documentación de la integración en Frameworks.

2. Agrega la integración de Allure gRPC y las utilidades JSON de Protobuf a las dependencias de tu proyecto.

   Allure gRPC usa protobuf-java-util para mostrar los mensajes como JSON, pero no lo agrega a tu proyecto. Usa la misma versión que la librería protobuf-java que tu proyecto ya usa.

   Maven

   <!-- Define la versión de Allure que deseas usar mediante la propiedad allure.version -->
   <properties>
       <allure.version>VERSION</allure.version>
   </properties>
   
   <!-- Agrega allure-bom a la gestión de dependencias para asegurar que se usen las versiones correctas de todas las dependencias -->
   <dependencyManagement>
       <dependencies>
           <dependency>
               <groupId>io.qameta.allure</groupId>
               <artifactId>allure-bom</artifactId>
               <version>${allure.version}</version>
               <type>pom</type>
               <scope>import</scope>
           </dependency>
       </dependencies>
   </dependencyManagement>
   
   <dependencies>
       <dependency>
           <groupId>io.qameta.allure</groupId>
           <artifactId>allure-grpc</artifactId>
           <scope>test</scope>
       </dependency>
       <dependency>
           <groupId>com.google.protobuf</groupId>
           <artifactId>protobuf-java-util</artifactId>
           <version>PROTOBUF_VERSION</version>
           <scope>test</scope>
       </dependency>
   </dependencies>

   Gradle (Kotlin)

   val allureVersion = "VERSION"
   
   dependencies {
       testImplementation(platform("io.qameta.allure:allure-bom:$allureVersion"))
       testImplementation("io.qameta.allure:allure-grpc")
       testImplementation("com.google.protobuf:protobuf-java-util:PROTOBUF_VERSION")
   }

   Gradle (Groovy)

   def allureVersion = "VERSION"
   
   dependencies {
       testImplementation platform("io.qameta.allure:allure-bom:$allureVersion")
       testImplementation "io.qameta.allure:allure-grpc"
       testImplementation "com.google.protobuf:protobuf-java-util:PROTOBUF_VERSION"
   }

3. Registra una instancia de AllureGrpc como interceptor de cliente, ya sea en el canal o en un stub.

   El ejemplo a continuación muestra el uso de Allure gRPC en una prueba de JUnit Jupiter. Usa el servicio de verificación de salud de gRPC, así que reemplaza la dirección y el stub con los tuyos propios.

   import io.grpc.ManagedChannel;
   import io.grpc.ManagedChannelBuilder;
   import io.grpc.health.v1.HealthCheckRequest;
   import io.grpc.health.v1.HealthCheckResponse;
   import io.grpc.health.v1.HealthGrpc;
   import io.qameta.allure.grpc.AllureGrpc;
   import org.junit.jupiter.api.Test;
   
   import static org.junit.jupiter.api.Assertions.assertEquals;
   
   class TestOrderService {
   
       @Test
       void testServiceIsServing() {
           ManagedChannel channel = ManagedChannelBuilder.forAddress("localhost", 8080)
                   .intercept(new AllureGrpc())
                   .usePlaintext()
                   .build();
           try {
               HealthCheckResponse response = HealthGrpc.newBlockingStub(channel)
                       .check(HealthCheckRequest.newBuilder().setService("shop.Orders").build());
               assertEquals(HealthCheckResponse.ServingStatus.SERVING, response.getStatus());
           } finally {
               channel.shutdownNow();
           }
       }
   }

   Para agregar el interceptor a un solo stub en lugar de al canal, usa withInterceptors():

   HealthGrpc.newBlockingStub(channel).withInterceptors(new AllureGrpc())

   Algunos aspectos del comportamiento de AllureGrpc pueden ser afectados mediante sus métodos de configuración.

4. Ejecuta tus pruebas y genera un reporte de pruebas de la forma en que normalmente lo harías.

Qué muestra el reporte

Allure gRPC agrega un paso para cada llamada gRPC realizada durante una prueba o un fixture, por ejemplo, "Send unary gRPC request to localhost:8080/grpc.health.v1.Health/Check". El nombre del paso contiene el tipo de llamada (unary, client_streaming, server_streaming o bidi_streaming), la dirección del servidor y el nombre completo del método.

El paso contiene un adjunto de intercambio HTTP llamado "gRPC exchange" con:

• los mensajes de solicitud y respuesta, convertidos a JSON (para llamadas de streaming, todos los mensajes del stream, en orden);
• los metadatos de la solicitud, y los encabezados y trailers de la respuesta, incluyendo grpc-status y grpc-message;
• la hora de inicio y fin de la llamada.

Los valores de metadatos repetidos se mantienen en su orden original. Los valores de claves de metadatos binarios (los que terminan en -bin) se muestran codificados en Base64. Por defecto, el valor de metadatos authorization se reemplaza con un marcador de posición.

Por defecto, si una llamada termina con un código de estado gRPC distinto de cero, el paso se marca como fallido. Consulta Estado del paso para cambiar esto.

Una llamada se agrega al reporte cuando termina. Si una llamada de streaming todavía está abierta cuando la prueba termina, su paso no tiene estado ni adjunto, así que asegúrate de que tus pruebas completen o cancelen sus llamadas de streaming.

Las llamadas realizadas mientras no se está ejecutando ninguna prueba o fixture no se agregan al reporte.

En Allure gRPC 2.x, la solicitud y la respuesta se agregan como dos adjuntos separados.