Merge pull request #1 from quindcode/feature/abolanos_refactorizacion_mitte

Feature/abolanos refactorizacion mitte

Author: Daniel36x

DocumentacionPruebas.md

@@ -1,100 +1,109 @@
-# Proyecto de Pruebas con Cypress
+# Proyecto de Pruebas con Cypress - Automatización de API Mitte
 
-Este proyecto utiliza Cypress para realizar pruebas en una aplicación web y se conecta a una base de datos Oracle utilizando la biblioteca `oracledb`. También se utiliza `dotenv` para cargar las variables de entorno desde un archivo `.env`, `ajv` para realizar comparativas de esquemas de las respuestas en formato `.json` y los valores obtenidos del consumo API, y `cypress-mochawesome-reporter` para generar reportes de ejecución.
+Este proyecto consiste en la automatización de pruebas para una API encargada de la gestión de entradas, salidas y pagos de un parqueadero. Esta aplicación se comunica directamente con el autorizador de accesos para validar las transacciones.
 
-## Instalación
+## Estructura del Proyecto
 
-1. Clona este repositorio en tu máquina local.
+El proyecto sigue una estructura modular para facilitar el mantenimiento y la escalabilidad:
 
-2. Abre una terminal y navega hasta la carpeta del proyecto.
+- **`cypress/e2e/`**: Contiene los archivos de prueba (`.cy.js`) que definen los escenarios y casos de prueba (bloques `it`).
 
-3. Ejecuta el siguiente comando para instalar todas las dependencias:
+- **`cypress/support//`**: Carpeta principal para la lógica de soporte:
 
-```bash 
-    npm install
-```
+  - **`assertions/`**: Contiene las validaciones personalizadas (Asserts) para verificar respuestas de API y estados de base de datos.
 
-4. Renombra el archivo `.env.template` a `.env` y actualiza las variables de entorno con los valores correspondientes para la conexión a la base de datos Oracle.
+  - **`page_objects//`** (Services): Contiene los objetos que encapsulan las solicitudes de envío a la API (lectura/escritura).
 
-## Ejecución de Pruebas
+  - **`utils/`**: Generadores de datos (Data Generators) y funciones auxiliares para las pruebas.
 
-1. Para abrir Cypress en modo de interfaz de usuario, ejecuta el siguiente comando:
-```bash
-    npx cypress open 
-```
-O alternativamente puedes usar el comando personalizado.
-```bash
-    npm run cy:open
-```
+  - **`constants/`**: Definición de constantes del proyecto, como nombres campos de API y mensajes de error.
+  
+  - **`commands.js`**: Comandos personalizados de Cypress (opcional).
+
+## Instalación
 
-   Esto abrirá la interfaz de usuario de Cypress, donde podrás seleccionar y ejecutar las pruebas manualmente.
+Sigue estos pasos para instalar y configurar el proyecto en tu entorno local:
 
