Prueba de funciones duraderas de Lambda

AWS proporciona SDK de prueba específicos para funciones duraderas que le permiten ejecutar e inspeccionar las ejecuciones tanto de forma local como en la nube. Instale el SDK de prueba para su lenguaje:

TypeScript

npm install --save-dev @aws/aws-durable-execution-sdk-js-testing
        

Para ver la documentación completa y los ejemplos, consulte el SDK de prueba para TypeScript en GitHub.

Python

pip install aws-durable-execution-sdk-python-testing
        

Para ver la documentación completa y los ejemplos, consulte el SDK de prueba para Python en GitHub.

El SDK de prueba proporciona dos modos de prueba: pruebas locales para pruebas unitarias rápidas y pruebas en la nube para pruebas de integración con funciones implementadas.

Testeo local

Las pruebas locales ejecutan sus funciones duraderas en su entorno de desarrollo sin requerir recursos implementados. El ejecutor de pruebas ejecuta el código de la función directamente y captura todas las operaciones para su inspección.

Utilice las pruebas locales para las pruebas unitarias, el desarrollo basado en pruebas y las canalizaciones de CI/CD. Las pruebas se ejecutan localmente sin latencia de red ni costos adicionales.

Ejemplo de prueba:

TypeScript

import { withDurableExecution } from '@aws/aws-durable-execution-sdk-js';
import { DurableFunctionTestRunner } from '@aws/aws-durable-execution-sdk-js-testing';

const handler = withDurableExecution(async (event, context) => {
  const result = await context.step('calculate', async () => {
    return event.a + event.b;
  });
  return result;
});

test('addition works correctly', async () => {
  const runner = new DurableFunctionTestRunner({ handler });
  const result = await runner.run({ a: 5, b: 3 });
  
  expect(result.status).toBe('SUCCEEDED');
  expect(result.result).toBe(8);
  
  const step = result.getStep('calculate');
  expect(step.result).toBe(8);
});
          

Python

from aws_durable_execution_sdk_python import durable_execution, DurableContext
from aws_durable_execution_sdk_python_testing import DurableFunctionTestRunner
from aws_durable_execution_sdk_python.execution import InvocationStatus

@durable_execution
def handler(event: dict, context: DurableContext) -> int:
    result = context.step(lambda _: event["a"] + event["b"], name="calculate")
    return result

def test_addition():
    runner = DurableFunctionTestRunner(handler=handler)
    with runner:
        result = runner.run(input={"a": 5, "b": 3}, timeout=10)
    
    assert result.status is InvocationStatus.SUCCEEDED
    assert result.result == 8
    
    step = result.get_step("calculate")
    assert step.result == 8
          

El ejecutor de pruebas captura el estado de ejecución, incluidos el resultado final, los resultados de los pasos individuales, las operaciones de espera, las devoluciones de llamada y cualquier error. Puede inspeccionar las operaciones por su nombre o repetir todas las operaciones en iteraciones para comprobar el comportamiento de la ejecución.

Almacenes de ejecución

El SDK de prueba utiliza almacenes de ejecución para conservar los datos de ejecución de las pruebas. De forma predeterminada, las pruebas utilizan un almacén en la memoria que es rápido y no requiere limpieza. Para depurar o analizar el historial de ejecuciones, puede usar un almacén del sistema de archivos que guarde las ejecuciones como archivos JSON.

Almacén en la memoria (predeterminado):

El almacén en la memoria guarda los datos de ejecución en la memoria durante las pruebas. Los datos se pierden cuando finalizan las pruebas, por lo que resulta ideal para las pruebas unitarias estándar y los procesos de CI/CD, en los que no es necesario inspeccionar las ejecuciones una vez finalizadas las pruebas.

Almacén del sistema de archivos:

El almacén del sistema de archivos conserva los datos de ejecución en el disco como archivos JSON. Cada ejecución se guarda en un archivo por separado, lo que facilita la inspección del historial de ejecuciones una vez finalizadas las pruebas. Utilice el almacén del sistema de archivos para depurar errores de prueba complejos o analizar los patrones de ejecución a lo largo del tiempo.

Configure el almacén mediante variables de entorno:

# Use filesystem store
export AWS_DEX_STORE_TYPE=filesystem
export AWS_DEX_STORE_PATH=./test-executions

# Run tests
pytest tests/
      

Los archivos de ejecución se almacenan con nombres saneados y contienen el estado de ejecución completo, y se incluyen las operaciones, los puntos de control y los resultados. El almacén del sistema de archivos crea automáticamente el directorio de almacenamiento, si no existe.

Prueba en la nube

Las pruebas en la nube invocan funciones duraderas implementadas en AWS y recuperan su historial de ejecución mediante la API de Lambda. Utilice las pruebas en la nube para verificar el comportamiento en entornos similares a los de producción con servicios de AWS y configuraciones reales.

Las pruebas en la nube requieren una función implementada y credenciales de AWS con permisos para invocar funciones y leer el historial de ejecución:

{
    "Version": "2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "lambda:InvokeFunction",
                "lambda:GetDurableExecution",
                "lambda:GetDurableExecutionHistory"
            ],
            "Resource": "arn:aws:lambda:region:account-id:function:function-name"
        }
    ]
}
    

Ejemplo de pruebas en la nube:

TypeScript

import { DurableFunctionCloudTestRunner } from '@aws/aws-durable-execution-sdk-js-testing';

