Today, I’m excited to announce enhanced local testing capabilities for AWS Step Functions through the TestState API, our testing API.
These enhancements are available through the API, so you can build automated test suites that validate your workflow definitions locally on your development machines, test error handling patterns, data transformations, and mock service integrations using your preferred testing frameworks. This launch introduces an API-based approach for local unit testing, providing programmatic access to comprehensive testing capabilities without deploying to Amazon Web Services (AWS).
There are three key capabilities introduced in this enhanced TestState API:
Mocking support – Mock state outputs and errors without invoking downstream services, enabling true unit testing of state machine logic. TestState validates mocked responses against AWS API models with three validation modes: STRICT (this is the default and validates all required fields), PRESENT (validates field types and names), and NONE (no validation), providing high-fidelity testing.
Support for all state types – All state types, including advanced states such as Map states (inline and distributed), Parallel states, activity-based Task states, .sync service integration patterns, and .waitForTaskToken service integration patterns, can now be tested. This means you can use TestState API across your entire workflow definition and write unit tests to verify control flow logic, including state transitions, error handling, and data transformations.
Testing individual states – Test specific states within a full state machine definition using the new stateName parameter. You can provide the complete state machine definition one time and test each state individually by name. You can control execution context to test specific retry attempts, Map iteration positions, and error scenarios.
Getting started with enhanced TestState
Let me walk you through these new capabilities in enhanced TestState.
Scenario 1: Mock successful results
The first capability is mocking support, which you can use to test your workflow logic without invoking actual AWS services or even external HTTP requests. You can either mock service responses for fast unit testing or test with actual AWS services for integration testing. When using mocked responses, you don’t need AWS Identity and Access Management (IAM) permissions.
Here’s how to mock a successful AWS Lambda function response:
aws stepfunctions test-state --region us-east-1
--definition '{
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Parameters": {"FunctionName": "process-order"},
"End": true
}'
--mock '{"result":"{"orderId":"12345","status":"processed"}"}'
--inspection-level DEBUG
This command tests a Lambda invocation state without actually calling the function. TestState validates your mock response against the Lambda service API model so your test data matches what the real service would return.
The response shows the successful execution with detailed inspection data (when using DEBUG inspection level):
{
"output": "{"orderId":"12345","status":"processed"}",
"inspectionData": {
"input": "{}",
"afterInputPath": "{}",
"afterParameters": "{"FunctionName":"process-order"}",
"result": "{"orderId":"12345","status":"processed"}",
"afterResultSelector": "{"orderId":"12345","status":"processed"}",
"afterResultPath": "{"orderId":"12345","status":"processed"}"
},
"status": "SUCCEEDED"
}
When you specify a mock response, TestState validates it against the AWS service’s API model so your mocked data conforms to the expected schema, maintaining high-fidelity testing without requiring actual AWS service calls.
Scenario 2: Mock error conditions
You can also mock error conditions to test your error handling logic:
aws stepfunctions test-state --region us-east-1
--definition '{
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Parameters": {"FunctionName": "process-order"},
"End": true
}'
--mock '{"errorOutput":{"error":"Lambda.ServiceException","cause":"Function failed"}}'
--inspection-level DEBUG
This simulates a Lambda service exception so you can verify how your state machine handles failures without triggering actual errors in your AWS environment.
The response shows the failed execution with error details:
{
"error": "Lambda.ServiceException",
"cause": "Function failed",
"inspectionData": {
"input": "{}",
"afterInputPath": "{}",
"afterParameters": "{"FunctionName":"process-order"}"
},
"status": "FAILED"
}
Scenario 3: Test Map states
The second capability adds support for previously unsupported state types. Here’s how to test a Distributed Map state:
aws stepfunctions test-state --region us-east-1
--definition '{
"Type": "Map",
"ItemProcessor": {
"ProcessorConfig": {"Mode": "DISTRIBUTED", "ExecutionType": "STANDARD"},
"StartAt": "ProcessItem",
"States": {
"ProcessItem": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Parameters": {"FunctionName": "process-item"},
"End": true
}
}
},
"End": true
}'
--input '[{"itemId":1},{"itemId":2}]'
--mock '{"result":"[{"itemId":1,"status":"processed"},{"itemId":2,"status":"processed"}]"}'
--inspection-level DEBUG
The mock result represents the complete output from processing multiple items. In this case, the mocked array must match the expected Map state output format.
The response shows successful processing of the array input:
{
"output": "[{"itemId":1,"status":"processed"},{"itemId":2,"status":"processed"}]",
"inspectionData": {
"input": "[{"itemId":1},{"itemId":2}]",
"afterInputPath": "[{"itemId":1},{"itemId":2}]",
"afterResultSelector": "[{"itemId":1,"status":"processed"},{"itemId":2,"status":"processed"}]",
"afterResultPath": "[{"itemId":1,"status":"processed"},{"itemId":2,"status":"processed"}]"
},
"status": "SUCCEEDED"
}
Scenario 4: Test Parallel states
Similarly, you can test Parallel states that execute multiple branches concurrently:
aws stepfunctions test-state --region us-east-1
--definition '{
"Type": "Parallel",
"Branches": [
{"StartAt": "Branch1", "States": {"Branch1": {"Type": "Pass", "End": true}}},
{"StartAt": "Branch2", "States": {"Branch2": {"Type": "Pass", "End": true}}}
],
"End": true
}'
--mock '{"result":"[{"branch1":"data1"},{"branch2":"data2"}]"}'
--inspection-level DEBUG
The mock result must be an array with one element per branch. By using TestState, your mock data structure matches what a real Parallel state execution would produce.
The response shows the parallel execution results:
{
"output": "[{"branch1":"data1"},{"branch2":"data2"}]",
"inspectionData": {
"input": "{}",
"afterResultSelector": "[{"branch1":"data1"},{"branch2":"data2"}]",
"afterResultPath": "[{"branch1":"data1"},{"branch2":"data2"}]"
},
"status": "SUCCEEDED"
}
Scenario 5: Test individual states within complete workflows
You can test specific states within a full state machine definition using the stateName parameter. Here’s an example testing a single state, though you would typically provide your complete workflow definition and specify which state to test:
aws stepfunctions test-state --region us-east-1
--definition '{
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Parameters": {"FunctionName": "validate-order"},
"End": true
}'
--input '{"orderId":"12345","amount":99.99}'
--mock '{"result":"{"orderId":"12345","validated":true}"}'
--inspection-level DEBUG
This tests a Lambda invocation state with specific input data, showing how TestState processes the input and transforms it through the state execution.
The response shows detailed input processing and validation:
{
"output": "{"orderId":"12345","validated":true}",
"inspectionData": {
"input": "{"orderId":"12345","amount":99.99}",
"afterInputPath": "{"orderId":"12345","amount":99.99}",
"afterParameters": "{"FunctionName":"validate-order"}",
"result": "{"orderId":"12345","validated":true}",
"afterResultSelector": "{"orderId":"12345","validated":true}",
"afterResultPath": "{"orderId":"12345","validated":true}"
},
"status": "SUCCEEDED"
}
These enhancements bring the familiar local development experience to Step Functions workflows, helping me to get instant feedback on changes before deploying to my AWS account. I can write automated test suites to validate all Step Functions features with the same reliability as cloud execution, providing confidence that my workflows will work as expected when deployed.
Things to know
Here are key points to note:
Get started today with enhanced local testing by integrating TestState into your development workflow.
Happy building!
— Donnie
Source: AWS News