Testen langlebiger Lambda-Funktionen

AWS bietet spezielle Tests SDKs für langlebige Funktionen, mit denen Sie Ausführungen sowohl lokal als auch in der Cloud ausführen und überprüfen können. Installieren Sie das Test-SDK für Ihre Sprache:

TypeScript

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

Eine vollständige Dokumentation und Beispiele finden Sie im TypeScript Test-SDK unter GitHub.

Python

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

Eine vollständige Dokumentation und Beispiele finden Sie im Python-Test-SDK unter GitHub.

Das Test-SDK bietet zwei Testmodi: lokale Tests für schnelle Komponententests und Cloud-Tests für Integrationstests mit bereitgestellten Funktionen.

Lokale Tests

Beim lokalen Testen werden Ihre dauerhaften Funktionen in Ihrer Entwicklungsumgebung ausgeführt, ohne dass bereitgestellte Ressourcen erforderlich sind. Der Test-Runner führt Ihren Funktionscode direkt aus und erfasst alle Operationen zur Überprüfung.

Verwenden Sie lokale Tests für Komponententests, testgetriebene Entwicklung und CI/CD Pipelines. Tests werden lokal ohne Netzwerklatenz oder zusätzliche Kosten ausgeführt.

Beispieltest:

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
          

Der Test-Runner erfasst den Ausführungsstatus einschließlich des Endergebnisses, der Ergebnisse einzelner Schritte, Warteoperationen, Rückrufe und aller Fehler. Sie können Operationen anhand des Namens überprüfen oder alle Operationen wiederholen, um das Ausführungsverhalten zu überprüfen.

Die Ausführung wird gespeichert

Das Test-SDK verwendet Ausführungsspeicher, um Testausführungsdaten beizubehalten. Standardmäßig verwenden Tests einen In-Memory-Speicher, der schnell ist und keine Bereinigung erfordert. Zum Debuggen oder Analysieren des Ausführungsverlaufs können Sie einen Dateisystemspeicher verwenden, der Ausführungen als JSON-Dateien speichert.

In-Memory-Speicher (Standard):

Der In-Memory-Speicher speichert die Ausführungsdaten während der Testläufe im Speicher. Daten gehen verloren, wenn die Tests abgeschlossen sind, und eignen sich daher ideal für Standard-Komponententests und CI/CD Pipelines, bei denen Sie Ausführungen nach Abschluss der Tests nicht überprüfen müssen.

Dateisystemspeicher:

Der Dateisystemspeicher speichert Ausführungsdaten als JSON-Dateien auf der Festplatte. Jede Ausführung wird in einer separaten Datei gespeichert, sodass der Ausführungsverlauf nach Abschluss der Tests leicht überprüft werden kann. Verwenden Sie den Dateisystemspeicher, um komplexe Testfehler zu debuggen oder Ausführungsmuster im Laufe der Zeit zu analysieren.

Konfigurieren Sie den Speicher mithilfe von Umgebungsvariablen:

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

# Run tests
pytest tests/
      

Ausführungsdateien werden mit bereinigten Namen gespeichert und enthalten den vollständigen Ausführungsstatus, einschließlich Operationen, Prüfpunkten und Ergebnissen. Der Dateisystemspeicher erstellt automatisch das Speicherverzeichnis, falls es nicht existiert.

Testen in der Cloud

Cloud-Tests rufen bereitgestellte dauerhafte Funktionen auf AWS und rufen deren Ausführungsverlauf mithilfe der Lambda-API ab. Verwenden Sie Cloud-Tests, um das Verhalten in produktionsähnlichen Umgebungen mit echten Diensten und Konfigurationen zu überprüfen. AWS

Für Cloud-Tests sind eine bereitgestellte Funktion und AWS Anmeldeinformationen mit Berechtigungen zum Aufrufen von Funktionen und zum Lesen des Ausführungsverlaufs erforderlich:

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

Beispiel für einen Cloud-Test:

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"
          

Cloud-Tests rufen die tatsächlich bereitgestellte Funktion auf und rufen den Ausführungsverlauf von ab AWS. Auf diese Weise können Sie die Integration mit anderen AWS Diensten überprüfen, Leistungsmerkmale validieren und Tests mit produktionsähnlichen Daten und Konfigurationen durchführen.

Was muss getestet werden?

Testen Sie langlebige Funktionen, indem Sie die Ausführungsergebnisse, das Betriebsverhalten und die Fehlerbehandlung überprüfen. Konzentrieren Sie sich eher auf die Richtigkeit der Geschäftslogik als auf Implementierungsdetails.

Überprüfen Sie die Ausführungsergebnisse: Prüfen Sie, ob die Funktionen die erwarteten Werte für die angegebenen Eingaben zurückgeben. Testen Sie sowohl erfolgreiche Ausführungen als auch Fehlerfälle, um sicherzustellen, dass Funktionen ungültige Eingaben angemessen behandeln.

