Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menguji fungsi Lambda yang tahan lama
AWS menyediakan pengujian khusus SDKs untuk fungsi tahan lama yang memungkinkan Anda menjalankan dan memeriksa eksekusi baik secara lokal maupun di cloud. Instal SDK pengujian untuk bahasa Anda:
------
#### [ TypeScript ]
```
npm install --save-dev @aws/aws-durable-execution-sdk-js-testing
```
Untuk dokumentasi dan contoh lengkap, lihat [SDK TypeScript pengujian](https://github.com/aws/aws-durable-execution-sdk-js/tree/development/packages/aws-durable-execution-sdk-js-testing) aktif. GitHub
------
#### [ Python ]
```
pip install aws-durable-execution-sdk-python-testing
```
Untuk dokumentasi dan contoh lengkap, lihat [SDK pengujian Python](https://github.com/aws/aws-durable-execution-sdk-python-testing). GitHub
------
SDK pengujian menyediakan dua mode pengujian: pengujian lokal untuk pengujian unit cepat, dan pengujian cloud untuk pengujian integrasi terhadap fungsi yang diterapkan.
## Pengujian lokal
Pengujian lokal menjalankan fungsi tahan lama Anda di lingkungan pengembangan Anda tanpa memerlukan sumber daya yang digunakan. Pelari uji menjalankan kode fungsi Anda secara langsung dan menangkap semua operasi untuk diperiksa.
Gunakan pengujian lokal untuk pengujian unit, pengembangan berbasis tes, dan CI/CD jaringan pipa. Pengujian dijalankan secara lokal tanpa latensi jaringan atau biaya tambahan.
**Contoh tes:**
------
#### [ 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
```
------
Runner pengujian menangkap status eksekusi termasuk hasil akhir, hasil langkah individual, operasi tunggu, panggilan balik, dan kesalahan apa pun. Anda dapat memeriksa operasi berdasarkan nama atau iterasi melalui semua operasi untuk memverifikasi perilaku eksekusi.
### Toko eksekusi
SDK pengujian menggunakan penyimpanan eksekusi untuk mempertahankan data eksekusi pengujian. Secara default, pengujian menggunakan penyimpanan dalam memori yang cepat dan tidak memerlukan pembersihan. Untuk men-debug atau menganalisis riwayat eksekusi, Anda dapat menggunakan penyimpanan sistem file yang menyimpan eksekusi sebagai file JSON.
**Penyimpanan dalam memori (default):**
Penyimpanan dalam memori menyimpan data eksekusi dalam memori selama pengujian dijalankan. Data hilang saat pengujian selesai, sehingga ideal untuk pengujian unit standar dan CI/CD saluran pipa di mana Anda tidak perlu memeriksa eksekusi setelah pengujian selesai.
**Toko sistem file:**
Penyimpanan sistem file mempertahankan data eksekusi ke disk sebagai file JSON. Setiap eksekusi disimpan dalam file terpisah, sehingga mudah untuk memeriksa riwayat eksekusi setelah tes selesai. Gunakan penyimpanan sistem file saat men-debug kegagalan pengujian yang kompleks atau menganalisis pola eksekusi dari waktu ke waktu.
Konfigurasikan toko menggunakan variabel lingkungan:
```
# Use filesystem store
export AWS_DEX_STORE_TYPE=filesystem
export AWS_DEX_STORE_PATH=./test-executions
# Run tests
pytest tests/
```
File eksekusi disimpan dengan nama yang disanitasi dan berisi status eksekusi lengkap termasuk operasi, pos pemeriksaan, dan hasil. Penyimpanan sistem file secara otomatis membuat direktori penyimpanan jika tidak ada.
## Pengujian cloud
Pengujian cloud memanggil fungsi tahan lama yang diterapkan AWS dan mengambil riwayat eksekusi mereka menggunakan Lambda API. Gunakan pengujian cloud untuk memverifikasi perilaku di lingkungan seperti produksi dengan AWS layanan dan konfigurasi nyata.
Pengujian cloud memerlukan fungsi dan AWS kredensil yang diterapkan dengan izin untuk memanggil fungsi dan membaca riwayat eksekusi:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction",
"lambda:GetDurableExecution",
"lambda:GetDurableExecutionHistory"
],
"Resource": "arn:aws:lambda:region:account-id:function:function-name"
}
]
}
```
**Contoh tes 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"
```
------
Pengujian cloud memanggil fungsi yang diterapkan yang sebenarnya dan mengambil riwayat eksekusi dari. AWS Ini memungkinkan Anda memverifikasi integrasi dengan AWS layanan lain, memvalidasi karakteristik kinerja, dan menguji dengan data dan konfigurasi seperti produksi.
## Apa yang harus diuji
Uji fungsi tahan lama dengan memverifikasi hasil eksekusi, perilaku operasi, dan penanganan kesalahan. Fokus pada kebenaran logika bisnis daripada detail implementasi.
**Verifikasi hasil eksekusi:** Periksa apakah fungsi mengembalikan nilai yang diharapkan untuk input yang diberikan. Uji eksekusi yang berhasil dan kasus kesalahan untuk memastikan fungsi menangani input yang tidak valid dengan tepat.
**Periksa eksekusi operasi:** Verifikasi bahwa langkah, menunggu, dan panggilan balik dijalankan seperti yang diharapkan. Periksa hasil langkah untuk memastikan operasi perantara menghasilkan nilai yang benar. Validasi bahwa operasi tunggu dikonfigurasi dengan batas waktu yang sesuai dan callback dibuat dengan pengaturan yang benar.
**Penanganan kesalahan pengujian:** Verifikasi fungsi gagal dengan benar dengan pesan kesalahan deskriptif saat diberikan input yang tidak valid. Uji perilaku coba lagi dengan mensimulasikan kegagalan sementara dan mengonfirmasi operasi coba lagi dengan tepat. Periksa apakah kegagalan permanen tidak memicu percobaan ulang yang tidak perlu.
**Validasi alur kerja:** Untuk alur kerja multi-langkah, verifikasi operasi yang dijalankan dalam urutan yang benar. Uji percabangan bersyarat untuk memastikan jalur eksekusi yang berbeda bekerja dengan benar. Validasi operasi paralel dijalankan secara bersamaan dan menghasilkan hasil yang diharapkan.
Repositori dokumentasi SDK berisi contoh ekstensif pola pengujian termasuk alur kerja multi-langkah, skenario kesalahan, penanganan batas waktu, dan pola polling.
## Strategi pengujian
Gunakan pengujian lokal untuk pengujian unit selama pengembangan dan di CI/CD jaringan pipa. Pengujian lokal berjalan cepat, tidak memerlukan AWS kredensil, dan memberikan umpan balik langsung tentang perubahan kode. Tulis tes lokal untuk memverifikasi logika bisnis, penanganan kesalahan, dan perilaku operasi.
Gunakan pengujian cloud untuk pengujian integrasi sebelum menerapkan ke produksi. Pengujian cloud memverifikasi perilaku dengan AWS layanan dan konfigurasi nyata, memvalidasi karakteristik kinerja, dan menguji end-to-end alur kerja. Jalankan pengujian cloud di lingkungan pementasan untuk menangkap masalah integrasi sebelum mencapai produksi.
Mengolok-olok dependensi eksternal dalam pengujian lokal untuk mengisolasi logika fungsi dan menjaga pengujian tetap cepat. Gunakan pengujian cloud untuk memverifikasi integrasi aktual dengan layanan eksternal seperti database APIs, dan AWS layanan lainnya.
Tulis tes terfokus yang memverifikasi satu perilaku tertentu. Gunakan nama tes deskriptif yang menjelaskan apa yang sedang diuji. Kelompokkan tes terkait bersama-sama dan gunakan perlengkapan uji untuk kode pengaturan umum. Jaga agar tes tetap sederhana dan hindari logika pengujian kompleks yang sulit dipahami.
## Kegagalan debugging
Ketika tes gagal, periksa hasil eksekusi untuk memahami apa yang salah. Periksa status eksekusi untuk melihat apakah fungsi berhasil, gagal, atau habis waktu. Baca pesan kesalahan untuk memahami penyebab kegagalan.
Periksa hasil operasi individu untuk menemukan di mana perilaku menyimpang dari harapan. Periksa hasil langkah untuk melihat nilai apa yang dihasilkan. Verifikasi urutan operasi untuk mengonfirmasi operasi yang dijalankan dalam urutan yang diharapkan. Hitung operasi untuk memastikan jumlah langkah, menunggu, dan panggilan balik yang tepat dibuat.
Masalah umum termasuk kode non-deterministik yang menghasilkan hasil yang berbeda pada pemutaran ulang, status bersama melalui variabel global yang rusak selama pemutaran ulang, dan operasi yang hilang karena kesalahan logika bersyarat. Gunakan debugger standar dan logging untuk melangkah melalui kode fungsi dan melacak alur eksekusi.
Untuk pengujian cloud, periksa riwayat eksekusi di CloudWatch Log untuk melihat log operasi terperinci. Gunakan tracing untuk melacak alur eksekusi di seluruh layanan dan mengidentifikasi kemacetan.