Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Tester les fonctions durables de Lambda

AWS fournit des tests dédiés SDKs pour les fonctions durables qui vous permettent d'exécuter et d'inspecter les exécutions à la fois localement et dans le cloud. Installez le SDK de test pour votre langue :

TypeScript

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

Pour obtenir une documentation complète et des exemples, consultez le SDK de TypeScript test sur GitHub.

Python

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

Pour une documentation complète et des exemples, consultez le SDK de test Python sur GitHub.

Le SDK de test propose deux modes de test : les tests locaux pour les tests unitaires rapides et les tests dans le cloud pour les tests d'intégration sur les fonctions déployées.

Tests locaux

Les tests locaux exécutent vos fonctions durables dans votre environnement de développement sans nécessiter de ressources déployées. Le lanceur de tests exécute directement votre code de fonction et capture toutes les opérations à des fins d'inspection.

Utilisez les tests locaux pour les tests unitaires, le développement piloté par les tests et CI/CD les pipelines. Les tests sont exécutés localement sans latence réseau ni coûts supplémentaires.

Exemple de test :

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
          

Le lanceur de tests capture l'état d'exécution, y compris le résultat final, les résultats des étapes individuelles, les opérations d'attente, les rappels et les éventuelles erreurs. Vous pouvez inspecter les opérations par leur nom ou répéter toutes les opérations pour vérifier le comportement d'exécution.

Magasins d'exécution

Le SDK de test utilise des magasins d'exécution pour conserver les données d'exécution des tests. Par défaut, les tests utilisent un magasin en mémoire qui est rapide et ne nécessite aucun nettoyage. Pour le débogage ou l'analyse de l'historique des exécutions, vous pouvez utiliser un magasin de système de fichiers qui enregistre les exécutions sous forme de fichiers JSON.

Stockage en mémoire (par défaut) :

Le stockage en mémoire conserve les données d'exécution en mémoire pendant les tests. Les données sont perdues à la fin des tests, ce qui les rend idéales pour les tests unitaires standard et les CI/CD pipelines où vous n'avez pas besoin d'inspecter les exécutions une fois les tests terminés.

Stockage du système de fichiers :

Le magasin du système de fichiers conserve les données d'exécution sur le disque sous forme de fichiers JSON. Chaque exécution est enregistrée dans un fichier distinct, ce qui permet de consulter facilement l'historique des exécutions une fois les tests terminés. Utilisez le magasin du système de fichiers pour corriger les échecs de tests complexes ou pour analyser les modèles d'exécution au fil du temps.

Configurez le magasin à l'aide de variables d'environnement :

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

# Run tests
pytest tests/
      

Les fichiers d'exécution sont stockés avec des noms nettoyés et contiennent l'état d'exécution complet, y compris les opérations, les points de contrôle et les résultats. Le magasin du système de fichiers crée automatiquement le répertoire de stockage s'il n'existe pas.

Test cloud

Les tests dans le cloud invoquent les fonctions durables déployées AWS et récupèrent leur historique d'exécution à l'aide de l'API Lambda. Utilisez les tests dans le cloud pour vérifier le comportement dans des environnements de production dotés de AWS services et de configurations réels.

Les tests dans le cloud nécessitent une fonction déployée et des AWS informations d'identification avec les autorisations nécessaires pour appeler des fonctions et lire l'historique d'exécution :

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

Exemple de test dans le 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"
          

Les tests dans le cloud invoquent la fonction réellement déployée et en extraient l'historique d'exécution AWS. Cela vous permet de vérifier l'intégration avec d'autres AWS services, de valider les caractéristiques de performance et de tester avec des données et des configurations similaires à celles de la production.

Que faut-il tester ?

Testez les fonctions durables en vérifiant les résultats d'exécution, le comportement des opérations et la gestion des erreurs. Concentrez-vous sur l'exactitude de la logique métier plutôt que sur les détails de mise en œuvre.

Vérifiez les résultats de l'exécution : vérifiez que les fonctions renvoient les valeurs attendues pour des entrées données. Testez à la fois les exécutions réussies et les cas d'erreur pour vous assurer que les fonctions gèrent correctement les entrées non valides.

