Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menguji mesin status dengan TestState API
**catatan**
Mulai November 2025, TestState API menyertakan penyempurnaan yang memungkinkan Anda membuat pengujian unit otomatis untuk alur kerja AWS Step Functions Anda. Perangkat tambahan ini tersedia melalui AWS CLI dan. SDKs Penyempurnaan kunci ditambahkan:
Integrasi AWS layanan tiruan atau layanan yang dipanggil melalui status Tugas HTTP untuk menguji logika status tanpa memanggil layanan yang sebenarnya
Uji status lanjutan seperti status Peta, Paralel, dan Aktivitas dengan respons yang diejek
Konteks eksekusi kontrol untuk menguji percobaan ulang tertentu, posisi iterasi peta, dan skenario kesalahan
## Gambaran umum
Anda dapat menguji [status yang didukung](https://docs.aws.amazon.com/step-functions/latest/dg/test-state-isolation.html#supported-test-states) menggunakan TestState fitur di Step Functions konsolAWSCommand Line Interface (AWS CLI), atau SDK.
[TestState](https://docs.aws.amazon.com/step-functions/latest/apireference/API_TestState.html)API menerima definisi status dan menjalankannya. Ini memungkinkan Anda untuk menguji status tanpa membuat mesin negara atau memperbarui mesin status yang ada. Anda dapat memberikan:
+ Definisi negara tunggal
+ Definisi mesin status lengkap dengan `stateName` parameter
`TestState`API mengasumsikan IAM peran yang harus berisi IAM izin yang diperlukan untuk sumber daya yang diakses status Anda. Saat Anda menentukan tiruan, menentukan peran menjadi opsional, memungkinkan Anda menguji logika mesin status tanpa mengonfigurasi IAM izin. Untuk informasi tentang izin yang mungkin diperlukan oleh negara bagian, lihat[IAMizin untuk menggunakan API TestState](#test-state-permissions).
**Topik**
+ [Menggunakan level inspeksi di TestState API](#how-test-state-works)
+ [IAMizin untuk menggunakan API TestState](#test-state-permissions)
+ [Menguji status menggunakan konsol AWS Step Functions](#test-state-console)
+ [Menguji status menggunakan AWS CLI](#test-state-cli)
+ [Menguji dan men-debug aliran data input dan output](#test-state-input-output-dataflow)
+ [Apa yang dapat Anda uji dan tegaskan dengan API TestState](#what-you-can-test-assert)
+ [Integrasi layanan mengejek](#mocking-service-integrations)
+ [Menguji Peta dan status Paralel](#testing-map-parallel-states)
+ [Aktivitas Pengujian, .sync, dan. waitForTaskToken menyatakan](#testing-activity-sync-waitfortasktoken)
+ [Iterasi melalui definisi mesin negara](#iterating-through-state-machine-definitions)
+ [Menggunakan bidang konteks di TestState API](#using-context-field)
+ [Menguji coba lagi dan penanganan kesalahan](#testing-retry-error-handling)
## Menggunakan level inspeksi di TestState API
Saat menguji status menggunakan [TestState](https://docs.aws.amazon.com/step-functions/latest/apireference/API_TestState.html)API, Anda dapat menentukan jumlah detail yang ingin Anda lihat di hasil pengujian. Misalnya, jika Anda telah menggunakan filter pemrosesan data input dan output seperti [`InputPath`](input-output-inputpath-params.md#input-output-inputpath)atau [`ResultPath`](input-output-resultpath.md), Anda dapat melihat hasil pemrosesan data menengah dan akhir. Step Functionsmenyediakan tingkat inspeksi berikut:
+ [INFO](#test-state-info-level)
+ [DEBUG](#test-state-debug-level)
+ [JEJAK](#test-state-trace-level)
Semua level ini juga mengembalikan `status` dan `nextState` bidang. `status`menunjukkan status eksekusi negara. Misalnya,, `SUCCEEDED``FAILED`,`RETRIABLE`, dan`CAUGHT_ERROR`. `nextState`menunjukkan nama negara bagian berikutnya untuk transisi ke. Jika Anda belum menentukan status berikutnya dalam definisi Anda, bidang ini mengembalikan nilai kosong.
Untuk informasi tentang pengujian status menggunakan tingkat inspeksi ini di Step Functions konsol danAWS CLI, lihat [Menguji status menggunakan konsol AWS Step Functions](#test-state-console) dan[Menguji status menggunakan AWS CLI](#test-state-cli).
### INFO InspectionLevel
Jika tes berhasil, level ini menunjukkan output status. Jika tes gagal, level ini menunjukkan output kesalahan. Secara default, Step Functions tetapkan **level Inspeksi** ke **INFO** jika Anda tidak menentukan level.
#### Contoh tes dengan level INFO yang berhasil
Gambar berikut menunjukkan tes untuk status Lulus yang berhasil. **Tingkat Inspeksi** untuk status ini diatur ke **INFO** dan output untuk status muncul di tab **Output**.
#### Contoh pengujian dengan level INFO yang gagal
Gambar berikut menunjukkan pengujian yang gagal untuk status Tugas saat **tingkat Inspeksi** disetel ke **INFO**. Tab **Output** menunjukkan output kesalahan yang mencakup nama kesalahan dan penjelasan rinci tentang penyebab kesalahan itu.
### DEBUG Inspeksi Level
Jika tes berhasil, level ini menunjukkan output status dan hasil pemrosesan data input dan output.
Jika tes gagal, level ini menunjukkan output kesalahan. Tingkat ini menunjukkan hasil pemrosesan data menengah hingga titik kegagalan. Misalnya, katakan bahwa Anda menguji status Tugas yang memanggil Lambda fungsi. Bayangkan Anda telah menerapkan[InputPath](input-output-inputpath-params.md#input-output-inputpath),[Parameter](input-output-inputpath-params.md#input-output-parameters),[Menentukan output status menggunakan Step ResultPath Functions](input-output-resultpath.md), dan [Memfilter output status menggunakan OutputPath](input-output-example.md#input-output-outputpath) filter ke status Tugas. Katakan bahwa doa gagal. Dalam hal ini, `DEBUG` level menunjukkan hasil pemrosesan data berdasarkan penerapan filter dalam urutan sebagai berikut:
+ `input`— Masukan status mentah
+ `afterInputPath`— Masukan setelah Step Functions menerapkan `InputPath` filter.
+ `afterParameters`- Input efektif setelah Step Functions menerapkan `Parameters` filter.
Informasi diagnostik yang tersedia di level ini dapat membantu Anda memecahkan masalah yang terkait dengan [integrasi layanan](integrate-services.md) atau aliran [pemrosesan data input dan output](#test-state-input-output-dataflow) yang mungkin telah Anda tentukan.
#### Contoh pengujian dengan level DEBUG yang berhasil
Gambar berikut menunjukkan tes untuk status Lulus yang berhasil. **Tingkat Inspeksi** untuk status ini diatur ke **DEBUG**. Tab **pemrosesan input/output** pada gambar berikut menunjukkan hasil penerapan [`Parameters`](input-output-inputpath-params.md#input-output-parameters)pada input yang disediakan untuk keadaan ini.
#### Contoh pengujian dengan level DEBUG yang gagal
Gambar berikut menunjukkan pengujian yang gagal untuk status Tugas saat **tingkat Inspeksi** disetel ke **DEBUG**. Tab **pemrosesan input/output** pada gambar berikut menunjukkan hasil pemrosesan data input dan output untuk status hingga titik kegagalannya.
### TRACE Inspection Level
Step Functionsmenyediakan tingkat **TRACE** untuk menguji [Tugas HTTP](call-https-apis.md). Level ini mengembalikan informasi tentang permintaan HTTP yang Step Functions membuat dan merespons yang dikembalikan oleh HTTPS API. Respons mungkin berisi informasi, seperti header dan badan permintaan. Selain itu, Anda dapat melihat output status dan hasil pemrosesan data input dan output di level ini.
Jika tes gagal, level ini menunjukkan output kesalahan.
Level ini hanya berlaku untuk HTTP Task. Step Functionsmelempar kesalahan jika Anda menggunakan level ini untuk tipe status lainnya.
Saat Anda mengatur **level Inspeksi** ke **TRACE**, Anda juga dapat melihat rahasia yang disertakan dalam [EventBridge koneksi](call-https-apis.md#http-task-authentication). Untuk melakukan ini, Anda harus mengatur `revealSecrets` parameter ke `true` dalam [TestState](https://docs.aws.amazon.com/step-functions/latest/apireference/API_TestState.html)API. Selain itu, Anda harus memastikan bahwa IAM pengguna yang memanggil TestState API memiliki izin untuk `states:RevealSecrets` tindakan tersebut. Untuk contoh IAM kebijakan yang menetapkan `states:RevealSecrets` izin, lihat[IAMizin untuk menggunakan API TestState](#test-state-permissions). Tanpa izin ini, Step Functions melempar kesalahan akses ditolak.
Jika Anda mengatur `revealSecrets` parameter ke`false`, Step Functions menghilangkan semua rahasia dalam permintaan HTTP dan data respons. Perhatikan bahwa Anda tidak dapat menggunakan `revealSecrets` saat mengejek diaktifkan. Jika Anda menentukan keduanya `revealSecrets` dan tiruan dalam permintaan TestState API, Step Functions mengembalikan pengecualian validasi.
#### Contoh tes dengan level TRACE yang berhasil
Gambar berikut menunjukkan tes untuk Tugas HTTP yang berhasil. **Tingkat Inspeksi** untuk status ini diatur ke **TRACE**. Tab **permintaan & respons HTTP** pada gambar berikut menunjukkan hasil panggilan HTTPS API.
## IAMizin untuk menggunakan API TestState
IAMPengguna yang memanggil `TestState` API harus memiliki izin untuk melakukan `states:TestState` tindakan. Saat Anda tidak menggunakan ejekan, IAM pengguna juga harus memiliki izin untuk melakukan `iam:PassRole` tindakan untuk meneruskan peran eksekusi. Step Functions Selain itu, jika Anda mengatur `revealSecrets` parameter ke`true`, IAM pengguna harus memiliki izin untuk melakukan `states:RevealSecrets` tindakan. Tanpa izin ini, Step Functions melempar kesalahan akses ditolak.
Perhatikan bahwa saat Anda menentukan tiruan dalam permintaan TestState API, Anda dapat menguji logika mesin status tanpa memberikan peran eksekusi (lihat detail selengkapnya di bawah [Integrasi layanan Mocking](#mocking-service-integrations)). Bila Anda tidak menggunakan tiruan, Anda harus memberikan peran eksekusi yang berisi izin yang diperlukan untuk sumber daya yang diakses negara Anda. Untuk informasi tentang izin yang mungkin diperlukan oleh negara bagian Anda, lihat [Mengelola peran eksekusi](manage-state-machine-permissions.md).
## Menguji status menggunakan konsol AWS Step Functions
Anda dapat menguji status di konsol dan memeriksa output status atau aliran pemrosesan data input dan output. Untuk [Tugas HTTP](call-https-apis.md), Anda dapat menguji permintaan dan respons HTTP mentah.
**catatan**
TestState Fitur konsol belum mendukung beberapa penyempurnaan yang dijelaskan dalam dokumen ini, seperti mengejek integrasi layanan, menguji status Peta dan Paralel, atau Aktivitas, .sync dan. waitForTaskPola token. Kemampuan ini saat ini hanya tersedia melalui TestState API menggunakan AWS CLI atau SDK.
**Untuk menguji suatu negara**
1. Buka [Konsol Step Functions](https://console.aws.amazon.com/states/home?region=us-east-1#/).
1. Pilih **Create state machine** untuk mulai membuat state machine atau pilih state machine yang sudah ada.
1. Di [Mode desain](workflow-studio.md#wfs-interface-design-mode) Workflow Studio, pilih status yang ingin Anda uji.
1. Pilih **status Uji** di [Panel Inspector](workflow-studio.md#workflow-studio-components-formdefinition) Workflow Studio.
1. Dalam kotak dialog **Test state**, lakukan hal berikut:
1. Untuk **peran Eksekusi**, pilih peran eksekusi untuk menguji status. Pastikan Anda memiliki [IAMizin](#test-state-permissions) yang diperlukan untuk status yang ingin Anda uji.
1. (Opsional) Berikan masukan JSON apa pun yang dibutuhkan status yang Anda pilih untuk pengujian.
1. Untuk **tingkat Inspeksi**, pilih salah satu opsi berikut berdasarkan nilai yang ingin Anda lihat:
+ [INFO](#test-state-info-level) - Menampilkan output status di tab **Output** jika tes berhasil. Jika tes gagal, **INFO** menunjukkan output kesalahan, yang mencakup nama kesalahan dan penjelasan rinci tentang penyebab kesalahan itu. Secara default, Step Functions tetapkan **level Inspeksi** ke **INFO** jika Anda tidak memilih level.
+ [DEBUG](#test-state-debug-level) - Menunjukkan output status dan hasil pemrosesan data input dan output jika pengujian berhasil. Jika pengujian gagal, **DEBUG** menunjukkan output kesalahan, yang mencakup nama kesalahan dan penjelasan rinci tentang penyebab kesalahan itu.
+ [TRACE](#test-state-trace-level) - Menampilkan permintaan dan respons HTTP mentah, dan berguna untuk memverifikasi header, parameter kueri, dan detail spesifik API lainnya. Opsi ini hanya tersedia untuk [Tugas HTTP](call-https-apis.md).
Secara opsional, Anda dapat memilih untuk memilih **Mengungkapkan rahasia**. Dalam kombinasi dengan **TRACE**, pengaturan ini memungkinkan Anda melihat data sensitif yang disisipkan EventBridge koneksi, seperti kunci API. Identitas IAM pengguna yang Anda gunakan untuk mengakses konsol harus memiliki izin untuk melakukan `states:RevealSecrets` tindakan. Tanpa izin ini, Step Functions melempar kesalahan akses ditolak saat Anda memulai pengujian. Untuk contoh IAM kebijakan yang menetapkan `states:RevealSecrets` izin, lihat[IAMizin untuk menggunakan API TestState](#test-state-permissions).
1. Pilih **Mulai tes**.
## Menguji status menggunakan AWS CLI
Anda dapat menguji status menggunakan [TestState](https://docs.aws.amazon.com/step-functions/latest/apireference/API_TestState.html)API di fileAWS CLI. API ini menerima definisi status dan menjalankannya.
Untuk setiap status, Anda dapat menentukan jumlah detail yang ingin Anda lihat dalam hasil tes. Rincian ini memberikan informasi tambahan tentang eksekusi negara, termasuk input dan output hasil pengolahan data dan permintaan HTTP dan informasi respon. Contoh berikut menampilkan berbagai level inspeksi yang dapat Anda tentukan untuk TestState API.
Bagian ini berisi contoh-contoh berikut yang menjelaskan bagaimana Anda dapat menggunakan berbagai tingkat inspeksi yang Step Functions disediakan dalamAWS CLI:
+ [Menggunakan INFO InspectionLevel](#test-info-level-cli)
+ [Menggunakan DEBUG InspectionLevel](#test-debug-level-cli)
+ [Menggunakan TRACE InspectionLevel](#test-trace-level-cli)
+ [Menggunakan utilitas jq AWS CLI untuk memfilter dan mencetak respons HTTP yang dikembalikan TestState API](#cli-readable-output)
### Contoh 1: Menggunakan INFO InspectionLevel untuk menguji status Choice
Untuk menguji status menggunakan `INFO` [InspectionLevel](https://docs.aws.amazon.com/step-functions/latest/apireference/API_TestState.html#StepFunctions-TestState-request-inspectionLevel) diAWS CLI, jalankan `test-state` perintah seperti yang ditunjukkan pada contoh berikut.
```
aws stepfunctions test-state \
--definition '{"Type": "Choice", "Choices": [{"Variable": "$.number", "NumericEquals": 1, "Next": "Equals 1"}, {"Variable": "$.number", "NumericEquals": 2, "Next": "Equals 2"}], "Default": "No Match"}' \
--role-arn arn:aws:iam::{{account-id}}:role/{{myRole}} \
--input '{"number": 2}'
```
Contoh ini menggunakan status [Pilihan](state-choice.md) untuk menentukan jalur eksekusi untuk status berdasarkan input numerik yang Anda berikan. Secara default, Step Functions atur `inspectionLevel` ke `INFO` jika Anda tidak menetapkan level.
Step Functionsmengembalikan output berikut.
```
{
"output": "{\"number\": 2}",
"nextState": "Equals 2",
"status": "SUCCEEDED"
}
```
### Contoh 2: Menggunakan DEBUG InspectionLevel untuk men-debug pemrosesan data input dan output dalam status Pass
Untuk menguji status menggunakan `DEBUG` [InspectionLevel](https://docs.aws.amazon.com/step-functions/latest/apireference/API_TestState.html#StepFunctions-TestState-request-inspectionLevel) diAWS CLI, jalankan `test-state` perintah seperti yang ditunjukkan pada contoh berikut.
```
aws stepfunctions test-state \
--definition '{"Type": "Pass", "InputPath": "$.payload", "Parameters": {"data": 1}, "ResultPath": "$.result", "OutputPath": "$.result.data", "Next": "Another State"}' \
--role-arn arn:aws:iam::{{account-id}}:role/{{myRole}} \
--input '{"payload": {"foo": "bar"}}' \
--inspection-level DEBUG
```
Contoh ini menggunakan [Lulus status alur kerja](state-pass.md) status untuk menampilkan bagaimana Step Functions filter dan memanipulasi input data JSON menggunakan input dan output filter pengolahan data. Contoh ini menggunakan filter ini:`InputPath`,`Parameter`,`Menentukan output status menggunakan Step ResultPath Functions`, dan`Memfilter output status menggunakan OutputPath`.
Step Functionsmengembalikan output berikut.
```
{
"output": "1",
"inspectionData": {
"input": "{\"payload\": {\"foo\": \"bar\"}}",
"afterInputPath": "{\"foo\":\"bar\"}",
"afterParameters": "{\"data\":1}",
"afterResultSelector": "{\"data\":1}",
"afterResultPath": "{\"payload\":{\"foo\":\"bar\"},\"result\":{\"data\":1}}"
},
"nextState": "Another State",
"status": "SUCCEEDED"
}
```
### Contoh 3: Menggunakan TRACE InspectionLevel dan RevealSecrets untuk memeriksa permintaan HTTP yang dikirim ke HTTPS API
Untuk menguji [Tugas HTTP](call-https-apis.md) menggunakan `TRACE` [InspectionLevel](https://docs.aws.amazon.com/step-functions/latest/apireference/API_TestState.html#StepFunctions-TestState-request-inspectionLevel) bersama dengan parameter [RevealSecrets](https://docs.aws.amazon.com/step-functions/latest/apireference/API_TestState.html#StepFunctions-TestState-request-revealSecrets) diAWS CLI, jalankan `test-state` perintah seperti yang ditunjukkan pada contoh berikut.
```
aws stepfunctions test-state \
--definition '{"Type": "Task", "Resource": "arn:aws:states:::http:invoke", "Parameters": {"Method": "GET", "Authentication": {"ConnectionArn": "arn:aws:events:{{region}}:{{account-id}}:connection/{{MyConnection/0000000-0000-0000-0000-000000000000"}}}, "ApiEndpoint": "https://httpbin.org/get", "Headers": {"definitionHeader": "h1"}, "RequestBody": {"message": "Hello from Step Functions!"}, "QueryParameters": {"queryParam": "q1"}}, "End": true}' \
--role-arn arn:aws:iam::{{account-id}}:role/{{myRole}} \
--inspection-level TRACE \
--reveal-secrets
```
Contoh ini menguji apakah Tugas HTTP memanggil HTTPS API yang ditentukan,`https://httpbin.org/`. Ini juga menunjukkan permintaan HTTP dan data respons untuk panggilan API.
Step Functionsmengembalikan output mirip dengan contoh asli dalam dokumentasi saat ini.
### Contoh 4: Menggunakan utilitas jq untuk memfilter dan mencetak respons yang dikembalikan TestState API
TestState API mengembalikan data JSON sebagai string yang lolos dalam responsnya. AWS CLIContoh berikut memperluas [Contoh 3](#test-trace-level-cli) dan menggunakan `jq` utilitas untuk memfilter dan mencetak respons HTTP yang dikembalikan TestState API dalam format yang dapat dibaca manusia. Untuk informasi tentang `jq` dan petunjuk pemasangannya, lihat [jq](https://stedolan.github.io/jq/) on *GitHub*.
```
aws stepfunctions test-state \
--definition '{"Type": "Task", "Resource": "arn:aws:states:::http:invoke", "Parameters": {"Method": "GET", "Authentication": {"ConnectionArn": "arn:aws:events:{{region}}:{{account-id}}:connection/{{MyConnection/0000000-0000-0000-0000-000000000000"}}}, "ApiEndpoint": "https://httpbin.org/get", "Headers": {"definitionHeader": "h1"}, "RequestBody": {"message": "Hello from Step Functions!"}, "QueryParameters": {"queryParam": "q1"}}, "End": true}' \
--role-arn arn:aws:iam::{{account-id}}:role/{{myRole}} \
--inspection-level TRACE \
--reveal-secrets \
| jq '.inspectionData.response.body | fromjson'
```
Contoh berikut menunjukkan output yang dikembalikan dalam format yang dapat dibaca manusia.
```
{
"args": {
{{"QueryParam1": "QueryParamValue1",
"queryParam": "q1"}}
},
"headers": {
"Authorization": "Basic XXXXXXXX",
"Content-Type": "application/json; charset=UTF-8",
"Customheader1": "CustomHeaderValue1",
"Definitionheader": "h1",
"Host": "httpbin.org",
"Range": "bytes=0-262144",
"Transfer-Encoding": "chunked",
"User-Agent": "Amazon|StepFunctions|HttpInvoke|{{region}}",
"X-Amzn-Trace-Id": "Root=1-0000000-0000-0000-0000-000000000000"
},
"origin": "{{12.34.567.891}}",
"url": "{{https://httpbin.org/get?queryParam=q1&QueryParam1=QueryParamValue1}}"
}
```
## Menguji dan men-debug aliran data input dan output
`TestState`API berguna untuk menguji dan men-debug data yang mengalir melalui alur kerja Anda. Bagian ini memberikan beberapa konsep kunci dan menjelaskan cara menggunakan TestState untuk tujuan ini.
### Konsep utama
DalamStep Functions, proses penyaringan dan manipulasi data JSON saat melewati status di mesin negara Anda disebut pemrosesan *input dan output*. Untuk informasi tentang cara kerjanya, lihat[Memproses input dan output di Step Functions](concepts-input-output-filtering.md).
Semua jenis [status](workflow-states.md) dalam [Amazon States Language](concepts-amazon-states-language.md) (ASL) (Tugas, Paralel, Peta, Lulus, Tunggu, Pilihan, Sukses, dan Gagal) berbagi satu set bidang umum untuk memfilter dan memanipulasi data JSON yang melewatinya. Bidang-bidang ini adalah: [InputPath](input-output-inputpath-params.md#input-output-inputpath)[Parameter](input-output-inputpath-params.md#input-output-parameters),[ResultSelector](input-output-inputpath-params.md#input-output-resultselector),,[Menentukan output status menggunakan Step ResultPath Functions](input-output-resultpath.md), dan[Memfilter output status menggunakan OutputPath](input-output-example.md#input-output-outputpath). Support untuk setiap bidang [bervariasi di seluruh negara bagian](https://states-language.net/spec.html#state-type-table). Saat runtime, Step Functions terapkan setiap bidang dalam urutan tertentu. Diagram berikut menunjukkan urutan di mana bidang ini diterapkan ke data di dalam status Tugas:
Daftar berikut menjelaskan urutan penerapan bidang pemrosesan input dan output yang ditunjukkan pada diagram.
1. *Input status* adalah data JSON yang diteruskan ke keadaan saat ini dari keadaan sebelumnya.
1. [InputPath](input-output-inputpath-params.md#input-output-inputpath)menyaring sebagian dari input status mentah.
1. [Parameter](input-output-inputpath-params.md#input-output-parameters)mengkonfigurasi set nilai untuk diteruskan ke [Tugas](state-task.md).
1. Tugas melakukan pekerjaan dan mengembalikan hasilnya.
1. [ResultSelector](input-output-inputpath-params.md#input-output-resultselector)memilih satu set nilai untuk menjaga dari hasil tugas.
1. [Menentukan output status menggunakan Step ResultPath Functions](input-output-resultpath.md)menggabungkan hasil dengan input status mentah, atau menggantikan hasilnya dengan itu.
1. [Memfilter output status menggunakan OutputPath](input-output-example.md#input-output-outputpath)menyaring sebagian dari output untuk diteruskan ke keadaan berikutnya.
1. *Output status* adalah data JSON yang diteruskan dari keadaan saat ini ke keadaan berikutnya.
Bidang pemrosesan input dan output ini bersifat opsional. Jika Anda tidak menggunakan salah satu bidang ini dalam definisi status Anda, tugas akan menggunakan input status mentah, dan mengembalikan hasil tugas sebagai output status.
### Menggunakan TestState untuk memeriksa pemrosesan input dan output
Saat Anda memanggil `TestState` API dan menyetel `inspectionLevel` parameternya`DEBUG`, respons API menyertakan objek yang dipanggil`inspectionData`. Objek ini berisi bidang untuk membantu Anda memeriksa bagaimana data disaring atau dimanipulasi dalam status saat dijalankan. Contoh berikut menunjukkan `inspectionData` objek untuk status Tugas.
```
"inspectionData": {
"input": string,
"afterInputPath": string,
"afterParameters": string,
"result": string,
"afterResultSelector": string,
"afterResultPath": string,
"output": string
}
```
Dalam contoh ini, setiap bidang yang berisi `after` awalan, menunjukkan data setelah bidang tertentu diterapkan. Misalnya, `afterInputPath` menunjukkan efek penerapan `InputPath` bidang untuk memfilter input status mentah. Diagram berikut memetakan setiap bidang [definisi ASL](concepts-amazon-states-language.md) ke bidang yang sesuai dalam `inspectionData` objek:
Untuk contoh penggunaan TestState API untuk men-debug pemrosesan input dan output, lihat berikut ini:
+ [Menguji status menggunakan tingkat inspeksi DEBUG di konsol Step Functions](#test-state-debug-level)
+ [Menguji status menggunakan tingkat inspeksi DEBUG di AWS CLI](#test-debug-level-cli)
Untuk status Peta secara khusus, saat `inspectionLevel` disetel ke`DEBUG`, `inspectionData` objek menyertakan bidang tambahan yang membantu Anda memeriksa bagaimana status Peta mengekstrak dan mengubah item. Anda dapat mempelajari lebih lanjut bidang ini di bawah [Memahami bagian data pemeriksaan status Peta](#understanding-map-inspection-data).
### Memahami data pemeriksaan keadaan Peta
Saat Anda menguji status Peta dengan `inspectionLevel` disetel ke`DEBUG`, respons TestState API menyertakan bidang tambahan dalam `inspectionData` objek yang menunjukkan cara status Peta memproses data:
**catatan**
`afterItemsPath`hanya diisi saat menggunakan JSONPath sebagai bahasa kueri.
+ `afterItemsPath`(String) — Input efektif setelah ItemsPath filter diterapkan. Ini menunjukkan array item yang diekstrak dari input Anda.
+ `afterItemsPointer`(String) — Input efektif setelah ItemsPointer filter diterapkan. Ini hanya berlaku untuk input JSON (tidak JSONata).
+ `afterItemSelector`(Array of Strings) - Sebuah array yang berisi nilai masukan setelah ItemSelector transformasi diterapkan. Setiap elemen dalam array mewakili satu item yang diubah. Bidang ini hanya ada saat menguji status Peta.
+ `afterItemBatcher`(Array of Strings) - Sebuah array yang berisi nilai masukan setelah ItemBatcher pengelompokan diterapkan. Ini menunjukkan bagaimana item dikelompokkan ke dalam batch. Bidang ini hanya ada saat menguji status Peta.
+ `toleratedFailureCount`(Angka) — Ambang batas kegagalan yang ditoleransi untuk status Peta dinyatakan sebagai hitungan iterasi status Peta. Nilai ini berasal dari nilai yang ditentukan dalam ToleratedFailureCount atau nilai yang dievaluasi saat runtime dari. ToleratedFailureCountPath
+ `toleratedFailurePercentage`(Angka) — Ambang batas kegagalan yang ditoleransi untuk status Peta dinyatakan sebagai persentase iterasi status Peta. Nilai ini berasal dari nilai yang ditentukan dalam ToleratedFailurePercentage atau nilai yang dievaluasi saat runtime dari. ToleratedFailurePercentagePath
+ `maxConcurrency`(Angka) — Pengaturan konkurensi maksimum dari status Peta.
Bidang ini memungkinkan Anda memvalidasi bahwa transformasi data status Peta dan konfigurasi toleransi kegagalan berfungsi dengan benar sebelum penerapan.
## Apa yang dapat Anda uji dan tegaskan dengan API TestState
TestState API memungkinkan Anda untuk menulis pengujian unit komprehensif untuk mesin status Anda. Anda dapat menegaskan beberapa aspek logika mesin status Anda, termasuk yang berikut ini:
+ [Penanganan kesalahan: Tangkap atau Coba Ulang mana yang berlaku](#error-handling-catch-retry)
+ [Transformasi data: Pemrosesan input dan output](#data-transformations-assert)
+ [Transformasi status peta: ItemSelector,, ItemsPath, ItemBatcher ItemsPointer](#map-state-transformations-assert)
+ [Memetakan ambang kegagalan status: Status Pengujian. ExceedToleratedFailureThreshold](#map-failure-thresholds-assert)
+ [Propagasi kesalahan di Peta dan status Paralel](#error-propagation-assert)
### Penanganan kesalahan: Tangkap atau Coba Ulang mana yang berlaku
Saat Anda mengolok-olok kesalahan, Anda dapat menggunakan TestState API untuk melihat penangan kesalahan mana yang diaktifkan.
Untuk blok Catch, Anda dapat menegaskan:
+ Penangan Catch mana yang menangkap kesalahan (melalui `catchIndex` respons)
+ Apa keadaan selanjutnya (melalui `nextState` dalam tanggapan)
+ Data apa yang mengalir ke penangan kesalahan (melalui `output` dalam respons, mempertimbangkan ResultPath)
Untuk blok Coba lagi, Anda dapat menegaskan:
+ Coba Ulang mana yang berlaku (melalui `retryIndex` dalam tanggapan)
+ Berapa durasi backoff (melalui `retryBackoffIntervalSeconds` dalam respons)
+ Apakah percobaan ulang habis dan kesalahan tertangkap
### Transformasi data: Pemrosesan input dan output
Menggunakan TestState API, Anda dapat memvalidasi bagaimana data status Anda diubah pada setiap tahap pemrosesan.
Anda dapat menegaskan:
+ Masukan setelah InputPath filter (`afterInputPath`)
+ Data setelah Parameters/Arguments transformasi (`afterParameters`atau`afterArguments`)
+ Hasil setelah ResultSelector (`afterResultSelector`)
+ Keluaran setelah ResultPath (`afterResultPath`)
+ Keluaran akhir setelah OutputPath (`output`)
### Transformasi status peta: ItemSelector,, ItemsPath, ItemBatcher ItemsPointer
Untuk status Peta, Anda dapat menggunakan TestState API untuk melihat bagaimana item diekstraksi dan diubah.
Anda dapat menegaskan:
+ Item setelah ItemsPath filter (`afterItemsPath`)
+ Item setelah ItemsPointer filter (`afterItemsPointer`)
+ Item setelah ItemSelector transformasi (`afterItemSelector`)
+ Item setelah ItemBatcher pengelompokan () `afterItemBatcher`
### Memetakan ambang kegagalan status: Status Pengujian. ExceedToleratedFailureThreshold
Uji apakah sejumlah iterasi gagal tertentu memicu ambang kegagalan yang ditoleransi.
Anda dapat menegaskan:
+ Apakah status Peta gagal dengan Negara. ExceedToleratedFailureThreshold
### Propagasi kesalahan di Peta dan status Paralel
Saat menguji status dalam status Peta atau Paralel, kesalahan menyebar ke penangan kesalahan status induk seperti yang terjadi dalam eksekusi nyata.
#### Menentukan sumber kesalahan dengan State errorCausedBy
Saat mengejek kesalahan untuk status Peta atau Paralel, Anda harus menentukan sub-status mana yang menyebabkan kesalahan menggunakan parameter. `stateConfiguration.errorCausedByState` Ini sangat penting saat menguji kesalahan wildcard seperti`States.TaskFailed`. `States.TaskFailed`adalah kesalahan wildcard yang berlaku untuk kegagalan status Tugas apa pun. Untuk menguji bagaimana Peta atau status Paralel menangani kesalahan ini, Anda perlu mengidentifikasi sub-status tertentu yang melemparkannya. Lihat contoh di bawah ini:
```
aws stepfunctions test-state \
--definition '{...Map or Parallel state definition...}' \
--input '[...]' \
--state-configuration '{"errorCausedByState": "ProcessItem"}' \
--mock '{"errorOutput": {"error": "States.TaskFailed", "cause": "Task execution failed"}}'
```
Dalam contoh ini, `errorCausedByState` katakan TestState bahwa status ProcessItem "" dalam Map/Parallel alur kerja menimbulkan kesalahan. Penangan Catch atau Retry Map/Parallel state induk akan memproses kesalahan seperti yang terjadi selama eksekusi aktual. `nextState`Bidang dalam respons menunjukkan penangan kesalahan mana yang menangkap kesalahan. Anda dapat menegaskan:
+ Apakah kesalahan status anak ditangkap oleh penangan Catch induk
+ Apakah kesalahan status anak memicu kebijakan Coba Ulang induk
+ Apa status selanjutnya setelah propagasi kesalahan
## Integrasi layanan mengejek
TestState API mendukung mengejek hasil integrasi layanan, memungkinkan Anda untuk menguji logika mesin status Anda tanpa memanggil layanan yang sebenarnya. AWS
### Kapan harus menggunakan ejekan
Mengejek berguna untuk:
+ Definisi mesin status pengujian unit dalam isolasi
+ Menguji penanganan kesalahan dan coba lagi logika
+ Memvalidasi transformasi data input dan output
+ Mensimulasikan berbagai respons layanan dan kondisi kesalahan
+ Menguji tanpa mengonfigurasi izin IAM
Saat Anda menentukan tiruan, `roleArn` parameter menjadi opsional, memungkinkan Anda untuk fokus pada pengujian definisi mesin status Anda tanpa berurusan dengan masalah terkait izin.
**catatan**
Mengejek diperlukan jika Anda perlu menguji jenis status atau pola integrasi layanan berikut - Peta, Paralel, Aktivitas, integrasi layanan .sync, dan integrasi layanan waitForTask Token.
### Sintaks mengejek dasar
Untuk mengejek hasil integrasi layanan:
```
aws stepfunctions test-state \
--definition '{
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Arguments": {
"FunctionName": "MyFunction",
"Payload.$": "$"
},
"End": true
}' \
--input '{"key": "value"}' \
--mock '{"result": "{\"Payload\": {\"statusCode\": 200, \"body\": \"Success\"}}"}'
```
Untuk mengejek kesalahan:
```
aws stepfunctions test-state \
--definition '{
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Arguments": {...},
"End": true
}' \
--input '{"key": "value"}' \
--mock '{"errorOutput": {"error": "Lambda.ServiceException", "cause": "Service unavailable"}}'
```
**catatan**
Anda tidak dapat memberikan keduanya `mock.result` dan `mock.errorOutput` dalam panggilan API yang sama. Ini menghasilkan pengecualian validasi.
### Mode validasi tiruan
TestState API memvalidasi respons tiruan terhadap model API AWS layanan untuk memastikan kebenarannya. Anda dapat mengontrol perilaku validasi menggunakan `fieldValidationMode` parameter:
+ **STRICT (default)** - Menerapkan batasan penamaan bidang, ukuran, bentuk, dan tipe data dari model API. AWS Semua bidang wajib harus hadir dengan tipe yang benar. Mode ini membantu memastikan tiruan Anda secara akurat mewakili respons layanan nyata.
+ **PRESENT** - Memvalidasi hanya bidang yang ada dalam tiruan. Bidang yang tidak dikenal diabaikan. Mode ini berguna ketika Anda menginginkan fleksibilitas tetapi masih menginginkan validasi pada bidang yang diketahui.
+ **TIDAK ADA** - Melewatkan validasi sepenuhnya. Gunakan dengan hati-hati karena ini dapat menyebabkan asumsi dan perilaku pengujian yang salah yang berbeda dari eksekusi yang sebenarnya.
**catatan**
Validasi dilakukan hanya pada bidang yang ditentukan dalam model API AWS layanan. Bidang apa pun yang tidak ditentukan dalam model API akan diabaikan selama validasi, terlepas dari mode validasi. Misalnya, jika menggunakan mode STRICT untuk API yang mendefinisikan tidak ada bidang 'Diperlukan', respons tiruan kosong akan melewati validasi.
Contoh dengan mode validasi:
```
aws stepfunctions test-state \
--definition '{
"Type": "Task",
"Resource": "arn:aws:states:::dynamodb:putItem",
"Parameters": {...},
"End": true
}' \
--input '{"key": "value"}' \
--mock '{"fieldValidationMode": "STRICT", "result": "{\"Attributes\": {...}}"}'
```
**penting**
Validasi tiruan tidak didukung untuk integrasi [HTTP Task](call-https-apis.md), API Gateway, EKS Call, dan EKS RunJob .
## Menguji Peta dan status Paralel
TestState API mendukung pengujian status Peta dan Paralel saat tiruan ditentukan. Ini memungkinkan Anda untuk menguji pemrosesan input dan output dari status aliran ini.
### Memahami pengujian status Peta
Saat menguji status Peta dengan TestState API, Anda menguji pemrosesan input dan output status Peta tanpa menjalankan iterasi di dalamnya. Pendekatan ini memungkinkan Anda untuk menguji:
+ ItemsPath atau ItemsPointer ekstraksi dari input
+ ItemSelector transformasi diterapkan untuk setiap item
+ ItemBatcher pengelompokan (jika ditentukan)
+ Pemrosesan keluaran status Peta (ResultPath, OutputPath)
+ Ambang batas kegagalan yang ditoleransi
Anda tidak menguji apa yang terjadi di dalam ItemProcessor (status yang memproses setiap item).
### Menguji status Peta
Saat menguji status Peta, hasil yang diejek harus mewakili output dari seluruh status Peta. Hasil tiruan harus berupa array JSON atau objek JSON yang valid tergantung pada konfigurasi status Peta Anda. Lihat contoh di bawah ini:
```
aws stepfunctions test-state \
--definition '{
"Type": "Map",
"ItemsPath": "$.items",
"ItemSelector": {
"value.$": "$$.Map.Item.Value",
"index.$": "$$.Map.Item.Index"
},
"ItemProcessor": {
"ProcessorConfig": {"Mode": "INLINE"},
"StartAt": "ProcessItem",
"States": {
"ProcessItem": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"End": true
}
}
},
"End": true
}' \
--input '{"items": [1, 2, 3, 4, 5]}' \
--mock '{"result": "[10, 20, 30, 40, 50]"}' \
--inspection-level DEBUG
```
### Menguji status Peta Terdistribusi
Status Peta Terdistribusi diuji mirip dengan status Peta sebaris. Saat Peta Anda menggunakan ItemReader to read from S3, berikan data langsung di input (seolah-olah sudah dibaca dari S3). Contoh:
```
aws stepfunctions test-state \
--definition '{
"Type": "Map",
"ItemReader": {
"Resource": "arn:aws:states:::s3:getObject",
"Parameters": {
"Bucket": "my-bucket",
"Key": "orders.json"
}
},
"ItemsPath": "$.orders",
"ItemProcessor": {
"ProcessorConfig": {"Mode": "DISTRIBUTED"},
...
},
"ToleratedFailureCount": 5,
"End": true
}' \
--input '{
"orders": [
{"orderId": "123"},
{"orderId": "456"},
{"orderId": "789"}
]
}' \
--mock '{"result": "..."}'
```
**catatan**
Saat menguji status Peta Terdistribusi (Mode diatur ke DISTRIBUTED), Anda juga dapat menegaskan tentang mapIterationFailure Hitungan. Nilai untuk bidang ini tidak dapat melebihi jumlah item dalam input, atau sama dengan jumlah item saat menguji status dalam Peta.
### Populasi Konteks Otomatis
Saat menguji status dalam status Peta (menggunakan `stateName` parameter) tanpa memberikan `context` parameter, TestState secara otomatis mengisi objek Context dengan nilai default. Ini termasuk bidang konteks khusus Peta seperti:
+ `$$.Map.Item.Index`= `0` (iterasi pertama)
+ `$$.Map.Item.Value`= nilai masukan Anda
+ `$$.Map.Item.Key`(untuk Peta Terdistribusi dengan ItemReader konfigurasi tertentu)
+ `$$.Map.Item.Source`(untuk Peta Terdistribusi, menunjukkan sumber item)
### Menguji status Paralel
Saat menguji status Paralel, hasil tiruan harus berupa array JSON dengan satu elemen untuk setiap cabang, dalam urutan yang sama seperti cabang yang muncul dalam definisi.
## Aktivitas Pengujian, .sync, dan. waitForTaskToken menyatakan
TestState API mendukung pengujian status Aktivitas, pola integrasi layanan.sync, dan. waitForTaskPola token saat tiruan ditentukan. Tanpa tiruan, menjalankan status ini melalui TestState API akan mengembalikan pengecualian validasi.
**catatan**
Untuk menguji integrasi.sync menggunakan TestState API, respons tiruan divalidasi terhadap skema API polling. Misalnya, saat menguji`startExecution.sync:2`, tiruan Anda harus cocok dengan skema `DescribeExecution` respons (yang memilih status), bukan Step Functions responsnya. `StartExecution`
## Iterasi melalui definisi mesin negara
Anda dapat memberikan definisi mesin status lengkap ke TestState API dan menentukan status mana yang akan diuji menggunakan `stateName` parameter. Ini memungkinkan Anda untuk menguji status tertentu dalam konteks mesin status lengkap Anda. Anda juga dapat menguji rantai dengan menggunakan output dan nextState dari satu tes sebagai input ke tes berikutnya. Ini memungkinkan Anda untuk menguji jalur eksekusi sebagian atau lengkap dalam mesin status Anda.
## Menggunakan bidang konteks di TestState API
`context`Parameter memungkinkan Anda untuk memberikan nilai untuk objek Context yang biasanya akan diisi selama eksekusi. Ini berguna untuk menguji status yang mereferensikan nilai konteks seperti ID eksekusi, nama negara, atau waktu yang dimasukkan. Contoh di bawah ini menunjukkan bagaimana Anda dapat menggunakan objek Context dalam panggilan TestState API Anda:
```
aws stepfunctions test-state \
--definition '{
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Arguments": {
"FunctionName": "MyFunction",
"Payload": {
"executionId.$": "$$.Execution.Id",
"stateName.$": "$$.State.Name",
"enteredTime.$": "$$.State.EnteredTime"
}
},
"End": true
}' \
--input '{"data": "value"}' \
--context '{
"Execution": {
"Id": "arn:aws:states:us-east-1:123456789012:execution:MyStateMachine:test-exec-123",
"Name": "test-exec-123",
"StartTime": "2024-01-01T10:00:00.000Z"
},
"State": {
"Name": "ProcessData",
"EnteredTime": "2024-01-01T10:00:05.000Z"
}
}' \
--mock '{"result": "{\"status\": \"success\"}"}'
```
## Menguji coba lagi dan penanganan kesalahan
TestState API memungkinkan Anda untuk mensimulasikan skenario coba lagi dan menguji logika penanganan kesalahan dengan menentukan upaya coba lagi dan kesalahan ejekan.
### Mensimulasikan upaya coba lagi
```
aws stepfunctions test-state \
--definition '{
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Arguments": {...},
"Retry": [{
"ErrorEquals": ["Lambda.ServiceException"],
"IntervalSeconds": 2,
"MaxAttempts": 3,
"BackoffRate": 2.0
}],
"End": true
}' \
--input '{"data": "value"}' \
--state-configuration '{"retrierRetryCount": 1}' \
--mock '{"errorOutput": {"error": "Lambda.ServiceException", "cause": "Service error"}}' \
--inspection-level DEBUG
```
Respons mencakup rincian kesalahan dalam InspectionData:
```
{
"status": "RETRIABLE",
"inspectionData": {
"errorDetails": {
"retryBackoffIntervalSeconds": 4,
"retryIndex": 0
}
}
}
```
Tanggapan ini menunjukkan:
+ Kesalahan dapat diambil (status: RETRIABLE)
+ Durasi backoff adalah 4 detik (2 × 2.0 ^ 1)
+ Coba Ulang pertama (indeks 0) berlaku
### Menguji catch handler
Saat kesalahan diejek dan cocok dengan penangan Catch, `nextState` bidang dalam respons TestState API menunjukkan status mana yang akan menangani kesalahan tersebut. Dalam contoh di bawah ini:
Untuk permintaan TestState API yang diberikan di bawah ini,
```
aws stepfunctions test-state \
--definition '{
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Arguments": {...},
"Catch": [{
"ErrorEquals": ["Lambda.TooManyRequestsException"],
"ResultPath": "$.error",
"Next": "HandleThrottling"
}],
"Next": "Success"
}' \
--input '{"data": "value"}' \
--mock '{"errorOutput": {"error": "Lambda.TooManyRequestsException", "cause": "Rate exceeded"}}' \
--inspection-level DEBUG
```
Respons API yang diharapkan harus:
```
{
"status": "CAUGHT_ERROR",
"nextState": "HandleThrottling",
"error": "Lambda.TooManyRequestsException",
"cause": "Rate exceeded",
"output": "{\"data\": \"value\", \"error\": {\"Error\": \"Lambda.TooManyRequestsException\", \"Cause\": \"Rate exceeded\"}}",
"inspectionData": {
"errorDetails": {
"catchIndex": 0
}
}
}
```
Tanggapan ini menunjukkan bahwa:
+ kesalahan tertangkap (status: CAUGHT\_ERROR)
+ Negara berikutnya adalah HandleThrottling
+ informasi kesalahan ditambahkan ke output melalui ResultPath
+ penangan Catch pertama (indeks 0) menangkap kesalahan
Anda juga dapat menguji apa yang terjadi ketika semua upaya coba lagi habis dengan meningkatkan RetryCount nilai dalam objek konteks Anda.