Überprüfen Sie die Ausführung des Vorgangs: Stellen Sie sicher, dass Schritte, Wartezeiten und Callbacks wie erwartet ausgeführt werden. Überprüfen Sie die Schrittergebnisse, um sicherzustellen, dass Zwischenoperationen korrekte Werte ergeben. Stellen Sie sicher, dass Wartevorgänge mit geeigneten Timeouts konfiguriert sind und dass Callbacks mit den richtigen Einstellungen erstellt wurden.

Testen Sie die Fehlerbehandlung: Stellen Sie sicher, dass Funktionen korrekt fehlschlagen, und geben Sie beschreibende Fehlermeldungen ein, wenn eine ungültige Eingabe erfolgt. Testen Sie das Wiederholungsverhalten, indem Sie vorübergehende Ausfälle simulieren und sicherstellen, dass der Vorgang ordnungsgemäß wiederholt wird. Stellen Sie sicher, dass permanente Fehler nicht zu unnötigen Wiederholungen führen.

Workflows validieren: Stellen Sie bei Workflows mit mehreren Schritten sicher, dass die Vorgänge in der richtigen Reihenfolge ausgeführt werden. Testen Sie die bedingte Verzweigung, um sicherzustellen, dass die verschiedenen Ausführungspfade korrekt funktionieren. Überprüfen Sie, ob parallel Operationen gleichzeitig ausgeführt werden und zu erwarteten Ergebnissen führen.

Die SDK-Dokumentationsrepositorien enthalten umfangreiche Beispiele für Testmuster, darunter mehrstufige Workflows, Fehlerszenarien, Timeout-Behandlung und Abfragemuster.

Teststrategie

Verwenden Sie lokale Tests für Komponententests während der Entwicklung und in CI/CD Pipelines. Lokale Tests werden schnell ausgeführt, erfordern keine AWS Anmeldeinformationen und bieten sofortiges Feedback zu Codeänderungen. Schreiben Sie lokale Tests, um Geschäftslogik, Fehlerbehandlung und Betriebsverhalten zu überprüfen.

Verwenden Sie Cloud-Tests für Integrationstests, bevor Sie sie in der Produktion einsetzen. Cloud-Tests verifizieren das Verhalten anhand realer AWS Dienste und Konfigurationen, validieren Leistungsmerkmale und testen end-to-end Workflows. Führen Sie Cloud-Tests in Staging-Umgebungen durch, um Integrationsprobleme zu erkennen, bevor sie in die Produktion gelangen.

Simulieren Sie externe Abhängigkeiten in lokalen Tests, um die Funktionslogik zu isolieren und Tests schnell zu halten. Verwenden Sie Cloud-Tests, um die tatsächliche Integration mit externen Diensten wie Datenbanken und anderen AWS Diensten zu überprüfen. APIs

Schreiben Sie gezielte Tests, die ein bestimmtes Verhalten verifizieren. Verwenden Sie aussagekräftige Testnamen, die erklären, was getestet wird. Gruppieren Sie verwandte Tests und verwenden Sie Testvorrichtungen für den allgemeinen Setup-Code. Halten Sie Tests einfach und vermeiden Sie komplexe Testlogik, die schwer zu verstehen ist.

Fehler beim Debuggen

Wenn Tests fehlschlagen, überprüfen Sie das Ausführungsergebnis, um zu verstehen, was schief gelaufen ist. Überprüfen Sie den Ausführungsstatus, um festzustellen, ob die Funktion erfolgreich war, fehlgeschlagen ist oder ob das Zeitlimit überschritten wurde. Lesen Sie die Fehlermeldungen, um die Fehlerursache zu verstehen.

Untersuchen Sie die einzelnen Betriebsergebnisse, um herauszufinden, wo das Verhalten von den Erwartungen abwich. Überprüfen Sie die Ergebnisse der einzelnen Schritte, um zu sehen, welche Werte erzielt wurden. Überprüfen Sie die Reihenfolge der Operationen, um zu bestätigen, dass die Operationen in der erwarteten Reihenfolge ausgeführt wurden. Zählen Sie die Operationen, um sicherzustellen, dass die richtige Anzahl von Schritten, Wartezeiten und Callbacks erstellt wurde.

Zu den häufigsten Problemen gehören nicht deterministischer Code, der bei der Wiedergabe zu unterschiedlichen Ergebnissen führt, gemeinsamer Status durch globale Variablen, der während der Wiedergabe unterbrochen wird, und fehlende Operationen aufgrund bedingter Logikfehler. Verwenden Sie Standard-Debugger und Protokollierung, um den Funktionscode Schritt für Schritt durchzugehen und den Ausführungsablauf zu verfolgen.

Sehen Sie sich bei Cloud-Tests den Ausführungsverlauf in den CloudWatch Protokollen an, um detaillierte Betriebsprotokolle einzusehen. Verwenden Sie Tracing, um den Ausführungsablauf zwischen Diensten zu verfolgen und Engpässe zu identifizieren.