Inspectez l'exécution des opérations : vérifiez que les étapes, les attentes et les rappels s'exécutent comme prévu. Vérifiez les résultats des étapes pour vous assurer que les opérations intermédiaires produisent des valeurs correctes. Vérifiez que les opérations d'attente sont configurées avec des délais d'expiration appropriés et que les rappels sont créés avec les paramètres appropriés.

Gestion des erreurs de test : vérifiez que les fonctions échouent correctement avec des messages d'erreur descriptifs en cas d'entrée non valide. Testez le comportement des nouvelles tentatives en simulant des défaillances transitoires et en vérifiant que les opérations recommencent correctement. Vérifiez que les échecs permanents ne déclenchent pas de nouvelles tentatives inutiles.

Valider les flux de travail : pour les flux de travail en plusieurs étapes, vérifiez que les opérations s'exécutent dans le bon ordre. Testez le branchement conditionnel pour vous assurer que les différents chemins d'exécution fonctionnent correctement. Validez les opérations parallèles exécutées simultanément et produisez les résultats attendus.

Les référentiels de documentation du SDK contiennent de nombreux exemples de modèles de test, notamment des flux de travail en plusieurs étapes, des scénarios d'erreur, la gestion des délais d'attente et des modèles de sondage.

Stratégie de test

Utilisez des tests locaux pour les tests unitaires pendant le développement et dans les CI/CD pipelines. Les tests locaux s'exécutent rapidement, ne nécessitent pas AWS d'informations d'identification et fournissent des informations immédiates sur les modifications du code. Rédigez des tests locaux pour vérifier la logique métier, la gestion des erreurs et le comportement des opérations.

Utilisez les tests dans le cloud pour les tests d'intégration avant le déploiement en production. Les tests dans le cloud vérifient le comportement à l'aide de AWS services et de configurations réels, valident les caractéristiques de performance et testent end-to-end les flux de travail. Exécutez des tests cloud dans des environnements de test afin de détecter les problèmes d'intégration avant qu'ils ne soient mis en production.

Simulez les dépendances externes dans les tests locaux pour isoler la logique des fonctions et accélérer les tests. Utilisez des tests dans le cloud pour vérifier l'intégration réelle avec des services externes tels que des bases de données et d'autres AWS services. APIs

Rédigez des tests ciblés qui vérifient un comportement spécifique. Utilisez des noms de test descriptifs qui expliquent ce qui est testé. Regroupez les tests connexes et utilisez des appareils de test pour un code de configuration commun. Simplifiez les tests et évitez les logiques de test complexes difficiles à comprendre.

Défaillances de débogage

Lorsque les tests échouent, inspectez le résultat de l'exécution pour comprendre ce qui s'est mal passé. Vérifiez l'état d'exécution pour voir si la fonction a réussi, a échoué ou a expiré. Lisez les messages d'erreur pour comprendre la cause de l'échec.

Inspectez les résultats de chaque opération pour trouver les domaines dans lesquels le comportement ne correspondait pas aux attentes. Vérifiez les résultats des étapes pour voir quelles valeurs ont été produites. Vérifiez l'ordre des opérations pour confirmer que les opérations sont exécutées dans l'ordre attendu. Comptez les opérations pour vous assurer que le bon nombre d'étapes, d'attentes et de rappels a été créé.

Les problèmes courants incluent le code non déterministe qui produit des résultats différents lors de la réexécution, l'état partagé par le biais de variables globales qui s'interrompent pendant la rediffusion et les opérations manquantes en raison d'erreurs de logique conditionnelle. Utilisez les débogueurs et la journalisation standard pour parcourir le code de fonction et suivre le flux d'exécution.

Pour les tests dans le cloud, consultez l'historique des exécutions dans CloudWatch les journaux pour consulter les journaux d'opérations détaillés. Utilisez le suivi pour suivre le flux d'exécution entre les services et identifier les goulots d'étranglement.