Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Test delle funzioni durevoli di Lambda

AWS fornisce test dedicati SDKs per funzioni durevoli che consentono di eseguire e ispezionare le esecuzioni sia localmente che nel cloud. Installa l'SDK di test per la tua lingua:

TypeScript

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

Per la documentazione completa e gli esempi, consulta l'SDK TypeScript di test su. GitHub

Python

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

Per la documentazione completa e gli esempi, consulta l'SDK per i test di Python su. GitHub

L'SDK di test offre due modalità di test: test locali per test unitari rapidi e test su cloud per test di integrazione rispetto alle funzioni distribuite.

Test locale

I test locali eseguono le funzioni durevoli nel tuo ambiente di sviluppo senza richiedere risorse distribuite. Il test runner esegue direttamente il codice della funzione e acquisisce tutte le operazioni per l'ispezione.

Utilizza i test locali per i test unitari, lo sviluppo basato sui test e le pipeline. CI/CD I test vengono eseguiti localmente senza latenza di rete o costi aggiuntivi.

Test di esempio:

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
          

Il test runner acquisisce lo stato di esecuzione, inclusi il risultato finale, i risultati dei singoli passaggi, le operazioni di attesa, i callback ed eventuali errori. È possibile ispezionare le operazioni per nome o ripetere tutte le operazioni per verificare il comportamento di esecuzione.

Archivi di esecuzione

L'SDK di test utilizza gli archivi di esecuzione per rendere persistenti i dati di esecuzione dei test. Per impostazione predefinita, i test utilizzano un archivio in memoria che è veloce e non richiede alcuna pulizia. Per il debug o l'analisi della cronologia delle esecuzioni, puoi utilizzare un archivio di file system che salva le esecuzioni come file JSON.

Archivio in memoria (predefinito):

L'archivio in memoria mantiene i dati di esecuzione in memoria durante le esecuzioni dei test. I dati vengono persi al termine dei test, il che li rende ideali per i test unitari standard e CI/CD le pipeline in cui non è necessario ispezionare le esecuzioni al termine dei test.

Archivio del file system:

L'archivio del file system memorizza i dati di esecuzione su disco come file JSON. Ogni esecuzione viene salvata in un file separato, semplificando l'ispezione della cronologia di esecuzione dopo il completamento dei test. Utilizza l'archivio del file system per eseguire il debug di test falliti complessi o per analizzare i modelli di esecuzione nel tempo.

Configura lo store utilizzando le variabili di ambiente:

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

# Run tests
pytest tests/
      

I file di esecuzione sono archiviati con nomi anonimi e contengono lo stato di esecuzione completo, comprese le operazioni, i checkpoint e i risultati. L'archivio del filesystem crea automaticamente la directory di archiviazione se non esiste.

Test sul cloud

Il test nel cloud richiama le funzioni durevoli implementate AWS e ne recupera la cronologia di esecuzione utilizzando l'API Lambda. Utilizza i test sul cloud per verificare il comportamento in ambienti simili a quelli di produzione con servizi e configurazioni reali. AWS

Il cloud testing richiede una funzione distribuita e AWS credenziali con autorizzazioni per richiamare funzioni e leggere la cronologia di esecuzione:

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

Esempio di test nel cloud:

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"
          

I test nel cloud richiamano la funzione effettivamente implementata e recuperano la cronologia di esecuzione da. AWS Ciò consente di verificare l'integrazione con altri AWS servizi, convalidare le caratteristiche prestazionali e testare con dati e configurazioni simili a quelli di produzione.

Cosa testare

Testa le funzioni durevoli verificando i risultati di esecuzione, il comportamento operativo e la gestione degli errori. Concentrati sulla correttezza della logica aziendale piuttosto che sui dettagli di implementazione.

Verifica i risultati dell'esecuzione: verifica che le funzioni restituiscano i valori previsti per determinati input. Verifica sia le esecuzioni riuscite che i casi di errore per garantire che le funzioni gestiscano gli input non validi in modo appropriato.

Ispeziona l'esecuzione dell'operazione: verifica che i passaggi, le attese e i callback vengano eseguiti come previsto. Controllate i risultati delle fasi per assicurarvi che le operazioni intermedie producano valori corretti. Verifica che le operazioni di attesa siano configurate con i timeout appropriati e che i callback siano creati con le impostazioni corrette.

Gestione degli errori di test: verifica che le funzioni falliscano correttamente con messaggi di errore descrittivi quando viene fornito un input non valido. Verifica il comportamento dei nuovi tentativi simulando gli errori temporanei e confermando che le operazioni siano ripetute correttamente. Verificate che i guasti permanenti non generino tentativi non necessari.

Convalida i flussi di lavoro: per i flussi di lavoro in più fasi, verifica che le operazioni vengano eseguite nell'ordine corretto. Verifica la ramificazione condizionale per assicurarti che i diversi percorsi di esecuzione funzionino correttamente. Convalida le operazioni parallele, eseguite contemporaneamente e producono i risultati previsti.

Gli archivi di documentazione SDK contengono numerosi esempi di modelli di test, tra cui flussi di lavoro in più fasi, scenari di errore, gestione dei timeout e modelli di polling.

Strategia di test

Utilizza i test locali per i test unitari durante lo sviluppo e nelle CI/CD pipeline. I test locali vengono eseguiti rapidamente, non richiedono AWS credenziali e forniscono un feedback immediato sulle modifiche al codice. Scrivi test locali per verificare la logica aziendale, la gestione degli errori e il comportamento operativo.

Usa i test sul cloud per i test di integrazione prima di passare alla produzione. I test sul cloud verificano il comportamento con AWS servizi e configurazioni reali, convalidano le caratteristiche prestazionali e testano i flussi di lavoro. end-to-end Esegui test sul cloud in ambienti di staging per individuare i problemi di integrazione prima che raggiungano la produzione.

Simula le dipendenze esterne nei test locali per isolare la logica delle funzioni e mantenere veloci i test. Utilizza i test sul cloud per verificare l'effettiva integrazione con servizi esterni come database e altri APIs servizi. AWS

Scrivi test mirati che verifichino un comportamento specifico. Usa nomi di test descrittivi che spieghino cosa viene testato. Raggruppa i test correlati e utilizza i dispositivi di test per il codice di configurazione comune. Mantieni i test semplici ed evita logiche di test complesse e difficili da capire.

Errori di debug

Quando i test falliscono, controlla il risultato dell'esecuzione per capire cosa è andato storto. Controlla lo stato di esecuzione per vedere se la funzione è riuscita, non riuscita o è scaduta. Leggi i messaggi di errore per comprendere la causa dell'errore.

Esamina i risultati delle singole operazioni per scoprire dove il comportamento si discosta dalle aspettative. Controlla i risultati delle fasi per vedere quali valori sono stati prodotti. Verifica l'ordine delle operazioni per confermare le operazioni eseguite nella sequenza prevista. Conta le operazioni per garantire che sia stato creato il giusto numero di passaggi, attese e callback.

I problemi più comuni includono il codice non deterministico che produce risultati diversi durante la riproduzione, lo stato condiviso tramite variabili globali che si interrompe durante la riproduzione e le operazioni mancanti a causa di errori di logica condizionale. Usa i debugger e la registrazione standard per esaminare il codice delle funzioni e tenere traccia del flusso di esecuzione.

Per i test sul cloud, controlla la cronologia di esecuzione in CloudWatch Logs per visualizzare i registri operativi dettagliati. Utilizza il tracciamento per tracciare il flusso di esecuzione tra i servizi e identificare i punti deboli.