Requisitos

1

Pruebas End-to-End para APIs con Node.js y Express

Introducción: pruebas e2e con Node.js

2

Exploración y Configuración de APIs con Insomnia y Postman

3

Pruebas en Node.js con Jest y Clean Architecture

4

Configuración y uso de Jest para pruebas end-to-end en JavaScript

5

Pruebas End-to-End con Supertest y Node.js

6

Buenas prácticas en pruebas con Jest y manejo de ciclos abiertos

Pruebas a la API de Fake Store

7

Configuración de Entorno de Pruebas para Aplicaciones Node.js con Twen.js

8

Generación de Reporte de Cobertura con Pruebas End to End

9

Pruebas de Integridad de Datos con DTOs y Joy en APIs REST

10

Pruebas End-to-End con Base de Datos en API REST

11

Pruebas de Autenticación en Login con JavaScript

12

Pruebas de Rutas Protegidas con API Key en Node.js

13

Pruebas End-to-End con Access Token en API REST

14

Pruebas Efectivas de Creación de Usuarios en POS con Bases de Datos

Pruebas en Entornos de Desarrollo Avanzados

15

Pruebas End-to-End: Gestión de Datos con Semillas Automatizadas

16

Configuración de Bases de Datos para Pruebas End-to-End con Docker

17

Creación de Sets de Datos Manuales para Pruebas End-to-End

18

Sets de Datos en SQLite: Creación y Gestión Efectiva

19

Uso de Unsook para Migraciones Programáticas en Pruebas

20

Pruebas de API: Creación de Categorías con Roles y Tokens

21

Pruebas End-to-End para API de Productos sin Autenticación

22

Pruebas de Paginación en Endpoints de Productos con Limit y Offset

Mocking y automatización

23

Mocking de Servicios Externos con NodeMailer en Pruebas Tuen

24

Automatización de Pruebas con GitHub Actions en Integración Continua

Próximos pasos

25

Pruebas de APIs punto a punto con Node.js

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Pruebas de Rutas Protegidas con API Key en Node.js

12/25
Recursos

¿Cómo utilizar API keys para pruebas protegidas?

Las pruebas de endpoints con restricciones son comunes al desarrollar APIs. En los casos donde se requiere más que un simple login, es esencial entender cómo enviar API keys en las cabeceras (headers) para obtener autorización. Este artículo explica el proceso para ejecutar dichas pruebas usando herramientas como Insomnia o Postman, y cómo integrarlas en tu flujo de pruebas automatizadas.

¿Qué pasos seguir para realizar solicitudes de prueba?

En primeras instancias, al enviar solicitudes de prueba a un endpoint protegido por un middleware, es común encontrarse con el mensaje de "no autorizado", debido a la falta de un API key adjunto en los headers. Para rectificar esto:

  1. Verificar la necesidad de la API Key: Asegúrate de que la ruta que estás probando exige una API Key. Esto suele estar especificado en el middleware, que controla el acceso a la ruta.

  2. Consultar las variables de entorno: Si la API key se almacena como una variable de entorno, localízala en el archivo de configuración (generalmente .env).

  3. Configurar la solicitud con la API Key: Utiliza herramientas como Insomnia o Postman para enviar la API Key en los headers de la solicitud. Asegúrate de que el valor sea exacto.

Por ejemplo, configurar una API Key desde Insomnia puede lograrse accediendo a los headers y añadiendo el campo API junto al valor correspondiente.

¿Cómo implementar pruebas automatizadas efectivamente?

Una vez dominado el envío manual de API Keys, es momento de automatizar el proceso dentro del código. Aquí hay un ejemplo de cómo hacerlo en un archivo JavaScript de pruebas:

const request = require('supertest');
const app = require('../app'); // Asegúrate de apuntar al archivo correcto
const config = require('../config');

describe('Pruebas para nueva ruta', () => {
  it('debería retornar 401 sin API key', async () => {
    const response = await request(app).get('/nueva-ruta');
    expect(response.statusCode).toBe(401);
  });

  it('debería retornar 401 con API key inválida', async () => {
    const response = await request(app)
      .get('/nueva-ruta')
      .set('API', 'invalid-api-key');
    expect(response.statusCode).toBe(401);
  });

  it('debería retornar 200 con API key válida', async () => {
    const response = await request(app)
      .get('/nueva-ruta')
      .set('API', config.apiKey);
    expect(response.statusCode).toBe(200);
  });
});

¿Qué hemos aprendido sobre la autenticación de API Keys?

Esta lección ha mostrado cómo realizar pruebas a rutas protegidas ajustando los headers para incluir API Keys. Esto no sólo facilita las pruebas manuales, sino que además mejora la automatización de las pruebas a través de herramientas como supertest. Al comprender cómo emplear API Keys adecuadamente, estás en el camino hacia la construcción de APIs seguras y confiables.

Recuerda siempre mantener organizadas tus variables de entorno y automatizar tus pruebas. Estas prácticas asegurarán una mejor gestión de tus proyectos y te prepararán mejor para las futuras lecciones sobre la validación de autenticaciones más avanzadas, como las basadas en JWT. ¡Sigue adelante con tu aprendizaje y sigue explorando las maravillas del desarrollo de APIs robustas y seguras!

Aportes 2

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Fijense que yo utilice esta otra sintaxis y tambien me funciono. El cambio de sintaxis no es significativo, pero solo para que sepan que es otra manera de hacerlotest("/new-route (Authentication Succeed)", async () => {            const response = await api.get("/nueva-ruta").set("api", "79823");            expect(response.status).toBe(200);            expect(response.text).toBe("Hola, soy una nueva ruta");        }); ```js test("/new-route (Authentication Succeed)", async () => { const response = await api.get("/nueva-ruta").set("api", "79823"); expect(response.status).toBe(200); expect(response.text).toBe("Hola, soy una nueva ruta"); }); ```
Bueno, creo que podemos ser más explícitos en el código y yo propongo lo siguiente en app.e2e.js: ```javascript const supertest = require('supertest');const createApp = require('../src/app');const { config } = require('../src/config/config'); describe('Tests for app', () => { let app = null; let server = null; let api = null; beforeAll(() => { app = createApp(); server = app.listen(9000); api = supertest(app); }); describe('GET /hello', () => { test('should return correct info when requesting hello route', async () => { const response = await api.get('/hello'); expect(response).toBeTruthy(); expect(response.statusCode).toEqual(200); expect(response.body.name).toEqual('mike'); expect(response.headers\['content-type']).toMatch(/json/); }); }); describe('GET /nueva-ruta', () => { test('should return status code of 401 without api key', async () => { const { statusCode } = await api.get('/nueva-ruta'); expect(statusCode).toEqual(401); }); test('should return status code of 401 with invalid api key', async () => { const { statusCode } = await api.get('/nueva-ruta').set({ api: 'nope' }); expect(statusCode).toEqual(401); }); test('should return status code of 200 with correct api key', async () => { const { statusCode } = await api .get('/nueva-ruta') .set({ api: config.apiKey }); expect(statusCode).toEqual(200); }); }); afterAll(() => { server.close(); });}); ```