Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menguji mesin status dengan Step Functions Local (tidak didukung)
**Step Functions Lokal tidak didukung**
Step Functions Local **tidak** menyediakan paritas fitur dan **tidak** didukung.
Anda dapat mempertimbangkan solusi pihak ketiga yang meniru Step Functions untuk tujuan pengujian.
Sebagai alternatif dari Step Functions Local, Anda dapat menggunakan TestState API untuk menguji unit logika mesin status Anda sebelum menerapkan ke AWS akun Anda. Untuk informasi selengkapnya, lihat [Menguji mesin status dengan TestState API](https://docs.aws.amazon.com/step-functions/latest/dg/test-state-isolation.html).
Dengan AWS Step Functions Local, versi Step Functions yang dapat diunduh, Anda dapat menguji aplikasi dengan Step Functions yang berjalan di lingkungan pengembangan Anda sendiri.
Saat menjalankan Step Functions Local, Anda dapat menggunakan salah satu cara berikut untuk memanggil integrasi layanan:
+ Mengkonfigurasi titik akhir lokal untuk AWS Lambda dan layanan lainnya.
+ Melakukan panggilan langsung ke AWS layanan dari Step Functions Local.
+ Mengejek respons dari integrasi layanan.
AWS Step Functions Local tersedia sebagai paket JAR atau image Docker mandiri yang berjalan di Microsoft Windows, Linux, macOS, dan platform lain yang mendukung Java atau Docker.
**Awas**
Anda hanya boleh menggunakan Step Functions Local untuk pengujian dan tidak pernah memproses informasi sensitif.
**Topics**
+ [Menyiapkan Step Functions Lokal dan Docker](#sfn-local-docker)
+ [Menyiapkan Step Functions Lokal - Versi Java](#sfn-local-jar)
+ [Mengkonfigurasi Step Functions Opsi Lokal](#sfn-local-config-options)
+ [Menjalankan Step Functions Lokal](#sfn-local-computer)
+ [Tutorial: Pengujian menggunakan Step Functions dan AWS SAM CLI Local](sfn-local-lambda.md)
+ [Pengujian dengan integrasi layanan yang diejek](sfn-local-test-sm-exec.md)
## Menyiapkan Step Functions Lokal (Versi yang Dapat Diunduh) di Docker
Citra Docker Step Functions Local memungkinkan Anda memulai dengan Step Functions Local cepat dengan menggunakan citra Docker terhadap semua dependensi yang dibutuhkan. Image Docker memungkinkan Anda untuk menyertakan Step Functions Local dalam build container Anda dan sebagai bagian dari pengujian integrasi berkelanjutan Anda.
Untuk mendapatkan image Docker untuk Step Functions Local, lihat [https://hub.docker.com/r/amazon/ aws-stepfunctions-local](https://hub.docker.com/r/amazon/aws-stepfunctions-local), atau masukkan perintah Docker berikut. `pull`
```
docker pull amazon/aws-stepfunctions-local
```
Untuk memulai versi Step Functions yang dapat diunduh di Docker, jalankan perintah Docker berikut `run`
```
docker run -p 8083:8083 amazon/aws-stepfunctions-local
```
Untuk berinteraksi dengan AWS Lambda atau layanan lain yang didukung, Anda perlu mengonfigurasi kredensyal dan opsi konfigurasi lainnya terlebih dahulu. Untuk informasi selengkapnya, lihat topik berikut:
+ [Mengatur Opsi Konfigurasi untuk Step Functions Lokal](#sfn-local-config-options)
+ [Kredensial dan konfigurasi untuk Docker](#docker-credentials)
## Menyiapkan Step Functions Lokal (Versi yang Dapat Diunduh) - Versi Java
Versi yang dapat diunduh AWS Step Functions disediakan sebagai file JAR yang dapat dieksekusi dan sebagai gambar Docker. Aplikasi Java berjalan pada Windows, Linux, macOS, dan platform lain yang mendukung Java. Selain Java, Anda perlu menginstal AWS Command Line Interface (AWS CLI). Untuk informasi tentang menginstal dan mengonfigurasi AWS CLI, lihat [Panduan AWS Command Line Interface Pengguna](https://docs.aws.amazon.com/cli/latest/userguide/).
**Untuk menyiapkan dan menjalankan Step Functions di komputer Anda**
1. Unduh Step Functions menggunakan tautan berikut.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/step-functions/latest/dg/sfn-local.html)
1. Ekstrak file `.zip`.
1. Menguji unduhan dan melihat informasi versi.
```
$ java -jar StepFunctionsLocal.jar -v
Step Function Local
Version: 2.0.0
Build: 2024-05-18
```
1. (Opsional) Melihat daftar perintah yang tersedia.
```
$ java -jar StepFunctionsLocal.jar -h
```
1. Untuk memulai Step Functions di komputer Anda, buka command prompt, navigasikan ke direktori tempat Anda mengekstrak`StepFunctionsLocal.jar`, dan masukkan perintah berikut.
```
java -jar StepFunctionsLocal.jar
```
1. Untuk mengakses Step Functions yang berjalan secara lokal, gunakan parameter `--endpoint-url`. Misalnya, menggunakan AWS CLI, Anda akan menentukan perintah Step Functions sebagai berikut:
```
aws stepfunctions --endpoint-url http://localhost:8083 command
```
**catatan**
Secara default, Step Functions Local menggunakan akun pengujian lokal dan kredensialnya, dan AWS Region diatur ke US East (Virginia N.). Untuk menggunakan Step Functions Local dengan AWS Lambda, atau layanan lain yang didukung, Anda harus mengonfigurasi kredensyal dan Wilayah Anda.
Jika Anda menggunakan alur kerja Express dengan Step Functions Local, riwayat eksekusi akan disimpan dalam file log. Itu tidak masuk ke CloudWatch Log. Jalur file log akan didasarkan pada grup CloudWatch log Log ARN yang disediakan saat Anda membuat mesin status lokal. Berkas log akan disimpan di `/aws/states/log-group-name/${execution_arn}.log` relatif terhadap lokasi tempat Anda menjalankan Step Functions Local. Misalnya, jika ARN eksekusi adalah:
```
arn:aws:states:region:account-id:express:test:example-ExpressLogGroup-wJalrXUtnFEMI
```
berkas log adalah:
```
aws/states/log-group-name/arn:aws:states:region:account-id:express:test:example-ExpressLogGroup-wJalrXUtnFEMI.log
```
## Mengatur Opsi Konfigurasi untuk Step Functions Lokal
Saat Anda memulai AWS Step Functions Local dengan menggunakan file JAR, Anda dapat mengatur opsi konfigurasi dengan menggunakan AWS Command Line Interface (AWS CLI), atau dengan memasukkannya ke dalam lingkungan sistem. Untuk Docker, Anda harus menentukan pilihan ini dalam file yang Anda referensi ketika memulai Step Functions Local.
### Opsi konfigurasi
[Saat Anda mengonfigurasi container Step Functions Local untuk menggunakan endpoint override seperti Lambda Endpoint dan Batch Endpoint, dan melakukan panggilan ke endpoint tersebut, Step Functions Local tidak menggunakan kredensyal yang Anda tentukan.](#docker-credentials) Menyetel penggantian titik akhir ini adalah opsional.
| Opsi | Baris perintah | Lingkungan |
| --- | --- | --- |
| Akun | -akun, --aws-akun | AWS\$1ACCOUNT\$1ID |
| Region | -wilayah, --aws-region | AWS\$1DEFAULT\$1WILAYAH |
| Skala Waktu Tunggu | -waitTimeScale, --wait-time-scale | WAIT\$1TIME\$1SCALE |
| Titik Akhir Lambda | -LambdaendPoint, --lambda-titik akhir | LAMBDA\$1ENDPOINT |
| Titik Akhir Batch | -BatchEndPoint, --batch-titik akhir | BATCH\$1ENDPOINT |
| Titik Akhir DynamoDB | -dinamo, --dynamodb-titik akhir DBEndpoint | DYNAMODB\$1ENDPOINT |
| Titik akhir ECS | -ECSendPoint, --ecs-titik akhir | ECS\$1ENDPOINT |
| Titik Akhir Glue | -GlueEndpoint, --lem-titik akhir | GLUE\$1ENDPOINT |
| SageMaker Titik akhir | -sageMakerEndpoint, --sagemaker-titik akhir | SAGE\$1MAKER\$1ENDPOINT |
| Titik akhir SQS | -SqSendPoint, --sqs-titik akhir | SQS\$1ENDPOINT |
| Titik Akhir SNS | -SnsendPoint, --sns-titik akhir | SNS\$1ENDPOINT |
| Titik akhir Step Functions | -stepFunctionsEndpoint, --step-functions-endpoint | STEP\$1FUNCTIONS\$1ENDPOINT |
### Kredensial dan konfigurasi untuk Docker
Untuk mengonfigurasi Step Functions Local untuk Docker, buat file berikut: `aws-stepfunctions-local-credentials.txt`.
File ini berisi kredensyal Anda dan opsi konfigurasi lainnya. Berikut ini dapat digunakan sebagai template saat membuat `aws-stepfunctions-local-credentials.txt` file.
```
AWS_DEFAULT_REGION=AWS_REGION_OF_YOUR_AWS_RESOURCES
AWS_ACCESS_KEY_ID=YOUR_AWS_ACCESS_KEY
AWS_SECRET_ACCESS_KEY=YOUR_AWS_SECRET_KEY
WAIT_TIME_SCALE=VALUE
LAMBDA_ENDPOINT=VALUE
BATCH_ENDPOINT=VALUE
DYNAMODB_ENDPOINT=VALUE
ECS_ENDPOINT=VALUE
GLUE_ENDPOINT=VALUE
SAGE_MAKER_ENDPOINT=VALUE
SQS_ENDPOINT=VALUE
SNS_ENDPOINT=VALUE
STEP_FUNCTIONS_ENDPOINT=VALUE
```
Setelah Anda mengonfigurasi kredensial dan opsi konfigurasi Anda di `aws-stepfunctions-local-credentials.txt`, mulai Step Functions dengan perintah berikut.
```
docker run -p 8083:8083 --env-file aws-stepfunctions-local-credentials.txt amazon/aws-stepfunctions-local
```
**catatan**
Disarankan untuk menggunakan nama DNS khusus`host.docker.internal`, yang menyelesaikan ke alamat IP internal yang digunakan host, seperti. `http://host.docker.internal:8000` Untuk informasi selengkapnya, lihat dokumentasi Docker untuk Mac dan Windows di [fitur Jaringan di Docker Desktop untuk Mac](https://docs.docker.com/desktop/mac/networking/#use-cases-and-workaround) dan [fitur Jaringan di Docker Desktop untuk](https://docs.docker.com/desktop/windows/networking/) Windows masing-masing.
## Menjalankan Step Functions Lokal di Komputer Anda
Gunakan Step Functions versi lokal untuk mengonfigurasi, mengembangkan, dan menguji mesin status di komputer Anda.
### Jalankan mesin HelloWorld status secara lokal
Setelah menjalankan Step Functions secara lokal dengan AWS Command Line Interface (AWS CLI), Anda dapat memulai eksekusi mesin status.
1. Buat mesin status dari AWS CLI dengan melarikan diri dari definisi mesin status.
```
aws stepfunctions --endpoint-url http://localhost:8083 create-state-machine --definition "{\
\"Comment\": \"A Hello World example of the Amazon States Language using a Pass state\",\
\"StartAt\": \"HelloWorld\",\
\"States\": {\
\"HelloWorld\": {\
\"Type\": \"Pass\",\
\"End\": true\
}\
}}" --name "HelloWorld" --role-arn "arn:aws:iam::012345678901:role/DummyRole"
```
**catatan**
`role-arn`Ini tidak digunakan untuk Step Functions Local, tetapi Anda harus memasukkannya dengan sintaks yang tepat. Anda dapat menggunakan Amazon Resource Name (ARN) dari contoh sebelumnya.
Jika Anda berhasil membuat mesin status, Step Functions merespons dengan tanggal penciptaan dan ARN mesin status.
```
{
"creationDate": 1548454198.202,
"stateMachineArn": "arn:aws:states:region:account-id:stateMachine:HelloWorld"
}
```
1. Mulai eksekusi menggunakan ARN dari mesin status yang Anda buat.
```
aws stepfunctions --endpoint-url http://localhost:8083 start-execution --state-machine-arn arn:aws:states:region:account-id:stateMachine:HelloWorld
```
### Step Functions Lokal dengan AWS SAM CLI Lokal
Anda dapat menggunakan versi lokal Step Functions dengan versi lokal AWS Lambda. Untuk mengonfigurasi ini, Anda harus memasang dan mengonfigurasi AWS SAM.
Untuk informasi tentang mengkonfigurasi dan menjalankan AWS SAM, lihat berikut ini:
+ [Mengatur AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-quick-start.html)
+ [Mulai AWS SAM CLI Lokal](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/sam-cli-command-reference-sam-local-start-lambda.html)
Ketika Lambda berjalan pada sistem lokal Anda, Anda dapat memulai Step Functions Local. Dari direktori tempat Anda mengekstrak file JAR lokal Step Functions, mulai Step Functions Local dan gunakan `--lambda-endpoint` parameter untuk mengonfigurasi titik akhir Lambda lokal.
```
java -jar StepFunctionsLocal.jar --lambda-endpoint http://127.0.0.1:3001 command
```
Untuk informasi selengkapnya tentang menjalankan Step Functions Local with AWS Lambda, lihat[Tutorial: Menguji alur kerja menggunakan Step Functions dan AWS SAM CLI Local](sfn-local-lambda.md).
# Tutorial: Menguji alur kerja menggunakan Step Functions dan AWS SAM CLI Local
**Step Functions Lokal tidak didukung**
Step Functions Local **tidak** menyediakan paritas fitur dan **tidak** didukung.
Anda dapat mempertimbangkan solusi pihak ketiga yang meniru Step Functions untuk tujuan pengujian.
Sebagai alternatif dari Step Functions Local, Anda dapat menggunakan TestState API untuk menguji unit logika mesin status Anda sebelum menerapkan ke AWS akun Anda. Untuk informasi selengkapnya, lihat [Menguji mesin status dengan TestState API](https://docs.aws.amazon.com/step-functions/latest/dg/test-state-isolation.html).
Dengan keduanya AWS Step Functions dan AWS Lambda berjalan di mesin lokal Anda, Anda dapat menguji mesin status dan fungsi Lambda Anda tanpa menerapkan kode Anda. AWS
Untuk informasi selengkapnya, lihat topik berikut:
+ [Menguji mesin status dengan Step Functions Local (tidak didukung)](sfn-local.md)
+ [Mengatur AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-quick-start.html)
## Langkah 1: Mengatur AWS SAM
AWS Serverless Application Model (AWS SAM) CLI Local membutuhkan AWS Command Line Interface, AWS SAM, dan Docker untuk diinstal.
1. [Instal AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html).
**catatan**
Sebelum menginstal AWS SAM CLI, Anda perlu menginstal AWS CLI dan Docker. Lihat [Prasyarat](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html) untuk menginstal CLI. AWS SAM
1. Buka dokumentasi [Quick Start AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-quick-start.html). Pastikan untuk mengikuti langkah-langkah berikut:
1. [Inisialisasi Aplikasi](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-quick-start.html#gs-ex1-setup-local-app)
1. [Uji Aplikasi Secara Lokal](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-quick-start.html#gs-ex1-test-locally)
Hal ini menciptakan direktori `sam-app`, dan membangun lingkungan yang mencakup fungsi Hello World Lambda berbasis Python.
## Langkah 2: Uji AWS SAM CLI Lokal
Sekarang setelah Anda menginstal AWS SAM dan membuat fungsi Hello World Lambda, Anda dapat menguji fungsinya. Di `sam-app` direktori, masukkan perintah berikut:
```
sam local start-api
```
Langkah ini meluncurkan instans lokal dari fungsi Lambda Anda. Anda akan melihat output yang serupa dengan yang berikut:
```
2019-01-31 16:40:27 Found credentials in shared credentials file: ~/.aws/credentials
2019-01-31 16:40:27 Mounting HelloWorldFunction at http://127.0.0.1:3000/hello [GET]
2019-01-31 16:40:27 You can now browse to the above endpoints to invoke your functions. You do not need to restart/reload SAM CLI while working on your functions changes will be reflected instantly/automatically. You only need to restart SAM CLI if you update your AWS SAM template
2019-01-31 16:40:27 * Running on http://127.0.0.1:3000/ (Press CTRL+C to quit)
```
Buka browser dan masukkan yang berikut ini:
```
http://127.0.0.1:3000/hello
```
Ini akan menghasilkan respons yang mirip dengan yang berikut:
```
{"message": "hello world", "location": "72.21.198.66"}
```
Masukkan **CTRL\$1C** untuk mengakhiri API Lambda.
## Langkah 3: Mulai AWS SAM CLI Lokal
Sekarang setelah Anda menguji bahwa fungsinya berfungsi, mulai AWS SAM CLI Local. Di `sam-app` direktori, masukkan perintah berikut:
```
sam local start-lambda
```
Ini memulai AWS SAM CLI Local dan menyediakan titik akhir untuk digunakan, mirip dengan output berikut:
```
2019-01-29 15:33:32 Found credentials in shared credentials file: ~/.aws/credentials
2019-01-29 15:33:32 Starting the Local Lambda Service. You can now invoke your Lambda Functions defined in your template through the endpoint.
2019-01-29 15:33:32 * Running on http://127.0.0.1:3001/ (Press CTRL+C to quit)
```
## Langkah 4: Mulai Step Functions Local
### File JAR
Jika Anda menggunakan versi `.jar` file Step Functions Local, mulai Step Functions dan tentukan titik akhir Lambda. Di direktori tempat Anda mengekstrak `.jar` file, masukkan perintah berikut:
```
java -jar StepFunctionsLocal.jar --lambda-endpoint http://localhost:3001
```
Saat Step Functions Local dimulai, ia memeriksa lingkungan, lalu kredensial dikonfigurasikan di file `~/.aws/credentials` Anda. Secara default, itu mulai menggunakan ID pengguna fiktif, dan terdaftar sebagai. `region us-east-1`
```
2019-01-29 15:38:06.324: Failed to load credentials from environment because Unable to load AWS credentials from environment variables (AWS_ACCESS_KEY_ID (or AWS_ACCESS_KEY) and AWS_SECRET_KEY (or AWS_SECRET_ACCESS_KEY))
2019-01-29 15:38:06.326: Loaded credentials from profile: default
2019-01-29 15:38:06.326: Starting server on port 8083 with account account-id, region us-east-1
```
### Docker
Jika Anda menggunakan Step Functions Local versi Docker, luncurkan Step Functions dengan perintah berikut:
```
docker run -p 8083:8083 amazon/aws-stepfunctions-local
```
Untuk informasi tentang menginstal Step Functions versi Docker, lihat [Menyiapkan Step Functions Lokal (Versi yang Dapat Diunduh) di Docker](sfn-local.md#sfn-local-docker).
**catatan**
Anda dapat menentukan titik akhir melalui baris perintah atau dengan menetapkan variabel lingkungan jika Anda meluncurkan Step Functions dari file `.jar`. Untuk versi Docker, Anda harus menentukan titik akhir dan kredensial dalam file teks. Lihat [Mengatur Opsi Konfigurasi untuk Step Functions Lokal](sfn-local.md#sfn-local-config-options).
## Langkah 5: Buat Mesin Negara yang Mereferensikan Fungsi AWS SAM Lokal CLI Anda
Setelah Step Functions Local berjalan, buat mesin status yang mereferensikan `HelloWorldFunction` yang Anda inisialisasi. [Langkah 1: Mengatur AWS SAM](#install-sam)
```
aws stepfunctions --endpoint http://localhost:8083 create-state-machine --definition "{\
\"Comment\": \"A Hello World example of the Amazon States Language using an AWS Lambda Local function\",\
\"StartAt\": \"HelloWorld\",\
\"States\": {\
\"HelloWorld\": {\
\"Type\": \"Task\",\
\"Resource\": \"arn:aws:lambda:region:account-id:function:HelloWorldFunction\",\
\"End\": true\
}\
}\
}\" --name "HelloWorld" --role-arn "arn:aws:iam::012345678901:role/DummyRole"
```
Tindakan ini akan menciptakan sebuah mesin status dan menyediakan Amazon Resource Name (ARN) yang dapat Anda gunakan untuk memulai eksekusi.
```
{
"creationDate": 1548805711.403,
"stateMachineArn": "arn:aws:states:region:account-id:stateMachine:HelloWorld"
}
```
## Langkah 6: Mulai Eksekusi Mesin Status Lokal Anda.
Setelah Anda membuat mesin negara, mulailah eksekusi. Anda harus mereferensikan ARN endpoint dan state machine saat menggunakan perintah berikut**aws stepfunctions**:
```
aws stepfunctions --endpoint http://localhost:8083 start-execution --state-machine arn:aws:states:region:account-id:stateMachine:HelloWorld --name test
```
Ini memulai eksekusi bernama `test` mesin `HelloWorld` negara Anda.
```
{
"startDate": 1548810641.52,
"executionArn": "arn:aws:states:region:account-id:execution:HelloWorld:test"
}
```
Sekarang Step Functions berjalan secara lokal, Anda dapat berinteraksi dengannya menggunakan file. AWS CLI Misalnya, untuk mendapatkan informasi tentang eksekusi ini, gunakan perintah berikut:
```
aws stepfunctions --endpoint http://localhost:8083 describe-execution --execution-arn arn:aws:states:region:account-id:execution:HelloWorld:test
```
`describe-execution`Memanggil eksekusi memberikan detail yang lebih lengkap, mirip dengan output berikut:
```
{
"status": "SUCCEEDED",
"startDate": 1549056334.073,
"name": "test",
"executionArn": "arn:aws:states:region:account-id:execution:HelloWorld:test",
"stateMachineArn": "arn:aws:states:region:account-id:stateMachine:HelloWorld",
"stopDate": 1549056351.276,
"output": "{\"statusCode\": 200, \"body\": \"{\\\"message\\\": \\\"hello world\\\", \\\"location\\\": \\\"72.21.198.64\\\"}\"}",
"input": "{}"
}
```
# Menggunakan integrasi layanan tiruan untuk pengujian di Step Functions Local
**Step Functions Lokal tidak didukung**
Step Functions Local **tidak** menyediakan paritas fitur dan **tidak** didukung.
Anda dapat mempertimbangkan solusi pihak ketiga yang meniru Step Functions untuk tujuan pengujian.
Di Step Functions Local, Anda dapat menguji jalur eksekusi mesin status Anda tanpa benar-benar memanggil layanan terintegrasi dengan menggunakan integrasi layanan tiruan. Untuk mengonfigurasi mesin status Anda agar menggunakan integrasi layanan tiruan, Anda membuat file konfigurasi tiruan. Dalam file ini, Anda mendefinisikan output yang diinginkan dari integrasi layanan Anda sebagai respons yang diejek dan eksekusi yang menggunakan respons tiruan Anda untuk mensimulasikan jalur eksekusi sebagai kasus uji.
Dengan menyediakan file konfigurasi tiruan ke Step Functions Local, Anda dapat menguji panggilan integrasi layanan dengan menjalankan state machine yang menggunakan respons tiruan yang ditentukan dalam kasus pengujian alih-alih membuat panggilan integrasi layanan yang sebenarnya.
**catatan**
Jika Anda tidak menentukan respons integrasi layanan tiruan dalam file konfigurasi tiruan, Step Functions Local akan memanggil integrasi AWS layanan menggunakan titik akhir yang Anda konfigurasikan saat menyiapkan Step Functions Local. Untuk informasi tentang mengonfigurasi titik akhir untuk Step Functions Local, lihat. [Mengatur Opsi Konfigurasi untuk Step Functions Lokal](sfn-local.md#sfn-local-config-options)
Topik ini menggunakan beberapa konsep yang didefinisikan dalam daftar berikut:
+ Integrasi Layanan Mocked - Mengacu pada status Tugas yang dikonfigurasi untuk menggunakan respons yang diejek alih-alih melakukan panggilan layanan yang sebenarnya.
+ Respons Mocked - Mengacu pada data tiruan yang status Tugas dapat dikonfigurasi untuk digunakan.
+ Kasus Uji - Mengacu pada eksekusi mesin status yang dikonfigurasi untuk menggunakan integrasi layanan yang diejek.
+ File Konfigurasi Mock - Mengacu pada file konfigurasi tiruan yang berisi JSON, yang mendefinisikan integrasi layanan tiruan, respons yang diejek, dan kasus uji.
## Mengkonfigurasi integrasi layanan yang diejek
Anda dapat mengejek integrasi layanan apa pun menggunakan Step Functions Local. Namun, Step Functions Local tidak memaksakan tiruan menjadi sama dengan yang asli. APIs Tugas yang diejek tidak akan pernah memanggil titik akhir layanan. Jika Anda tidak menentukan respons yang diejek, Tugas akan mencoba memanggil titik akhir layanan. Selain itu, Step Functions Local akan secara otomatis menghasilkan token tugas saat Anda mengejek Task menggunakan. `.waitForTaskToken`
## Langkah 1: Tentukan Integrasi Layanan Mocked dalam File Konfigurasi Mock
Anda dapat menguji Step Functions AWS SDK dan integrasi layanan yang dioptimalkan menggunakan Step Functions Local. Gambar berikut menunjukkan mesin status yang ditentukan dalam tab Definisi mesin Negara:
![\[Contoh integrasi layanan yang diejek.\]](http://docs.aws.amazon.com/id_id/step-functions/latest/dg/images/msi-graph.png)
Untuk melakukan ini, Anda harus membuat file konfigurasi tiruan yang berisi bagian seperti yang didefinisikan dalam[Struktur file konfigurasi tiruan](#mock-cfg-struct).
1. Buat file bernama `MockConfigFile.json` untuk mengonfigurasi pengujian dengan integrasi layanan tiruan.
Contoh berikut menunjukkan file konfigurasi tiruan yang mereferensikan mesin negara dengan dua status yang ditentukan bernama `LambdaState` dan. `SQSState`
------
#### [ Mock configuration file example ]
Berikut ini adalah contoh file konfigurasi tiruan yang menunjukkan cara mengejek tanggapan dari menjalankan fungsi [Lambda](connect-lambda.md) [dan mengirim pesan](connect-sqs.md) ke Amazon SQS. Dalam contoh ini, mesin [`LambdaSQSIntegration`](#mock-cfg-sm-sect)negara berisi tiga kasus uji bernama`HappyPath`,`RetryPath`, dan `HybridPath` yang mengejek `Task` status bernama `LambdaState` dan`SQSState`. Negara-negara bagian ini menggunakan`MockedLambdaSuccess`,`MockedSQSSuccess`, dan tanggapan layanan yang `MockedLambdaRetry` diejek. Respons layanan yang diejek ini didefinisikan di `MockedResponses` bagian file.
```
{
"StateMachines":{
"LambdaSQSIntegration":{
"TestCases":{
"HappyPath":{
"LambdaState":"MockedLambdaSuccess",
"SQSState":"MockedSQSSuccess"
},
"RetryPath":{
"LambdaState":"MockedLambdaRetry",
"SQSState":"MockedSQSSuccess"
},
"HybridPath":{
"LambdaState":"MockedLambdaSuccess"
}
}
}
},
"MockedResponses":{
"MockedLambdaSuccess":{
"0":{
"Return":{
"StatusCode":200,
"Payload":{
"StatusCode":200,
"body":"Hello from Lambda!"
}
}
}
},
"LambdaMockedResourceNotReady":{
"0":{
"Throw":{
"Error":"Lambda.ResourceNotReadyException",
"Cause":"Lambda resource is not ready."
}
}
},
"MockedSQSSuccess":{
"0":{
"Return":{
"MD5OfMessageBody":"3bcb6e8e-7h85-4375-b0bc-1a59812c6e51",
"MessageId":"3bcb6e8e-8b51-4375-b0bc-1a59812c6e51"
}
}
},
"MockedLambdaRetry":{
"0":{
"Throw":{
"Error":"Lambda.ResourceNotReadyException",
"Cause":"Lambda resource is not ready."
}
},
"1-2":{
"Throw":{
"Error":"Lambda.TimeoutException",
"Cause":"Lambda timed out."
}
},
"3":{
"Return":{
"StatusCode":200,
"Payload":{
"StatusCode":200,
"body":"Hello from Lambda!"
}
}
}
}
}
}
```
------
#### [ State machine definition ]
Berikut ini adalah contoh definisi mesin negara yang disebut`LambdaSQSIntegration`, yang mendefinisikan dua status tugas integrasi layanan bernama `LambdaState` dan`SQSState`. `LambdaState`berisi kebijakan coba lagi berdasarkan`States.ALL`.
```
{
"Comment":"This state machine is called: LambdaSQSIntegration",
"StartAt":"LambdaState",
"States":{
"LambdaState":{
"Type":"Task",
"Resource":"arn:aws:states:::lambda:invoke",
"Parameters":{
"Payload.$":"$",
"FunctionName":"HelloWorldFunction"
},
"Retry":[
{
"ErrorEquals":[
"States.ALL"
],
"IntervalSeconds":2,
"MaxAttempts":3,
"BackoffRate":2
}
],
"Next":"SQSState"
},
"SQSState":{
"Type":"Task",
"Resource":"arn:aws:states:::sqs:sendMessage",
"Parameters":{
"QueueUrl":"https://sqs.us-east-1.amazonaws.com/account-id/myQueue",
"MessageBody.$":"$"
},
"End": true
}
}
}
```
------
Anda dapat menjalankan definisi mesin `LambdaSQSIntegration` status yang direferensikan dalam file konfigurasi tiruan menggunakan salah satu kasus uji berikut:
+ `HappyPath`- Tes ini mengolok-olok output `LambdaState` dan `SQSState` menggunakan `MockedLambdaSuccess` dan `MockedSQSSuccess` masing-masing.
+ `LambdaState`Akan mengembalikan nilai berikut:
```
"0":{
"Return":{
"StatusCode":200,
"Payload":{
"StatusCode":200,
"body":"Hello from Lambda!"
}
}
}
```
+ `SQSState`Akan mengembalikan nilai berikut:
```
"0":{
"Return":{
"MD5OfMessageBody":"3bcb6e8e-7h85-4375-b0bc-1a59812c6e51",
"MessageId":"3bcb6e8e-8b51-4375-b0bc-1a59812c6e51"
}
}
```
+ `RetryPath`- Tes ini mengolok-olok output `LambdaState` dan `SQSState` menggunakan `MockedLambdaRetry` dan `MockedSQSSuccess` masing-masing. Selain itu, `LambdaState` dikonfigurasi untuk melakukan empat upaya coba lagi. Tanggapan yang diejek untuk upaya ini didefinisikan dan diindeks di negara bagian. `MockedLambdaRetry`
+ Upaya awal berakhir dengan kegagalan tugas yang berisi pesan penyebab dan kesalahan seperti yang ditunjukkan pada contoh berikut:
```
"0":{
"Throw": {
"Error": "Lambda.ResourceNotReadyException",
"Cause": "Lambda resource is not ready."
}
}
```
+ Upaya percobaan ulang pertama dan kedua diakhiri dengan kegagalan tugas yang berisi pesan penyebab dan kesalahan seperti yang ditunjukkan pada contoh berikut:
```
"1-2":{
"Throw": {
"Error": "Lambda.TimeoutException",
"Cause": "Lambda timed out."
}
}
```
+ Upaya coba lagi ketiga diakhiri dengan keberhasilan tugas yang berisi hasil status dari bagian Payload dalam respons Lambda yang diejek.
```
"3":{
"Return": {
"StatusCode": 200,
"Payload": {
"StatusCode": 200,
"body": "Hello from Lambda!"
}
}
}
```
**catatan**
Untuk status dengan kebijakan coba lagi, Step Functions Local akan menghabiskan upaya percobaan ulang yang ditetapkan dalam kebijakan hingga menerima respons yang berhasil. Ini berarti bahwa Anda harus menunjukkan ejekan untuk percobaan ulang dengan nomor percobaan berturut-turut dan harus mencakup semua upaya coba lagi sebelum mengembalikan respons yang berhasil.
Jika Anda tidak menentukan respons yang diejek untuk upaya coba lagi tertentu, misalnya, coba lagi “3", eksekusi mesin status akan gagal.
+ `HybridPath`- Tes ini mengolok-olok output dari. `LambdaState` Setelah berhasil `LambdaState` berjalan dan menerima data tiruan sebagai respons, `SQSState` melakukan panggilan layanan aktual ke sumber daya yang ditentukan dalam produksi.
Untuk informasi tentang cara memulai eksekusi pengujian dengan integrasi layanan tiruan, lihat. [Langkah 3: Jalankan Tes Integrasi Layanan Mocked](#run-mocked-serv-integ-tests)
1. Pastikan bahwa struktur respons yang diejek sesuai dengan struktur respons layanan aktual yang Anda terima saat Anda melakukan panggilan layanan terintegrasi. Untuk informasi tentang persyaratan struktural untuk tanggapan yang diejek, lihat[Mengkonfigurasi integrasi layanan yang diejek](#mock-resp-struct-req).
Dalam contoh file konfigurasi tiruan sebelumnya, respons tiruan didefinisikan `MockedLambdaSuccess` dan `MockedLambdaRetry` sesuai dengan struktur respons aktual yang dikembalikan dari panggilan. `HelloFromLambda`
**penting**
AWS tanggapan layanan dapat bervariasi dalam struktur antara layanan yang berbeda. Step Functions Local tidak memvalidasi jika struktur respons tiruan sesuai dengan struktur respons layanan yang sebenarnya. Anda harus memastikan bahwa tanggapan ejekan Anda sesuai dengan respons aktual sebelum pengujian. Untuk meninjau struktur respons layanan, Anda dapat melakukan panggilan layanan aktual menggunakan Step Functions atau melihat dokumentasi untuk layanan tersebut.
## Langkah 2: Berikan File Konfigurasi Mock ke Step Functions Local
Anda dapat menyediakan file konfigurasi tiruan ke Step Functions Local dengan salah satu cara berikut:
------
#### [ Docker ]
**catatan**
Jika Anda menggunakan versi Docker dari Step Functions Local, Anda dapat menyediakan file konfigurasi tiruan hanya menggunakan variabel lingkungan. Selain itu, Anda harus memasang file konfigurasi tiruan ke wadah Step Functions Local pada boot-up server awal.
Pasang file konfigurasi tiruan ke direktori apa pun dalam wadah Step Functions Local. Kemudian, atur variabel lingkungan bernama `SFN_MOCK_CONFIG` yang berisi path ke file konfigurasi tiruan dalam wadah. Metode ini memungkinkan file konfigurasi tiruan diberi nama apa saja selama variabel lingkungan berisi path file dan nama.
Perintah berikut menunjukkan format untuk memulai image Docker.
```
docker run -p 8083:8083
--mount type=bind,readonly,source={absolute path to mock config file},destination=/home/StepFunctionsLocal/MockConfigFile.json
-e SFN_MOCK_CONFIG="/home/StepFunctionsLocal/MockConfigFile.json" amazon/aws-stepfunctions-local
```
Contoh berikut menggunakan perintah untuk memulai image Docker.
```
docker run -p 8083:8083
--mount type=bind,readonly,source=/Users/admin/Desktop/workplace/MockConfigFile.json,destination=/home/StepFunctionsLocal/MockConfigFile.json
-e SFN_MOCK_CONFIG="/home/StepFunctionsLocal/MockConfigFile.json" amazon/aws-stepfunctions-local
```
------
#### [ JAR File ]
Gunakan salah satu cara berikut untuk menyediakan file konfigurasi tiruan ke Step Functions Local:
+ Tempatkan file konfigurasi tiruan di direktori yang sama dengan. `Step FunctionsLocal.jar` Saat menggunakan metode ini, Anda harus memberi nama file `MockConfigFile.json` konfigurasi tiruan.
+ Dalam sesi yang menjalankan Step Functions Local`SFN_MOCK_CONFIG`, atur variabel lingkungan bernama, ke path lengkap file konfigurasi tiruan. Metode ini memungkinkan file konfigurasi tiruan diberi nama apa saja selama variabel lingkungan berisi path file dan nama. Dalam contoh berikut, `SFN_MOCK_CONFIG` variabel diatur untuk menunjuk pada file konfigurasi tiruan bernama`EnvSpecifiedMockConfig.json`, terletak di `/home/workspace` direktori.
```
export SFN_MOCK_CONFIG="/home/workspace/EnvSpecifiedMockConfig.json"
```
**catatan**
Jika Anda tidak menyediakan variabel lingkungan `SFN_MOCK_CONFIG` ke Step Functions Local, secara default, ia akan mencoba membaca file konfigurasi tiruan bernama `MockConfigFile.json` dalam direktori tempat Anda meluncurkan Step Functions Local.
Jika Anda menempatkan file konfigurasi tiruan di direktori yang sama dengan `Step FunctionsLocal.jar` dan mengatur variabel lingkungan`SFN_MOCK_CONFIG`, Step Functions Local akan membaca file yang ditentukan oleh variabel lingkungan.
------
## Langkah 3: Jalankan Tes Integrasi Layanan Mocked
Setelah Anda membuat dan menyediakan file konfigurasi tiruan ke Step Functions Local, jalankan state machine yang dikonfigurasi dalam file konfigurasi tiruan menggunakan integrasi layanan tiruan. Kemudian periksa hasil eksekusi menggunakan tindakan API.
1. Buat mesin status berdasarkan definisi yang disebutkan sebelumnya dalam [file konfigurasi tiruan](#create-mock-config-file).
```
aws stepfunctions create-state-machine \
--endpoint http://localhost:8083 \
--definition "{\"Comment\":\"Thisstatemachineiscalled:LambdaSQSIntegration\",\"StartAt\":\"LambdaState\",\"States\":{\"LambdaState\":{\"Type\":\"Task\",\"Resource\":\"arn:aws:states:::lambda:invoke\",\"Parameters\":{\"Payload.$\":\"$\",\"FunctionName\":\"arn:aws:lambda:region:account-id:function:HelloWorldFunction\"},\"Retry\":[{\"ErrorEquals\":[\"States.ALL\"],\"IntervalSeconds\":2,\"MaxAttempts\":3,\"BackoffRate\":2}],\"Next\":\"SQSState\"},\"SQSState\":{\"Type\":\"Task\",\"Resource\":\"arn:aws:states:::sqs:sendMessage\",\"Parameters\":{\"QueueUrl\":\"https://sqs.us-east-1.amazonaws.com/account-id/myQueue\",\"MessageBody.$\":\"$\"},\"End\":true}}}" \
--name "LambdaSQSIntegration" --role-arn "arn:aws:iam::account-id:role/service-role/LambdaSQSIntegration"
```
1. Jalankan mesin status menggunakan integrasi layanan tiruan.
Untuk menggunakan file konfigurasi tiruan, lakukan panggilan `[StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html)` API pada mesin status yang dikonfigurasi dalam file konfigurasi tiruan. Untuk melakukan ini, tambahkan sufiks,`#test_name`, ke mesin negara ARN yang digunakan oleh. `StartExecution` `test_name`adalah kasus uji, yang dikonfigurasi untuk mesin status dalam file konfigurasi tiruan yang sama.
Perintah berikut adalah contoh yang menggunakan `LambdaSQSIntegration` state machine dan konfigurasi tiruan. Dalam contoh ini, mesin `LambdaSQSIntegration` status dijalankan menggunakan `HappyPath` pengujian yang didefinisikan dalam[Langkah 1: Tentukan Integrasi Layanan Mocked dalam File Konfigurasi Mock](#create-mock-config-file). `HappyPath`Pengujian berisi konfigurasi eksekusi untuk menangani panggilan integrasi layanan tiruan yang `LambdaState` dan `SQSState` status lakukan menggunakan respons layanan yang diejek `MockedLambdaSuccess` dan `MockedSQSSuccess` diejek.
```
aws stepfunctions start-execution \
--endpoint http://localhost:8083 \
--name executionWithHappyPathMockedServices \
--state-machine arn:aws:states:region:account-id:stateMachine:LambdaSQSIntegration#HappyPath
```
1. Lihat respons eksekusi mesin status.
Respons terhadap panggilan `StartExecution` menggunakan uji integrasi layanan tiruan sama dengan respons terhadap panggilan `StartExecution` secara normal, yang mengembalikan ARN eksekusi dan tanggal mulai.
Berikut ini adalah contoh respons untuk memanggil `StartExecution` menggunakan uji integrasi layanan tiruan:
```
{
"startDate":"2022-01-28T15:03:16.981000-05:00",
"executionArn":"arn:aws:states:region:account-id:execution:LambdaSQSIntegration:executionWithHappyPathMockedServices"
}
```
1. Periksa hasil eksekusi dengan melakukan panggilan`[ListExecutions](https://docs.aws.amazon.com/step-functions/latest/apireference/API_ListExecutions.html)`,`[DescribeExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_DescribeExecution.html)`, atau `[GetExecutionHistory](https://docs.aws.amazon.com/step-functions/latest/apireference/API_GetExecutionHistory.html)` API.
```
aws stepfunctions get-execution-history \
--endpoint http://localhost:8083 \
--execution-arn arn:aws:states:region:account-id:execution:LambdaSQSIntegration:executionWithHappyPathMockedServices
```
Contoh berikut menunjukkan bagian dari respon untuk memanggil `GetExecutionHistory` menggunakan ARN eksekusi dari contoh respon yang ditunjukkan pada langkah 2. Dalam contoh ini, output dari `LambdaState` dan `SQSState` adalah data tiruan yang didefinisikan dalam `MockedLambdaSuccess` dan `MockedSQSSuccess` dalam file [konfigurasi tiruan](#create-mock-config-file). Selain itu, data tiruan digunakan dengan cara yang sama seperti data yang dikembalikan dengan melakukan panggilan integrasi layanan aktual akan digunakan. Juga, dalam contoh ini, output dari `LambdaState` diteruskan ke `SQSState` sebagai input.
```
{
"events": [
...
{
"timestamp": "2021-12-02T19:39:48.988000+00:00",
"type": "TaskStateEntered",
"id": 2,
"previousEventId": 0,
"stateEnteredEventDetails": {
"name": "LambdaState",
"input": "{}",
"inputDetails": {
"truncated": false
}
}
},
...
{
"timestamp": "2021-11-25T23:39:10.587000+00:00",
"type": "LambdaFunctionSucceeded",
"id": 5,
"previousEventId": 4,
"lambdaFunctionSucceededEventDetails": {
"output": "{\"statusCode\":200,\"body\":\"\\\"Hello from Lambda!\\\"\"}",
"outputDetails": {
"truncated": false
}
}
},
...
"timestamp": "2021-12-02T19:39:49.464000+00:00",
"type": "TaskStateEntered",
"id": 7,
"previousEventId": 6,
"stateEnteredEventDetails": {
"name": "SQSState",
"input": "{\"statusCode\":200,\"body\":\"\\\"Hello from Lambda!\\\"\"}",
"inputDetails": {
"truncated": false
}
}
},
...
{
"timestamp": "2021-11-25T23:39:10.652000+00:00",
"type": "TaskSucceeded",
"id": 10,
"previousEventId": 9,
"taskSucceededEventDetails": {
"resourceType": "sqs",
"resource": "sendMessage",
"output": "{\"MD5OfMessageBody\":\"3bcb6e8e-7h85-4375-b0bc-1a59812c6e51\",\"MessageId\":\"3bcb6e8e-8b51-4375-b0bc-1a59812c6e51\"}",
"outputDetails": {
"truncated": false
}
}
},
...
]
}
```
## File konfigurasi untuk integrasi layanan tiruan di Step Functions
**Step Functions Lokal tidak didukung**
Step Functions Local **tidak** menyediakan paritas fitur dan **tidak** didukung.
Anda dapat mempertimbangkan solusi pihak ketiga yang meniru Step Functions untuk tujuan pengujian.
Sebagai alternatif dari Step Functions Local, Anda dapat menggunakan TestState API untuk menguji unit logika mesin status Anda sebelum menerapkan ke AWS akun Anda. Untuk informasi selengkapnya, lihat [Menguji mesin status dengan TestState API](https://docs.aws.amazon.com/step-functions/latest/dg/test-state-isolation.html).
Untuk menggunakan integrasi layanan tiruan, Anda harus terlebih dahulu membuat file konfigurasi tiruan bernama `MockConfigFile.json` berisi konfigurasi tiruan Anda. Kemudian berikan Step Functions Local dengan file konfigurasi tiruan. File konfigurasi ini mendefinisikan kasus uji, yang berisi status tiruan yang menggunakan respons integrasi layanan tiruan. Bagian berikut berisi informasi tentang struktur konfigurasi tiruan yang mencakup status tiruan dan tanggapan yang diejek:
### Struktur file konfigurasi tiruan
Konfigurasi tiruan adalah objek JSON yang berisi bidang tingkat atas berikut:
+ `StateMachines`- Bidang objek ini mewakili mesin negara yang dikonfigurasi untuk menggunakan integrasi layanan tiruan.
+ `MockedResponse`- Bidang objek ini mewakili tanggapan yang diejek untuk panggilan integrasi layanan.
Berikut ini adalah contoh file konfigurasi tiruan yang mencakup `StateMachine` definisi dan`MockedResponse`.
```
{
"StateMachines":{
"LambdaSQSIntegration":{
"TestCases":{
"HappyPath":{
"LambdaState":"MockedLambdaSuccess",
"SQSState":"MockedSQSSuccess"
},
"RetryPath":{
"LambdaState":"MockedLambdaRetry",
"SQSState":"MockedSQSSuccess"
},
"HybridPath":{
"LambdaState":"MockedLambdaSuccess"
}
}
}
},
"MockedResponses":{
"MockedLambdaSuccess":{
"0":{
"Return":{
"StatusCode":200,
"Payload":{
"StatusCode":200,
"body":"Hello from Lambda!"
}
}
}
},
"LambdaMockedResourceNotReady":{
"0":{
"Throw":{
"Error":"Lambda.ResourceNotReadyException",
"Cause":"Lambda resource is not ready."
}
}
},
"MockedSQSSuccess":{
"0":{
"Return":{
"MD5OfMessageBody":"3bcb6e8e-7h85-4375-b0bc-1a59812c6e51",
"MessageId":"3bcb6e8e-8b51-4375-b0bc-1a59812c6e51"
}
}
},
"MockedLambdaRetry":{
"0":{
"Throw":{
"Error":"Lambda.ResourceNotReadyException",
"Cause":"Lambda resource is not ready."
}
},
"1-2":{
"Throw":{
"Error":"Lambda.TimeoutException",
"Cause":"Lambda timed out."
}
},
"3":{
"Return":{
"StatusCode":200,
"Payload":{
"StatusCode":200,
"body":"Hello from Lambda!"
}
}
}
}
}
}
```
#### Referensi bidang konfigurasi tiruan
Bagian berikut menjelaskan bidang objek tingkat atas yang harus Anda tentukan dalam konfigurasi tiruan Anda.
+ [StateMachines](#mock-cfg-sm-sect)
+ [MockedResponses](#mock-cfg-mckd-resp-sect)
##### StateMachines
`StateMachines`Objek mendefinisikan mesin negara mana yang akan menggunakan integrasi layanan tiruan. Konfigurasi untuk setiap mesin negara direpresentasikan sebagai bidang tingkat `StateMachines` atas. Nama bidang adalah nama mesin negara dan nilai adalah objek yang berisi satu bidang bernama`TestCases`, yang bidangnya mewakili kasus uji mesin status tersebut.
Sintaks berikut menunjukkan mesin status dengan dua kasus uji:
```
"MyStateMachine": {
"TestCases": {
"HappyPath": {
...
},
"SadPath": {
...
}
}
```
##### TestCases
Bidang `TestCases` mewakili kasus uji individu untuk mesin negara. Nama setiap kasus uji harus unik per mesin negara dan nilai setiap kasus uji adalah objek yang menentukan respons tiruan untuk digunakan untuk status Tugas di mesin status.
Contoh berikut dari `TestCase` link dua `Task` negara ke dua`MockedResponses`:
```
"HappyPath": {
"SomeTaskState": "SomeMockedResponse",
"AnotherTaskState": "AnotherMockedResponse"
}
```
##### MockedResponses
`MockedResponses`adalah objek yang berisi beberapa objek respons yang diejek dengan nama bidang yang unik. Objek respons yang diejek mendefinisikan hasil yang berhasil atau keluaran kesalahan untuk setiap pemanggilan status Tugas yang diejek. Anda menentukan nomor pemanggilan menggunakan string integer individual, seperti “0", “1", “2", dan “3" atau rentang bilangan bulat inklusif, seperti “0-1", “2-3”.
Saat Anda mengejek Tugas, Anda harus menentukan respons yang diejek untuk setiap pemanggilan. Respons harus berisi satu bidang bernama `Return` atau `Throw` yang nilainya adalah hasil atau keluaran kesalahan untuk pemanggilan Tugas yang diejek. Jika Anda tidak menentukan respons yang diejek, eksekusi mesin status akan gagal.
Berikut ini adalah contoh dari `MockedResponse` dengan `Throw` dan `Return` objek. Dalam contoh ini, tiga kali pertama mesin status dijalankan, respons yang `"0-2"` ditentukan dalam dikembalikan, dan keempat kalinya mesin status berjalan, respons yang `"3"` ditentukan dalam dikembalikan.
```
"SomeMockedResponse": {
"0-2": {
"Throw": {
...
}
},
"3": {
"Return": {
...
}
}
}
```
**catatan**
Jika Anda menggunakan `Map` status, dan ingin memastikan respons yang dapat diprediksi untuk `Map` status tersebut, tetapkan nilainya `maxConcurrency` menjadi 1. Jika Anda menetapkan nilai lebih besar dari 1, Step Functions Local akan menjalankan beberapa iterasi secara bersamaan, yang akan menyebabkan urutan eksekusi keseluruhan status di seluruh iterasi menjadi tidak dapat diprediksi. Hal ini selanjutnya dapat menyebabkan Step Functions Local menggunakan respons tiruan yang berbeda untuk status iterasi dari satu eksekusi ke eksekusi berikutnya.
##### Nilai yang ditampilkan
`Return`direpresentasikan sebagai bidang `MockedResponse` objek. Ini menentukan hasil sukses dari status Tugas yang diejek.
Berikut ini adalah contoh `Return` objek yang berisi respons ejekan untuk memanggil [https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html)fungsi Lambda:
```
"Return": {
"StatusCode": 200,
"Payload": {
"StatusCode": 200,
"body": "Hello from Lambda!"
}
}
```
##### Lempar
`Throw`direpresentasikan sebagai bidang `MockedResponse` objek. Ini menentukan [output kesalahan](concepts-error-handling.md) dari Tugas gagal. Nilai `Throw` harus berupa objek yang berisi `Error` dan `Cause` bidang dengan nilai string. Selain itu, nilai string yang Anda tentukan di `Error` bidang di `MockConfigFile.json` harus cocok dengan kesalahan yang ditangani di `Retry` dan `Catch` bagian mesin status Anda.
Berikut ini adalah contoh `Throw` objek yang berisi respons ejekan untuk memanggil [https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html)fungsi Lambda:
```
"Throw": {
"Error": "Lambda.TimeoutException",
"Cause": "Lambda timed out."
}
```