test('deployed function processes orders', async () => {
  const runner = new DurableFunctionCloudTestRunner({
    functionName: 'order-processor',
    region: 'us-east-1'
  });
  
  const result = await runner.run({ orderId: 'order-123' });
  
  expect(result.status).toBe('SUCCEEDED');
  expect(result.result.status).toBe('completed');
});
          

Python

from aws_durable_execution_sdk_python_testing import (
    DurableFunctionCloudTestRunner,
    DurableFunctionCloudTestRunnerConfig
)

def test_deployed_function():
    config = DurableFunctionCloudTestRunnerConfig(
        function_name="order-processor",
        region="us-east-1"
    )
    runner = DurableFunctionCloudTestRunner(config=config)
    
    result = runner.run(input={"orderId": "order-123"})
    
    assert result.status is InvocationStatus.SUCCEEDED
    assert result.result["status"] == "completed"
          

Las pruebas en la nube invocan la función realmente implementada y recuperan el historial de ejecución de AWS. Esto le permite verificar la integración con otros servicios de AWS, validar las características de rendimiento y realizar pruebas con datos y configuraciones similares a los de producción.

Qué se debe probar

Puede probar las funciones duraderas si verifica los resultados de la ejecución, el comportamiento de las operaciones y la gestión de errores. Céntrese en la corrección de la lógica empresarial en lugar de en los detalles de la implementación.

Verifique los resultados de la ejecución: compruebe que las funciones devuelvan los valores esperados para determinadas entradas. Pruebe tanto las ejecuciones satisfactorias como los casos de error para garantizar que las funciones gestionen adecuadamente las entradas inválidas.

Inspeccione la ejecución de la operación: compruebe que los pasos, las esperas y las devoluciones de llamada se ejecuten según lo esperado. Compruebe los resultados de los pasos para asegurarse de que las operaciones intermedias produzcan los valores correctos. Compruebe que las operaciones de espera estén configuradas con los tiempos de espera adecuados y que las devoluciones de llamada se creen con los ajustes correctos.

Pruebe la gestión de errores: compruebe que las funciones fallen correctamente con mensajes de error descriptivos cuando se introduzcan datos inválidos. Pruebe el comportamiento de los reintentos; para ello, simule los errores transitorios y confirme que las operaciones se reintentan correctamente. Compruebe que los errores permanentes no desencadenen reintentos innecesarios.

Valide los flujos de trabajo: para los flujos de trabajo de varios pasos, compruebe que las operaciones se ejecuten en el orden correcto. Pruebe la ramificación condicional para asegurarse de que las diferentes rutas de ejecución funcionen correctamente. Valide que las operaciones paralelas se ejecuten simultáneamente y produzcan los resultados esperados.

Los repositorios de documentación del SDK contienen numerosos ejemplos de patrones de pruebas, incluidos flujos de trabajo de varios pasos, escenarios de error, gestión de los tiempos de espera y patrones de sondeo.

Estrategia de prueba

Utilice las pruebas locales para las pruebas unitarias durante el desarrollo y en las canalizaciones de CI/CD. Las pruebas locales se ejecutan rápidamente, no requieren credenciales de AWS y proporcionan información inmediata sobre los cambios en el código. Escriba pruebas locales para verificar la lógica empresarial, la gestión de errores y el comportamiento de las operaciones.

Utilice las pruebas en la nube para las pruebas de integración antes de implementarlas en producción. Las pruebas en la nube verifican el comportamiento con servicios de AWS y configuraciones reales, validan las características de rendimiento y prueban los flujos de trabajo de extremo a extremo. Realice pruebas en la nube en entornos de ensayo para detectar los problemas de integración antes de que lleguen a producción.

Simule dependencias externas en las pruebas locales para aislar la lógica de las funciones y mantener la rapidez de las pruebas. Utilice las pruebas en la nube para verificar la integración real con servicios externos, como bases de datos, API y otros servicios de AWS.

Escriba pruebas específicas que verifiquen un comportamiento específico. Use nombres de prueba descriptivos que expliquen lo que se evalúa. Agrupe las pruebas relacionadas y utilice dispositivos de prueba para un código de configuración común. Mantenga las pruebas simples y evite la lógica de prueba compleja que sea difícil de entender.

Fallos de depuración

En caso de error en las pruebas, inspeccione el resultado de la ejecución para comprender qué salió mal. Compruebe el estado de la ejecución para ver si la función fue satisfactoria, fallida o se agotó el tiempo de espera. Lea los mensajes de error para comprender la causa del error.

Inspeccione los resultados de cada operación para determinar en qué momento el comportamiento se desvió de las expectativas. Compruebe los resultados de los pasos para ver qué valores se produjeron. Verifique el orden de las operaciones para confirmar que las operaciones se ejecutaron en la secuencia esperada. Cuente las operaciones para garantizar que se haya creado el número correcto de pasos, esperas y devoluciones de llamada.

Los problemas más frecuentes incluyen un código no determinista que produce resultados diferentes en la reproducción, un estado compartido a través de variables globales que se interrumpe durante la reproducción y la falta de operaciones debido a errores de lógica condicional. Utilice depuradores y registros estándar para examinar el código de la función y realizar un seguimiento del flujo de ejecución.

Para las pruebas en la nube, inspeccione el historial de ejecución en Registros de CloudWatch para ver los detalles de los registros de operaciones. Utilice el seguimiento para seguir el flujo de ejecución en todos los servicios e identificar los cuellos de botella.