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 End-to-End con Access Token en API REST

13/25
Recursos

¿Cómo se pueden realizar pruebas de rutas protegidas por un access token?

Realizar pruebas de rutas que requieren autenticación es un proceso esencial para garantizar que una aplicación maneje correctamente la seguridad y la privacidad del usuario. En este contexto, los access tokens son fundamentales, ya que actúan como la llave que permite a los usuarios autenticados acceder a recursos protegidos. A continuación, detallamos cómo abordar las pruebas de rutas protegidas utilizando access tokens.

¿Qué es un access token y cómo funciona?

Un access token es un token de acceso que se genera cuando un usuario inicia sesión en una aplicación. Este token es utilizado para validar la sesión y otorgar acceso a ciertas funcionalidades o datos dentro de la aplicación. Funciona de la siguiente manera:

  • Generación: El token se genera al iniciar sesión con credenciales válidas (como email y contraseña).
  • Uso: Se envía en cada solicitud a rutas protegidas a través de los headers, típicamente en el header 'Authorization'.
  • Validación: El sistema verifica la validez del token. Un token inválido resultará en una respuesta de acceso no autorizado (código 401).

¿Cómo realizar pruebas con rutas protegidas?

Para ejecutar pruebas a rutas que requieren un access token, sigue estos pasos:

  1. Generación del access token: Inicia sesión en la aplicación para obtener un access token válido.
  2. Configuración del Request: En cada solicitud a rutas protegidas, incluye el access token en el header de la petición. Usa el formato 'Bearer' seguido del token.
  3. Validación de la respuesta: Verifica que el token permite acceder y devuelve la información correcta del usuario.

Ejemplo de configuración del request en código JavaScript:

const request = require('supertest');
const app = require('./app');

describe('Endpoint protegido', () => {
  let accessToken;

  beforeAll(async () => {
    const loginResponse = await request(app)
      .post('/login')
      .send({
        email: '[email protected]',
        password: 'password123'
      });
    accessToken = loginResponse.body.accessToken;
  });

  it('Debería devolver información del usuario autenticado', async () => {
    const response = await request(app)
      .get('/api/v1/profile/myUser')
      .set('Authorization', `Bearer ${accessToken}`);

    expect(response.status).toBe(200);
    expect(response.body.email).toBe('[email protected]');
  });
});

¿Cuáles son las mejores prácticas al realizar pruebas?

Implementar buenas prácticas es crucial para asegurar que las pruebas sean efectivas y mantenibles:

  • Usar beforeAll para autenticarse: Antes de ejecutar las pruebas, realiza un solo login y reutiliza el access token para todas las pruebas de un conjunto específico.
  • Pruebas por roles: Realiza pruebas con diferentes tipos de usuarios para verificar que se respeten roles y permisos.
  • Reset de estado: Al finalizar las pruebas, utiliza afterAll para limpiar el estado, como volver a poner el access token a null.

¿Cómo manejar pruebas con múltiples roles de usuario?

Cuando se trabaja con aplicaciones que tienen diferentes roles de usuario, como administrador o cliente, es útil estructurar las pruebas para que cada suite pueda manejar un rol diferente. Esto no solo mejora la eficacia de las pruebas, sino que también asegura que las rutas respondan correctamente según los permisos:

  • Distintas suites de pruebas: Para cada tipo de usuario, crea una suite de pruebas separada que maneje un acceso y un comportamiento específico, permitiendo validar que el API gestiona correctamente roles y permisos.
  • Evaluación continua: Usa herramientas como npm run para ejecutar tus pruebas y asegurarte de que el sistema esté en constante revisión.

Implementando estos enfoques, puedes garantizar que las rutas protegidas por tokens de acceso en tu aplicación no solo autenticen correctamente a los usuarios, sino que también mantengan estándares altos de seguridad. Las pruebas bien fundamentadas no solo contribuyen a un código más seguro, sino que también proporcionan una experiencia de usuario más fluida y confiable.

Aportes 5

Preguntas 0

Ordenar por:

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

Comparto mi codigo que estoy armando para las pruebas, usando ES6 import request from "supertest";import express from "express";import dotenv from "dotenv";import createApp from "../src/app.test.mjs"; dotenv.config();describe("test dispatcher", () => {  let \_app = null;  let \_server = null;  let \_api = null;  const port = process.env.PORT;  let \_token = null;  let \_rftoken = null;  let \_authHeaders = {};  /\*    beforeEach(() => {//se ejecutar al inicio de cada prueba         \_app = createApp();        \_server = \_app.listen(port);        \_api = request(\_app);    });    afterEach(() => {//se ejecuta despues de cada una de las pruebas        if (\_server) {          \_server.close();        }    });\*/  beforeAll(() => {    //se ejecutar al inicio de cada prueba    \_app = createApp();    \_server = \_app.listen(port);    \_api = request(\_app);  });  afterAll(() => {    //se ejecuta despues de cada una de las pruebas    if (\_server) {      \_server.close();    }  });   test("POST /GET TOKEN", async () => {    const response = await \_api.post("/api/auth/login").send({      email: "[email protected]",      password: "Test#12345",    });     // console.log(response);    expect(response.status).toBe(200);    expect(response.body).toHaveProperty("token");    expect(response.headers\["content-type"]).toMatch(/json/);    \_token = response.body.token;    \_rftoken = response.body.rftoken;    \_authHeaders = {      Authorization: `Bearer ${\_token}`,    };    // console.log(response.body);  });   describe("POST /GET TOKEN ", () => {    test("test should a 400", async () => {      //Arrange (preparar)      const inputData = {        email: "[email protected]",        password: "Test#123asd45",      };      //Act (ejecutar)      const response = await \_api.post("/api/auth/login").send(inputData);      const body = response.body;      //Assert      // console.log(response.status);      expect(response.status).toBe(400);    });    test("GET /PACKAGES ", async () => {      //Arrange      //Act      const response = await \_api.get("/api/package").set(\_authHeaders);      // console.log(\_authHeaders);       //Assert      // console.log(response);      expect(response.status).toBe(200);      expect(response.headers\["content-type"]).toMatch(/json/);      expect(response.body).toHaveProperty("message");      expect(response.body).toHaveProperty("packages");      const packagesData = response.body.packages;      expect(packagesData).toHaveProperty("count");      expect(packagesData).toHaveProperty("total\_pages");      expect(packagesData).toHaveProperty("current\_page");      expect(packagesData).toHaveProperty("filters");      expect(packagesData).toHaveProperty("packages");      expect(Array.isArray(packagesData.packages)).toBe(true);      if (packagesData.packages.length > 0) {        const pkg = packagesData.packages\[0];        expect(pkg).toHaveProperty("package\_id");        expect(pkg).toHaveProperty("address");        expect(pkg).toHaveProperty("courier\_name");        expect(pkg).toHaveProperty("created\_datetime");        expect(pkg).toHaveProperty("latitude");        expect(pkg).toHaveProperty("longitude");      }      // console.log(response);    });  });});
Esto se ve super :D

Hay que esperar hasta el final de la clase para que haga sentido la prueba, ja
Inicialmente no me parecía tan buena idea pero al final la arreglo

Todo esto se podria automatizar con chatgtp?

Excelente explicacion para como obtener los tokens para la autorizacion de los enpoint. !ahora todo tiene sentido¡