Testes de funções duráveis do Lambda

A AWS fornece SDKs de teste dedicados para funções duráveis que permitem executar e inspecionar execuções localmente e na nuvem. Instale o SDK de teste para a sua linguagem:

TypeScript

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

Para obter a documentação completa e exemplos, consulte SDK de testes de TypeScript no GitHub.

Python

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

Para obter a documentação completa e exemplos, consulte SDK de testes de Python no GitHub.

O SDK de testes fornece dois modos de teste: o teste local, para testes de unidade rápidos, e o teste em nuvem, para testes de integração com funções implantadas.

Teste local

O teste local executa suas funções duráveis no seu ambiente de desenvolvimento sem exigir recursos implantados. O executor de testes executa seu código de função diretamente e captura todas as operações para inspeção.

Use testes locais para testes de unidade, desenvolvimento orientado a testes e pipelines de CI/CD. Os testes são executados localmente, sem latência de rede ou custos adicionais.

Exemplo de teste:

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
          

O executor de teste captura o estado de execução, incluindo o resultado final, os resultados de etapas individuais, as operações de espera, os retornos de chamada e quaisquer erros. É possível inspecionar as operações por nome ou percorrer todas as operações para verificar o comportamento da execução.

Armazenamentos de execução

O SDK de teste usa armazenamentos de execução para manter os dados de execução do teste. Por padrão, os testes usam um armazenamento na memória que é rápido e não requer limpeza. Para depurar ou analisar o histórico de execução, é possível usar um armazenamento do sistema de arquivos que salva as execuções como arquivos JSON.

Armazenamento na memória (padrão):

O armazenamento na memória mantém os dados de execução na memória durante as execuções de teste. Os dados são perdidos quando os testes são concluídos, tornando-os ideais para testes de unidade padrão e pipelines de CI/CD, nos quais não é preciso inspecionar as execuções após a conclusão dos testes.

Armazenamento do sistema de arquivos:

O armazenamento do sistema de arquivos persiste os dados de execução no disco como arquivos JSON. Cada execução é salva em um arquivo separado, facilitando a inspeção do histórico de execução após a conclusão dos testes. Use o armazenamento do sistema de arquivos ao depurar falhas de teste complexas ou ao analisar padrões de execução ao longo do tempo.

Configure o armazenamento usando variáveis de ambiente:

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

# Run tests
pytest tests/
      

Os arquivos de execução são armazenados com nomes higienizados e contêm o estado completo da execução, incluindo operações, pontos de verificação e resultados. O armazenamento do sistema de arquivo criará automaticamente o diretório de armazenamento se ele não existir.

Teste na nuvem

O teste em nuvem invoca funções duráveis implantadas na AWS e recupera seu histórico de execução usando a API do Lambda. Use os testes em nuvem para verificar o comportamento em ambientes de produção com serviços da AWS e configurações reais.

O teste na nuvem exige uma função implantada e credenciais da AWS com permissões para invocar funções e ler o histórico de execução:

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

Exemplo de teste de nuvem:

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"
          

Os testes de nuvem invocam a função real implantada e recuperam o histórico de execução da AWS. Isso permite verificar a integração com outros serviços da AWS, validar as características de performance e testar com dados e configurações semelhantes aos de produção.

O que testar

Teste as funções duráveis verificando os resultados da execução, o comportamento da operação e o tratamento de erros. Concentre-se na correção da lógica de negócios em vez de nos detalhes da implementação.

Verifique os resultados da execução: confira se as funções retornam os valores esperados para determinadas entradas. Teste as execuções com êxito e os casos de erro para garantir que as funções tratem entradas inválidas de forma adequada.

Inspecione a execução da operação: verifique se as etapas, esperas e retornos de chamada são executados conforme o esperado. Verifique os resultados das etapas para garantir que as operações intermediárias produzam valores corretos. Valide se as operações de espera estão configuradas com tempos limite apropriados e se os retornos de chamada foram criados com as configurações corretas.

Tratamento de erros de teste: verifique se as funções falham corretamente com mensagens de erro descritivas quando recebem uma entrada inválida. Teste o comportamento de novas tentativas simulando falhas transitórias e confirmando as novas tentativas adequadas das operações. Verifique se falhas permanentes não acionam novas tentativas desnecessárias.

Valide os fluxos de trabalho: para fluxos de trabalho de várias etapas, verifique se as operações são executadas na ordem correta. Teste a ramificação condicional para garantir que diferentes caminhos de execução funcionem corretamente. Valide operações paralelas executadas simultaneamente e produza os resultados esperados.

Os repositórios de documentação do SDK contêm exemplos abrangentes de padrões de teste, incluindo fluxos de trabalho de várias etapas, cenários de erro, tratamento de tempo limite e padrões de sondagens.

Estratégia de teste

Use testes locais para testes de unidade durante o desenvolvimento e em pipelines de CI/CD. Os testes locais são executados rapidamente, não exigem credenciais da AWS e fornecem feedback imediato sobre alterações no código. Escreva testes locais para verificar a lógica de negócios, o tratamento de erros e o comportamento da operação.

Use testes de nuvem para testes de integração antes da implantação na produção. Os testes de nuvem verificam o comportamento com serviços e configurações reais da AWS, validam as características de performance e testam os fluxos de trabalho de ponta a ponta. Execute testes de nuvem em ambientes de preparação para detectar problemas de integração antes que eles cheguem à produção.

Simule dependências externas em testes locais para isolar a lógica da função e manter os testes rápidos. Use testes de nuvem para verificar a integração real com serviços externos, como bancos de dados, APIs e outros serviços da AWS.

Escreva testes focados que verifiquem um comportamento específico. Use nomes de testes descritivos que expliquem o que está sendo testado. Agrupe os testes relacionados e use acessórios de teste para obter um código de configuração comum. Mantenha os testes simples e evite uma lógica de teste complexa que seja difícil de entender.

Falhas de depuração

Quando os testes falharem, inspecione o resultado da execução para entender o que houve de errado. Verifique o status da execução para ver se a função foi concluída com êxito, falhou ou atingiu o tempo limite. Leia as mensagens de erro para entender a causa da falha.

Inspecione os resultados individuais da operação para descobrir onde o comportamento divergiu das expectativas. Verifique os resultados das etapas para ver quais valores foram produzidos. Verifique a ordem das operações para confirmar as operações executadas na sequência esperada. Conte as operações para garantir que o número certo de etapas, esperas e retornos de chamada tenham sido criados.

Os problemas comuns incluem código não determinístico que produza resultados diferentes nas reproduções, estado compartilhado por meio de variáveis globais que sejam interrompidas durante a reprodução e operações ausentes devido a erros lógicos condicionais. Use depuradores e logs padrão para analisar o código da função e monitorar o fluxo de execução.

Para testes de nuvem, inspecione o histórico de execução no CloudWatch Logs para ver os logs detalhados da operação. Use o rastreamento para acompanhar o fluxo de execução nos serviços e identificar gargalos.