-2. Para ejecutar las pruebas en modo de línea de comandos, ejecuta el siguiente comando:
+1. **Clonar el repositorio** (si aplica) o navegar a la carpeta del proyecto.
+2. **Instalar dependencias**:
+   Asegúrate de tener [Node.js](https://nodejs.org/) instalado y ejecuta el siguiente comando en la raíz del proyecto:
+   ```bash
+   npm install
+   ```
+
+## Ejecución de Pruebas
+
+Puedes ejecutar las pruebas de tres maneras diferentes según tus necesidades:
+
+### 1. Ejecución en el Navegador (Interfaz de Usuario de Cypress)
+Para abrir el test runner de Cypress y ejecutar pruebas de forma interactiva:
 ```bash
-    npm run test
+npm run cy:open
 ```
-   Esto ejecutará las pruebas automáticamente y mostrará el resultado en la terminal.
 
-3. Para ejecutar las pruebas con Allure habilitado:
+### 2. Ejecución por Línea de Comandos (Modo Headless)
+Para ejecutar todas las pruebas en segundo plano desde la terminal:
 ```bash
-    npm npm run test:report
+npm run test
 ```
 
+### 3. Ejecución con Reportes Allure
+Para generar y visualizar los reportes detallados de Allure:
+
+- **Ejecutar pruebas capturando datos para Allure**:
+  ```bash
+  npm run test:allure
+  ```
+- **Generar el reporte de Allure**:
+  ```bash
+  npm run allure:report
+  ```
+- **Abrir el reporte generado**:
+  ```bash
+  npm run allure:open
+  ```
+- **Limpiar reportes anteriores y ejecutar todo el flujo**:
+  ```bash
+  npm run test:report
+  ```
+
 ## Cambio de Variables de Entorno
 
-El archivo `.env` contiene las variables de entorno necesarias para la conexión a la base de datos Oracle. Para cambiar estas variables, sigue estos pasos:
+El proyecto utiliza variables de entorno para gestionar credenciales y conexiones. Debes configurar un archivo `.env` en la raíz del proyecto con la siguiente estructura:
 
-1. Abre el archivo `.env` en un editor de texto.
+```env
+# Configuración de Base de Datos (Oracle)
+DB_USER=tu_usuario
+DB_PASSWORD=tu_contraseña
+DB_CONNECT_STRING=tu_string_de_conexion
 
-2. Actualiza los valores de las variables `DB_USER`, `DB_PASSWORD` y `DB_CONNECT_STRING` con los valores correctos para tu entorno de base de datos.
+# Autenticación Cognito
+COGNITO_USERNAME=tu_usuario_cognito
+COGNITO_PASSWORD=tu_password_cognito
+COGNITO_CLIENT_ID=tu_client_id
 ```
-    DB_USER=usuario
-    DB_PASSWORD=clave
-    DB_CONNECT_STRING=oracleDbHost
-```
-
 
-3. Guarda los cambios en el archivo.
+---
 
-## Reporte de Ejecución
+## Documentación de Pruebas (Escenarios de Automatización)
 
-Después de ejecutar las pruebas, se generará un reporte utilizando la biblioteca `cypress-mochawesome-reporter`. 
-Podrá acceder al reporte de pruebas en la ruta [cypress/reports/html/index.html](cypress/reports/html/index.hml) desde la raíz del proyecto.
+### Gestión de Entradas (`CreateEntryStep.cy.js` y `CreateEntryValidation.cy.js`)
 
-## Recomendación para utilizar ajv para validación de esquemas
+- **Entrada Exitosa**: Valida la entrada exitosa de un vehículo a un parqueadero Mitte con el servicio de Flypass, verificando tanto la respuesta de la API como el registro en la base de datos.
 
-Cuando estamos validando la estructura de las respuestas que se generan a partir del llamado de un API, se deben crear archivos de referencia que indiquen la obligatoriedad de los campos que recibimos, tipos de datos esperados, y estructura de la información, de la siguiente forma:
+- **Entrada Rechazada**: Valida que la entrada sea rechazada cuando la placa no está autorizada.
 
-Imaginemos que al registrar un usuario por medio de un método POST, obtenemos la siguiente estructura:
+- **Validaciones de Contrato**:
+  - Validar que retorne `400 Bad Request` si faltan campos obligatorios como `sessionId`, `localIdentifier`, `actualStart` o `placeId`.
+  - Validar que retorne `400` cuando los campos tienen valores inválidos (Nulos, Vacíos o formatos de fecha incorrectos).
 
-```json
-{
-    "id": 4,
-    "token": "QpwL5tke4Pnpja7X4"
-}
-```
+### Gestión de Salidas (`CreateExitStep.cy.js` y `CreateExitValidation.cy.js`)
 
-Queremos validar la obligatoriedad del cumplimiento de su esquema, donde id, y token, son atributos obligatorios, y cada uno de ellos tienen tipos de datos `integer`, y `string` respectivamente, para lograrlo, debemos definir la estructura de la siguiente manera:
-
-```json
-{
-  "type": "object",
-  "properties": {
-    "id": {
-      "type": "integer"
-    },
-    "token": {
-      "type": "string"
-    }
-  },
-  "required": [
-    "id",
-    "token"
-  ]
-}
-```
+- **Salida Exitosa**: Valida la salida de un vehículo, asegurando que se procese correctamente en el sistema y se refleje en la base de datos.
 
-Allí es donde entra en juego la validación que nos permite realizar la librería `ajv` respecto al tipo de datos y el cumplimiento del contrato (o esquema) de la respuesta obtenida.
+- **Salida Rechazada**: Valida que la salida sea rechazada por placa no autorizada.
 
-Puedes hacer uso de herramientas que nos permitan crear los esquemas de forma automática como por ejemplo: https://www.liquid-technologies.com/online-json-to-schema-converter
+- **Flujo Completo (End-to-End)**: Registra una entrada exitosa y posteriormente una salida exitosa para el mismo vehículo/sesión.
 
+- **Validaciones de Contrato**:
+  - Validar que retorne `400 Bad Request` si faltan campos obligatorios como `sessionId`, `placeId`, `actualStart`, `currency` o `actualEnd`.

README.md

@@ -1,26 +1,23 @@
 const { defineConfig } = require("cypress");
 const oracledb = require("oracledb");
-//const mssql = require('mssql');
 require("dotenv").config();
 const { getTemporaryCredentials } = require('./cypress/support/utils/AWSConnection.js');
 
 
-// Establece la configuración de conexión para el ambiente de base de datos
 const connection = {
   user: process.env.DB_USER,
   password: process.env.DB_PASSWORD,
   connectString: process.env.DB_CONNECT_STRING,
 };
 
 
-// Establece la función para realizar consultas a la base de datos Oracle
 function queryDB(query, values = []) {
   return new Promise((resolve, reject) => {
     oracledb.getConnection(connection, (error, connection) => {
       if (error) {
         reject(error);
       } else {
-        connection.execute(query, values, (error, result) => { 
+        connection.execute(query, values, (error, result) => {
           connection.close(() => {
             if (error) {
               reject(error);
@@ -47,13 +44,11 @@ function queryDB(query, values = []) {
 }
 
 module.exports = defineConfig({
-  // Ajusta el tiempo de espera predeterminado en milisegundos
   defaultCommandTimeout: 5000,
   pageLoadTimeout: 10000,
   e2e: {
-    // Al iniciar la prueba esta será la url base
     baseUrl: "https://cert-providers.flypass.com.co/",
-    env:{
+    env: {
       allure: true,
       allureReuseAfterSpec: true,
     },
@@ -66,7 +61,7 @@ module.exports = defineConfig({
       config.env.COGNITO_CLIENT_ID = process.env.COGNITO_CLIENT_ID;
 
       on("task", {
-        queryDatabase({ query,values }) {
+        queryDatabase({ query, values }) {
           return queryDB(query, values);
         },
         async awsSetTemporaryCredentials() {
@@ -79,7 +74,7 @@ module.exports = defineConfig({
           return credentials;
         }
       });
-       return config;
+      return config;
     },
   },
 });

cypress.config.js

@@ -1,37 +1,37 @@
-import {EntryService} from "../support/page_objects/EntryService";
+import { EntryService } from "../support/page_objects/EntryService";
 import { EntryDataGenerator } from "../support/utils/EntryDataGenerator";
 import { EntryAsserts } from "../support/assertions/EntryAsserts";
 import { DatabaseAsserts } from "../support/assertions/DatabaseAsserts";
- 
 
- describe('Crear entrada a un parqueadero de Mitte', function () {
-     
-     const testCases=[
+
+describe('Crear entrada a un parqueadero de Mitte', function () {
+
+     const testCases = [
           {
-               description: 'Validar la entrada exitosa de un vehículo a un parqueadero mite con el servicio de Flypass',
+               description: 'Validar la entrada exitosa de un vehículo a un parqueadero Mitte con el servicio de Flypass',
                dataToUse: EntryDataGenerator.getAuthorizedEntry(),
-               validator: (response,data)=>{
+               validator: (response, data) => {
                     EntryAsserts.validateSuccessResponse(response);
                     DatabaseAsserts.validateTransactionEntry(data.sessionId)
                }
           },
           {
                description: 'Validar la entrada RECHAZADA por placa no autorizada',
                dataToUse: EntryDataGenerator.getUnauthorizedEntry(),
-               validator: (respone, data)=>{
-                    EntryAsserts.validateUnauthorizedResponse(respone)
-               }  
+               validator: (response, data) => {
+                    EntryAsserts.validateUnauthorizedResponse(response)
+               }
           }
      ]
 
      testCases.forEach((testCase) => {
-          it(testCase.description, function() {
+          it(testCase.description, function () {
                const entryData = testCase.dataToUse;
 
                EntryService.sendEntry(testCase.dataToUse, this.idToken)
-               .then((response)=>{
-                    testCase.validator(response, entryData);
-               })
+                    .then((response) => {
+                         testCase.validator(response, entryData);
+                    })
           });
      });
- });
+});