Saltar al contenido principal

​
Pruebas unitarias de Auth0 Actions

El paquete Actions NPM (@auth0/actions) permite usar TypeScript en proyectos externos, lo que ayuda a los desarrolladores a seguir las prácticas recomendadas y a mejorar sus pruebas unitarias a partir de las definiciones de TypeScript.

​
Cómo funciona

Sigue las pautas de instalación e importación descritas en: Cómo funciona Actions NPM. Para realizar pruebas unitarias de una Action, debes crear mocks de los objetos event y api que recibe la función de tu Action. Puedes crear estos mocks con las definiciones de TypeScript incluidas en auth0/actions, lo que garantiza que tus pruebas reflejen con precisión el entorno de producción. Los frameworks de pruebas como Jest son ideales para gestionar los mocks y probar la funcionalidad. Las pruebas unitarias pueden ejecutarse en un entorno local, en el control de versiones o en un proceso de CI/CD, lo que mejora la garantía general de calidad y las validaciones antes de que los cambios afecten a los Tenants de Auth0.

​
Ejemplos

Los siguientes ejemplos muestran cómo validar una serie de escenarios mediante la simulación de los objetos necesarios.
Los ejemplos usan Jest (https://www.npmjs.com/package/jest), pero se puede usar cualquier biblioteca de pruebas.

​
Configuración

En tu package.json, define las dependencias de desarrollo para contar con la ayuda de IntelliSense al escribir tu Action. 
{
  "name": "actions-js",
  "version": "1.0.0",
  "description": "Actions JS",
  "main": "example.js",
  "scripts": {
    "test": "jest"
  },
  "author": "John Doe",
  "license": "ISC",
  "devDependencies": {
    "@auth0/actions": "^0.7.1",
    "jest": "^29.7.0"
  }
}

​
Control de acceso antes del registro de usuarios y configuración de metadatos del usuario

El siguiente ejemplo de Action comprueba si el correo electrónico del usuario pertenece a un dominio de correo electrónico prohibido y llama a api.access.deny() si coincide. En caso contrario, verifica si se proporcionó el nombre completo mediante campos adicionales de Custom Prompts y, de ser así, lo establece en user_metadata del perfil del usuario; de lo contrario, envía un error de validación a Universal Login. 
/** @import {Event, PreUserRegistrationAPI} from "@auth0/actions/pre-user-registration/v2" */

/**
* Controlador que se llamará durante la ejecución de un flujo de PreUserRegistration.
*
* @param {Event} event - Detalles sobre el contexto y el usuario que está intentando registrarse.
* @param {PreUserRegistrationAPI} api - Interfaz cuyos métodos pueden utilizarse para cambiar el comportamiento del registro.
*/
exports.onExecutePreUserRegistration = async (event, api) => {
  const user = event.user;

  if (user.email?.endsWith('@example.com')) {
    api.access.deny('forbidden', 'Forbidden email domain')
    return;
  }

  const fullName = event.request.body['ulp-fullName'];

  if (fullName === undefined) {
    api.validation.error('invalid_payload', 'Missing full name');
    return;
  }

  api.user.setUserMetadata('full_name', fullName);
}
La prueba unitaria realiza algunas validaciones para maximizar la cobertura del código, simulando los objetos event y api. 
const { onExecutePreUserRegistration } = require('./preUserRegistration');

describe('onExecutePreUserRegistration', () => {
  const mockApi = {
    access: {
      deny: jest.fn(),
    },
    user: {
      setUserMetadata: jest.fn(),
    },
    validation: {
      error: jest.fn(),
    },
  };

  beforeEach(() => {
    jest.resetAllMocks();
  });

  afterEach(() => {
    jest.resetAllMocks();
  });

  it('rechaza el dominio del correo electrónico', async () => {
    const mockEvent = {
      user: {
        email: 'johndoe@example.com',
      }
    };

    await onExecutePreUserRegistration(mockEvent, mockApi);

    expect(mockApi.access.deny).toHaveBeenCalledWith('forbidden', 'Dominio de correo electrónico prohibido');
    expect(mockApi.validation.error).not.toHaveBeenCalled();
    expect(mockApi.user.setUserMetadata).not.toHaveBeenCalled();
  });

  it('permite el dominio del correo electrónico sin nombre completo', async () => {
    const mockEvent = {
      request: {
        body: {},
      },
      user: {
        email: 'johndoe@test.com',
      },
    };

    await onExecutePreUserRegistration(mockEvent, mockApi);

    expect(mockApi.access.deny).not.toHaveBeenCalled();
    expect(mockApi.validation.error).toHaveBeenCalledWith('invalid_payload', 'Falta el nombre completo');
    expect(mockApi.user.setUserMetadata).not.toHaveBeenCalled();
  });

  it('permite el dominio del correo electrónico con nombre completo', async () => {
    const mockEvent = {
      request: {
        body: {
          'ulp-fullName': 'John Doe'
        },
      },
      user: {
        email: 'johndoe@test.com',
      },
    };

    await onExecutePreUserRegistration(mockEvent, mockApi);

    expect(mockApi.access.deny).not.toHaveBeenCalled();
    expect(mockApi.validation.error).not.toHaveBeenCalled();
    expect(mockApi.user.setUserMetadata).toHaveBeenCalledWith('full_name', 'John Doe');
  });
});

​
Proveedor personalizado de correo electrónico y solicitud HTTP

El siguiente ejemplo de Action intenta enviar un mensaje mediante una solicitud HTTP a un servicio externo, gestionando un posible error en la solicitud para descartar la notificación. Usa secretos para la URL del servicio externo y la clave de API de autorización. 
/** @import {Event, CustomEmailProviderAPI} from "@auth0/actions/custom-email-provider/v1" */

/**
* Manejador que se ejecuta al enviar una notificación por correo electrónico
*
* @param {Event} event - Detalles sobre el usuario y el contexto en el que inicia sesión.
* @param {CustomEmailProviderAPI} api - Métodos y utilidades para modificar el comportamiento del envío de una notificación por correo electrónico.
*/
exports.onExecuteCustomEmailProvider = async (event, api) => {
  const notification = event.notification;
  const message = {
    body: notification.html
  };

  try {
    await fetch(event.secrets.URL, {
      method: 'POST',
      headers: {
        'X-API-Key': event.secrets.API_KEY,
      },
      body: JSON.stringify(message),
    });
  } catch (err) {
    api.notification.drop('External service failure');
  }
}
La prueba unitaria realiza algunas validaciones para maximizar la cobertura del código, simulando los objetos event y api, además de la función fetch. 
const { onExecuteCustomEmailProvider } = require('./customEmailProvider');

describe('onExecuteCustomEmailProvider', () => {
  const mockApi = {
    notification: {
      drop: jest.fn(),
    },
  };

  const mockEvent = {
    notification: {
      html: '<h1>Hello world</h1>',
    },
    secrets: {
      URL: 'https://example.com/service',
      API_KEY: 'ApiKeySecret1234.',
    },
    user: {
      email: 'johndoe@example.com',
    },
  };

  beforeEach(() => {
    jest.resetAllMocks();
  });

  afterEach(() => {
    jest.resetAllMocks();
  });

  it('succeeds on external service request', async () => {
    jest.spyOn(global, 'fetch').mockImplementationOnce(() => Promise.resolve({
      ok: true,
      status: 200,
      json: async () => ({ message: 'Success!' }),
    }));

    await onExecuteCustomEmailProvider(mockEvent, mockApi);

    expect(global.fetch).toHaveBeenCalled();
    expect(mockApi.notification.drop).not.toHaveBeenCalled();
  });

  it('fails on external service request', async () => {
    jest.spyOn(global, 'fetch').mockImplementationOnce(() => Promise.reject({
      ok: false,
      status: 500,
      json: async () => ({ error: 'Server Error' }),
    }));

    await onExecuteCustomEmailProvider(mockEvent, mockApi);

    expect(mockApi.notification.drop).toHaveBeenCalledWith('External service failure');
  });
});
Para obtener más información sobre @auth0/actions, visita https://www.npmjs.com/package/@auth0/actions. Para obtener más información sobre cómo escribir Actions, consulta Write Your First Action.