Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

fix(stepfunctions): resolve state machine alias ARNs (#3607)

Aniket Shuklae82836348b17
diff --git a/docs/services/step-functions.md b/docs/services/step-functions.md
index fd8cf85616..de6e2a87f9 100644
--- a/docs/services/step-functions.md
+++ b/docs/services/step-functions.md
@@ -16,6 +16,11 @@
| `PublishStateMachineVersion` | - |
| `ListStateMachineVersions` | - |
| `DeleteStateMachineVersion` | - |
+| `CreateStateMachineAlias` | - |
+| `DescribeStateMachineAlias` | - |
+| `ListStateMachineAliases` | - |
+| `UpdateStateMachineAlias` | - |
+| `DeleteStateMachineAlias` | - |
| `ValidateStateMachineDefinition` | Validate an ASL definition without creating a state machine |
| `StartExecution` | Start a new execution |
| `StartSyncExecution` | - |
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonHandler.java
index 11b57b8faf..368b000c3d 100644
--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonHandler.java
+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsJsonHandler.java
@@ -2,6 +2,7 @@ package io.github.hectorvent.floci.services.stepfunctions;
import io.github.hectorvent.floci.core.common.AwsErrorResponse;
import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.common.PaginatedResult;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
@@ -11,7 +12,9 @@ import io.github.hectorvent.floci.services.stepfunctions.model.ActivityTask;
import io.github.hectorvent.floci.services.stepfunctions.model.Execution;
import io.github.hectorvent.floci.services.stepfunctions.model.HistoryEvent;
import io.github.hectorvent.floci.services.stepfunctions.model.MapRun;
+import io.github.hectorvent.floci.services.stepfunctions.model.RoutingConfiguration;
import io.github.hectorvent.floci.services.stepfunctions.model.StateMachine;
+import io.github.hectorvent.floci.services.stepfunctions.model.StateMachineAlias;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.ws.rs.core.Response;
@@ -45,6 +48,11 @@ public class StepFunctionsJsonHandler {
case "PublishStateMachineVersion" -> handlePublishStateMachineVersion(request);
case "ListStateMachineVersions" -> handleListStateMachineVersions(request);
case "DeleteStateMachineVersion" -> handleDeleteStateMachineVersion(request);
+ case "CreateStateMachineAlias" -> handleCreateStateMachineAlias(request);
+ case "DescribeStateMachineAlias" -> handleDescribeStateMachineAlias(request);
+ case "ListStateMachineAliases" -> handleListStateMachineAliases(request);
+ case "UpdateStateMachineAlias" -> handleUpdateStateMachineAlias(request);
+ case "DeleteStateMachineAlias" -> handleDeleteStateMachineAlias(request);
case "ValidateStateMachineDefinition" -> handleValidateStateMachineDefinition(request);
case "StartExecution" -> handleStartExecution(request, region);
case "StartSyncExecution" -> handleStartSyncExecution(request, region);
@@ -159,6 +167,77 @@ public class StepFunctionsJsonHandler {
return Response.ok(objectMapper.createObjectNode()).build();
}
+ private Response handleCreateStateMachineAlias(JsonNode request) {
+ StateMachineAlias alias = service.createStateMachineAlias(
+ requiredText(request, "name"),
+ optionalText(request, "description"),
+ parseRoutingConfiguration(request, true));
+ ObjectNode response = objectMapper.createObjectNode();
+ response.put("stateMachineAliasArn", alias.getStateMachineAliasArn());
+ response.put("creationDate", alias.getCreationDate());
+ return Response.ok(response).build();
+ }
+
+ private Response handleDescribeStateMachineAlias(JsonNode request) {
+ StateMachineAlias alias = service.describeStateMachineAlias(
+ requiredText(request, "stateMachineAliasArn"));
+ return Response.ok(aliasResponse(alias)).build();
+ }
+
+ private Response handleListStateMachineAliases(JsonNode request) {
+ Integer maxResults = request.hasNonNull("maxResults")
+ ? request.path("maxResults").asInt() : null;
+ PaginatedResult<StateMachineAlias> page = service.listStateMachineAliases(
+ requiredText(request, "stateMachineArn"),
+ maxResults,
+ optionalText(request, "nextToken"));
+ ObjectNode response = objectMapper.createObjectNode();
+ ArrayNode array = response.putArray("stateMachineAliases");
+ for (StateMachineAlias alias : page.items()) {
+ ObjectNode item = array.addObject();
+ item.put("stateMachineAliasArn", alias.getStateMachineAliasArn());
+ item.put("creationDate", alias.getCreationDate());
+ }
+ if (page.nextToken() != null) {
+ response.put("nextToken", page.nextToken());
+ }
+ return Response.ok(response).build();
+ }
+
+ private Response handleUpdateStateMachineAlias(JsonNode request) {
+ boolean descriptionProvided = request.has("description");
+ StateMachineAlias alias = service.updateStateMachineAlias(
+ requiredText(request, "stateMachineAliasArn"),
+ optionalText(request, "description"),
+ descriptionProvided,
+ parseRoutingConfiguration(request, false));
+ return Response.ok(objectMapper.createObjectNode()
+ .put("updateDate", alias.getUpdateDate())).build();
+ }
+
+ private Response handleDeleteStateMachineAlias(JsonNode request) {
+ service.deleteStateMachineAlias(requiredText(request, "stateMachineAliasArn"));
+ return Response.ok(objectMapper.createObjectNode()).build();
+ }
+
+ private ObjectNode aliasResponse(StateMachineAlias alias) {
+ ObjectNode response = objectMapper.createObjectNode();
+ response.put("stateMachineAliasArn", alias.getStateMachineAliasArn());
+ response.put("name", alias.getName());
+ if (alias.getDescription() != null) {
+ response.put("description", alias.getDescription());
+ }
+ ArrayNode routing = response.putArray("routingConfiguration");
+ for (RoutingConfiguration route : alias.getRoutingConfiguration()) {
+ ObjectNode item = routing.addObject();
+ item.put("stateMachineVersionArn", route.getStateMachineVersionArn());
+ item.put("weight", route.getWeight());
+ }
+ response.put("creationDate", alias.getCreationDate());
+ response.put("updateDate", alias.getUpdateDate());
+ return response;
+ }
+
private Response handleDescribeStateMachine(JsonNode request) {
String includedData = optionalText(request, "includedData");
if (includedData != null
@@ -265,6 +344,12 @@ public class StepFunctionsJsonHandler {
ObjectNode response = objectMapper.createObjectNode();
response.put("executionArn", exec.getExecutionArn());
response.put("stateMachineArn", exec.getStateMachineArn());
+ if (exec.getStateMachineVersionArn() != null) {
+ response.put("stateMachineVersionArn", exec.getStateMachineVersionArn());
+ }
+ if (exec.getStateMachineAliasArn() != null) {
+ response.put("stateMachineAliasArn", exec.getStateMachineAliasArn());
+ }
response.put("name", exec.getName());
response.put("status", exec.getStatus());
response.put("startDate", exec.getStartDate());
@@ -281,6 +366,12 @@ public class StepFunctionsJsonHandler {
ObjectNode response = objectMapper.createObjectNode();
response.put("executionArn", exec.getExecutionArn());
response.put("stateMachineArn", exec.getStateMachineArn());
+ if (exec.getStateMachineVersionArn() != null) {
+ response.put("stateMachineVersionArn", exec.getStateMachineVersionArn());
+ }
+ if (exec.getStateMachineAliasArn() != null) {
+ response.put("stateMachineAliasArn", exec.getStateMachineAliasArn());
+ }
response.put("name", exec.getName());
response.put("status", exec.getStatus());
response.put("startDate", exec.getStartDate());
@@ -346,6 +437,12 @@ public class StepFunctionsJsonHandler {
ObjectNode item = array.addObject();
item.put("executionArn", e.getExecutionArn());
item.put("stateMachineArn", e.getStateMachineArn());
+ if (e.getStateMachineVersionArn() != null) {
+ item.put("stateMachineVersionArn", e.getStateMachineVersionArn());
+ }
+ if (e.getStateMachineAliasArn() != null) {
+ item.put("stateMachineAliasArn", e.getStateMachineAliasArn());
+ }
item.put("name", e.getName());
item.put("status", e.getStatus());
item.put("startDate", e.getStartDate());
@@ -527,6 +624,40 @@ public class StepFunctionsJsonHandler {
return tags;
}
+ private List<RoutingConfiguration> parseRoutingConfiguration(
+ JsonNode request, boolean required) {
+ JsonNode routingNode = request.get("routingConfiguration");
+ if (routingNode == null || routingNode.isNull()) {
+ if (required) {
+ throw new AwsException(
+ "MissingRequiredParameter", "routingConfiguration is required.", 400);
+ }
+ return null;
+ }
+ if (!routingNode.isArray()) {
+ throw new AwsException(
+ "ValidationException", "routingConfiguration must be a list.", 400);
+ }
+ List<RoutingConfiguration> routing = new ArrayList<>();
+ for (JsonNode item : routingNode) {
+ if (!item.isObject()) {
+ throw new AwsException(
+ "ValidationException",
+ "routingConfiguration entries must be objects.", 400);
+ }
+ String versionArn = requiredText(item, "stateMachineVersionArn");
+ JsonNode weightNode = item.get("weight");
+ if (weightNode == null || weightNode.isNull()) {
+ throw new AwsException("MissingRequiredParameter", "weight is required.", 400);
+ }
+ if (!weightNode.isIntegralNumber()) {
+ throw new AwsException("ValidationException", "weight must be an integer.", 400);
+ }
+ routing.add(new RoutingConfiguration(versionArn, weightNode.intValue()));
+ }
+ return routing;
+ }
+
private static String requiredText(JsonNode request, String fieldName) {
JsonNode node = request.get(fieldName);
if (node == null || node.isNull()) {
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsService.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsService.java
index 4c4b2aa803..8d7a83a223 100644
--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsService.java
@@ -3,6 +3,8 @@ package io.github.hectorvent.floci.services.stepfunctions;
import io.github.hectorvent.floci.core.common.AwsArnUtils;
import io.github.hectorvent.floci.core.common.AwsException;
import io.github.hectorvent.floci.core.common.AwsRegions;
+import io.github.hectorvent.floci.core.common.PaginatedResult;
+import io.github.hectorvent.floci.core.common.Pagination;
import io.github.hectorvent.floci.core.common.RegionResolver;
import io.github.hectorvent.floci.core.resource.ExplorerResource;
import io.github.hectorvent.floci.core.resource.ResourceProvider;
@@ -19,7 +21,9 @@ import io.github.hectorvent.floci.services.stepfunctions.model.Execution;
import io.github.hectorvent.floci.services.stepfunctions.model.HistoryEvent;
import io.github.hectorvent.floci.services.stepfunctions.model.MapRun;
import io.github.hectorvent.floci.services.stepfunctions.model.MockedTestCase;
+import io.github.hectorvent.floci.services.stepfunctions.model.RoutingConfiguration;
import io.github.hectorvent.floci.services.stepfunctions.model.StateMachine;
+import io.github.hectorvent.floci.services.stepfunctions.model.StateMachineAlias;
import io.github.hectorvent.floci.services.stepfunctions.model.StateMachineVersion;
import io.github.hectorvent.floci.core.common.Resettable;
import jakarta.enterprise.context.ApplicationScoped;
@@ -34,6 +38,7 @@ import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@@ -46,6 +51,7 @@ public class StepFunctionsService implements Resettable, ResourceProvider {
private static final int HISTORY_PERSIST_CHECKPOINT = 100;
private final StorageBackend<String, StateMachine> stateMachineStore;
+ private final StorageBackend<String, StateMachineAlias> stateMachineAliasStore;
// Account-aware: the startup sweep has no request context and must reach every account.
private final AccountAwareStorageBackend<Execution> executionStore;
private final StorageBackend<String, Activity> activityStore;
@@ -128,6 +134,11 @@ public class StepFunctionsService implements Resettable, ResourceProvider {
new TypeReference<Map<String, Activity>>() {});
this.mapRunStore = storageFactory.create("stepfunctions", "sfn-map-runs.json",
new TypeReference<Map<String, MapRun>>() {});
+ // Keep the established state-machine/execution/activity/map-run factory order stable for
+ // embedders and tests that supply sequential backends. New stores are appended.
+ this.stateMachineAliasStore = storageFactory.create(
+ "stepfunctions", "sfn-state-machine-aliases.json",
+ new TypeReference<Map<String, StateMachineAlias>>() {});
this.regionResolver = regionResolver;
this.aslExecutor = aslExecutor;
this.objectMapper = objectMapper;
@@ -419,23 +430,34 @@ public class StepFunctionsService implements Resettable, ResourceProvider {
return copyStateMachine(stateMachine.get());
}
- VersionArn parsedVersion = parseVersionArn(arn);
- if (parsedVersion != null) {
- Optional<StateMachine> baseStateMachine = stateMachineStore.get(parsedVersion.baseArn());
- if (baseStateMachine.isPresent()) {
- return baseStateMachine.get().getVersions().stream()
- .filter(version -> arn.equals(version.getStateMachineVersionArn()))
- .findFirst()
- .map(version -> stateMachineFromVersion(baseStateMachine.get(), version))
- .orElseThrow(() -> new AwsException(
- "StateMachineDoesNotExist",
- "State machine does not exist", 400));
+ QualifiedStateMachineArn qualifiedArn = parseQualifiedStateMachineArn(arn);
+ if (qualifiedArn != null) {
+ String versionArn = qualifiedArn.isVersion()
+ ? arn
+ : stateMachineAliasStore.get(arn)
+ .map(alias -> alias.getRoutingConfiguration().get(0)
+ .getStateMachineVersionArn())
+ .orElse(null);
+ if (versionArn != null) {
+ return describeStateMachineVersion(qualifiedArn.baseArn(), versionArn);
}
}
throw new AwsException(
"StateMachineDoesNotExist", "State machine does not exist", 400);
}
+ private StateMachine describeStateMachineVersion(String baseArn, String versionArn) {
+ StateMachine baseStateMachine = stateMachineStore.get(baseArn)
+ .orElseThrow(() -> new AwsException(
+ "StateMachineDoesNotExist", "State machine does not exist", 400));
+ return baseStateMachine.getVersions().stream()
+ .filter(version -> versionArn.equals(version.getStateMachineVersionArn()))
+ .findFirst()
+ .map(version -> stateMachineFromVersion(baseStateMachine, version))
+ .orElseThrow(() -> new AwsException(
+ "StateMachineDoesNotExist", "State machine does not exist", 400));
+ }
+
/**
* Key prefix matching every Step Functions ARN in {@code region}. This store is keyed by the
* full ARN, unlike the other services, which key by {@code region::name}, so the prefix has to
@@ -513,12 +535,148 @@ public class StepFunctionsService implements Resettable, ResourceProvider {
return List.copyOf(versions);
}
+ // ── State machine aliases ───────────────────────────────────────────────
+
+ public synchronized StateMachineAlias createStateMachineAlias(
+ String name, String description, List<RoutingConfiguration> routingConfiguration) {
+ validateStateMachineAliasName(name);
+ validateAliasDescription(description);
+ String stateMachineArn = validateRoutingConfiguration(routingConfiguration);
+ String aliasArn = stateMachineArn + ":" + name;
+
+ Optional<StateMachineAlias> existing = stateMachineAliasStore.get(aliasArn);
+ if (existing.isPresent()) {
+ StateMachineAlias alias = existing.get();
+ if (Objects.equals(description, alias.getDescription())
+ && routingConfigurationsEqual(
+ routingConfiguration, alias.getRoutingConfiguration())) {
+ return copyAlias(alias);
+ }
+ throw new AwsException(
+ "ConflictException", "State machine alias already exists: " + aliasArn, 409);
+ }
+
+ StateMachineAlias alias = new StateMachineAlias();
+ alias.setStateMachineAliasArn(aliasArn);
+ alias.setStateMachineArn(stateMachineArn);
+ alias.setName(name);
+ alias.setDescription(description);
+ alias.setRoutingConfiguration(copyRoutingConfiguration(routingConfiguration));
+ stateMachineAliasStore.put(aliasArn, alias);
+ return copyAlias(alias);
+ }
+
+ public StateMachineAlias describeStateMachineAlias(String aliasArn) {
+ validateStateMachineAliasArn(aliasArn);
+ return stateMachineAliasStore.get(aliasArn)
+ .map(this::copyAlias)
+ .orElseThrow(() -> new AwsException(
+ "ResourceNotFound", "State machine alias does not exist: " + aliasArn, 400));
+ }
+
+ public List<StateMachineAlias> listStateMachineAliases(String stateMachineArn) {
+ return listStateMachineAliases(stateMachineArn, null, null).items();
+ }
+
+ public PaginatedResult<StateMachineAlias> listStateMachineAliases(
+ String stateMachineArn, Integer maxResults, String nextToken) {
+ QualifiedStateMachineArn qualifiedArn = parseQualifiedStateMachineArn(stateMachineArn);
+ String baseArn = qualifiedArn != null && qualifiedArn.isVersion()
+ ? qualifiedArn.baseArn() : stateMachineArn;
+ validateStateMachineArn(baseArn);
+ if (stateMachineStore.get(baseArn).isEmpty()) {
+ throw new AwsException(
+ "StateMachineDoesNotExist", "State machine does not exist: " + baseArn, 400);
+ }
+
+ List<StateMachineAlias> aliases = stateMachineAliasStore.scan(key -> key.startsWith(baseArn + ":"));
+ if (qualifiedArn != null) {
+ aliases.removeIf(alias -> alias.getRoutingConfiguration().stream()
+ .noneMatch(route -> stateMachineArn.equals(route.getStateMachineVersionArn())));
+ }
+ return Pagination.paginate(
+ aliases.stream().map(this::copyAlias).toList(),
+ StepFunctionsService::aliasPaginationCursor,
+ maxResults,
+ nextToken,
+ 100,
+ 1000,
+ "ValidationException");
+ }
+
+ private static String aliasPaginationCursor(StateMachineAlias alias) {
+ // ListStateMachineAliases is newest-first. Pagination sorts cursors ascending, so invert
+ // the millisecond timestamp and use the ARN to make aliases created together deterministic.
+ long creationMillis = (long) (alias.getCreationDate() * 1000);
+ return String.format(Locale.ROOT, "%020d:%s",
+ Long.MAX_VALUE - creationMillis, alias.getStateMachineAliasArn());
+ }
+
+ public synchronized StateMachineAlias updateStateMachineAlias(
+ String aliasArn,
+ String description,
+ boolean descriptionProvided,
+ List<RoutingConfiguration> routingConfiguration) {
+ validateStateMachineAliasArn(aliasArn);
+ if (!descriptionProvided && routingConfiguration == null) {
+ throw new AwsException(
+ "MissingRequiredParameter",
+ "Either description or routingConfiguration must be specified.", 400);
+ }
+ if (descriptionProvided) {
+ validateAliasDescription(description);
+ }
+ StateMachineAlias current = stateMachineAliasStore.get(aliasArn)
+ .orElseThrow(() -> new AwsException(
+ "ResourceNotFound", "State machine alias does not exist: " + aliasArn, 400));
+ if (routingConfiguration != null) {
+ String stateMachineArn = validateRoutingConfiguration(routingConfiguration);
+ if (!Objects.equals(current.getStateMachineArn(), stateMachineArn)) {
+ throw new AwsException(
+ "ValidationException",
+ "Alias routes must reference versions of the same state machine.", 400);
+ }
+ }
+
+ StateMachineAlias updated = copyAlias(current);
+ if (descriptionProvided) {
+ updated.setDescription(description);
+ }
+ if (routingConfiguration != null) {
+ updated.setRoutingConfiguration(copyRoutingConfiguration(routingConfiguration));
+ }
+ updated.setUpdateDate(System.currentTimeMillis() / 1000.0);
+ stateMachineAliasStore.put(aliasArn, updated);
+ return copyAlias(updated);
+ }
+
+ public synchronized void deleteStateMachineAlias(String aliasArn) {
+ validateStateMachineAliasArn(aliasArn);
+ if (stateMachineAliasStore.get(aliasArn).isEmpty()) {
+ throw new AwsException(
+ "ResourceNotFound", "State machine alias does not exist: " + aliasArn, 400);
+ }
+ stateMachineAliasStore.delete(aliasArn);
+ }
+
public synchronized void deleteStateMachineVersion(String stateMachineVersionArn) {
VersionArn parsed = parseVersionArn(stateMachineVersionArn);
if (parsed == null) {
return;
}
String baseArn = parsed.baseArn();
+ boolean referencedByAlias = stateMachineAliasStore.scan(
+ key -> key.startsWith(baseArn + ":")).stream()
+ .flatMap(alias -> alias.getRoutingConfiguration().stream())
+ .anyMatch(route -> stateMachineVersionArn.equals(
+ route.getStateMachineVersionArn()));
+ if (referencedByAlias) {
+ throw new AwsException(
+ "ConflictException",
+ "State machine version is referenced by an alias: "
+ + stateMachineVersionArn,
+ 409);
+ }
stateMachineStore.get(baseArn).ifPresent(current -> {
StateMachine updated = copyStateMachine(current);
updated.getVersions().removeIf(
@@ -530,6 +688,7 @@ public class StepFunctionsService implements Resettable, ResourceProvider {
public void deleteStateMachine(String arn) {
stateMachineStore.delete(arn);
+ deleteStateMachineAliases(arn);
}
public synchronized boolean deleteStateMachineIfRevisionMatches(
@@ -543,14 +702,23 @@ public class StepFunctionsService implements Resettable, ResourceProvider {
return false;
}
stateMachineStore.delete(arn);
+ deleteStateMachineAliases(arn);
return true;
}
+ private void deleteStateMachineAliases(String stateMachineArn) {
+ for (StateMachineAlias alias : stateMachineAliasStore.scan(
+ key -> key.startsWith(stateMachineArn + ":"))) {
+ stateMachineAliasStore.delete(alias.getStateMachineAliasArn());
+ }
+ }
+
// ──────────────────────────── Executions ────────────────────────────
public Execution startExecution(String stateMachineArn, String name, String input, String region) {
var selection = splitTestCaseSuffix(stateMachineArn);
- var sm = describeStateMachine(selection.stateMachineArn());
+ var resolved = resolveStateMachineForExecution(selection.stateMachineArn());
+ var sm = resolved.stateMachine();
var mockedTestCase = resolveMockedTestCase(sm, selection);
var execName = (name != null && !name.isBlank()) ? name : UUID.randomUUID().toString();
boolean express = "EXPRESS".equals(sm.getType());
@@ -583,7 +751,9 @@ public class StepFunctionsService implements Resettable, ResourceProvider {
exec = new Execution();
exec.setExecutionArn(arn);
- exec.setStateMachineArn(selection.stateMachineArn());
+ exec.setStateMachineArn(resolved.baseArn());
+ exec.setStateMachineVersionArn(resolved.versionArn());
+ exec.setStateMachineAliasArn(resolved.aliasArn());
exec.setName(execName);
exec.setInput(input);
exec.setStatus("RUNNING");
@@ -627,7 +797,8 @@ public class StepFunctionsService implements Resettable, ResourceProvider {
}
// A bare trailing '#' is not stripped on this operation: Step Functions Local looks up
// the raw ARN and fails with StateMachineDoesNotExist, so Floci does the same.
- var sm = describeStateMachine(stateMachineArn);
+ var resolved = resolveStateMachineForExecution(stateMachineArn);
+ var sm = resolved.stateMachine();
if (!"EXPRESS".equals(sm.getType())) {
throw new AwsException("StateMachineTypeNotSupported",
"StartSyncExecution is only supported for EXPRESS state machines", 400);
@@ -644,7 +815,9 @@ public class StepFunctionsService implements Resettable, ResourceProvider {
var exec = new Execution();
exec.setExecutionArn(arn);
- exec.setStateMachineArn(stateMachineArn);
+ exec.setStateMachineArn(resolved.baseArn());
+ exec.setStateMachineVersionArn(resolved.versionArn());
+ exec.setStateMachineAliasArn(resolved.aliasArn());
exec.setName(execName);
exec.setInput(input);
exec.setStatus("RUNNING");
@@ -669,6 +842,40 @@ public class StepFunctionsService implements Resettable, ResourceProvider {
private record TestCaseSelection(String stateMachineArn, String testCaseName) {
}
+ private record ResolvedStateMachine(
+ StateMachine stateMachine, String baseArn, String versionArn, String aliasArn) {
+ }
+
+ private ResolvedStateMachine resolveStateMachineForExecution(String arn) {
+ QualifiedStateMachineArn qualifiedArn = parseQualifiedStateMachineArn(arn);
+ if (qualifiedArn == null) {
+ return new ResolvedStateMachine(describeStateMachine(arn), arn, null, null);
+ }
+ if (qualifiedArn.isVersion()) {
+ return new ResolvedStateMachine(
+ describeStateMachine(arn), qualifiedArn.baseArn(), arn, null);
+ }
+
+ StateMachineAlias alias = stateMachineAliasStore.get(arn)
+ .orElseThrow(() -> new AwsException(
+ "StateMachineDoesNotExist", "State machine does not exist", 400));
+ int selection = ThreadLocalRandom.current().nextInt(100);
+ int cumulativeWeight = 0;
+ RoutingConfiguration selected = alias.getRoutingConfiguration()
+ .get(alias.getRoutingConfiguration().size() - 1);
+ for (RoutingConfiguration route : alias.getRoutingConfiguration()) {
+ cumulativeWeight += route.getWeight();
+ if (selection < cumulativeWeight) {
+ selected = route;
+ break;
+ }
+ }
+ String versionArn = selected.getStateMachineVersionArn();
+ return new ResolvedStateMachine(
+ describeStateMachineVersion(alias.getStateMachineArn(), versionArn),
+ alias.getStateMachineArn(), versionArn, arn);
+ }
+
/**
* Splits the Step Functions Local mocked service integration suffix off a
* {@code StartExecution} ARN: {@code <stateMachineArn>#<testCaseName>} selects the named
@@ -727,8 +934,15 @@ public class StepFunctionsService implements Resettable, ResourceProvider {
}
public List<Execution> listExecutions(String stateMachineArn) {
- return executionStore.scan(k -> executionStore.get(k)
- .map(e -> e.getStateMachineArn().equals(stateMachineArn)).orElse(false));
+ QualifiedStateMachineArn qualifiedArn = parseQualifiedStateMachineArn(stateMachineArn);
+ return executionStore.scan(k -> executionStore.get(k).map(execution -> {
+ if (qualifiedArn == null) {
+ return Objects.equals(execution.getStateMachineArn(), stateMachineArn);
+ }
+ return qualifiedArn.isVersion()
+ ? Objects.equals(execution.getStateMachineVersionArn(), stateMachineArn)
+ : Objects.equals(execution.getStateMachineAliasArn(), stateMachineArn);
+ }).orElse(false));
}
/**
@@ -1226,23 +1440,134 @@ public class StepFunctionsService implements Resettable, ResourceProvider {
return copy;
}
+ private StateMachineAlias copyAlias(StateMachineAlias source) {
+ StateMachineAlias copy = new StateMachineAlias();
+ copy.setStateMachineAliasArn(source.getStateMachineAliasArn());
+ copy.setStateMachineArn(source.getStateMachineArn());
+ copy.setName(source.getName());
+ copy.setDescription(source.getDescription());
+ copy.setRoutingConfiguration(copyRoutingConfiguration(
+ source.getRoutingConfiguration()));
+ copy.setCreationDate(source.getCreationDate());
+ copy.setUpdateDate(source.getUpdateDate());
+ return copy;
+ }
+
+ private static List<RoutingConfiguration> copyRoutingConfiguration(
+ List<RoutingConfiguration> routingConfiguration) {
+ List<RoutingConfiguration> copy = new ArrayList<>();
+ for (RoutingConfiguration route : routingConfiguration) {
+ copy.add(new RoutingConfiguration(
+ route.getStateMachineVersionArn(), route.getWeight()));
+ }
+ return copy;
+ }
+
+ private static boolean routingConfigurationsEqual(
+ List<RoutingConfiguration> left, List<RoutingConfiguration> right) {
+ if (left.size() != right.size()) {
+ return false;
+ }
+ for (int index = 0; index < left.size(); index++) {
+ RoutingConfiguration leftRoute = left.get(index);
+ RoutingConfiguration rightRoute = right.get(index);
+ if (leftRoute.getWeight() != rightRoute.getWeight()
+ || !Objects.equals(
+ leftRoute.getStateMachineVersionArn(),
+ rightRoute.getStateMachineVersionArn())) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private String validateRoutingConfiguration(
+ List<RoutingConfiguration> routingConfiguration) {
+ if (routingConfiguration == null
+ || routingConfiguration.isEmpty()
+ || routingConfiguration.size() > 2) {
+ throw new AwsException(
+ "ValidationException",
+ "routingConfiguration must contain one or two version targets.", 400);
+ }
+
+ String baseArn = null;
+ int totalWeight = 0;
+ Set<String> versionArns = new HashSet<>();
+ for (RoutingConfiguration route : routingConfiguration) {
+ if (route == null || route.getStateMachineVersionArn() == null) {
+ throw new AwsException(
+ "ValidationException",
+ "Each routingConfiguration entry must contain a stateMachineVersionArn.",
+ 400);
+ }
+ VersionArn versionArn = parseVersionArn(route.getStateMachineVersionArn());
+ if (versionArn == null) {
+ throw new AwsException(
+ "InvalidArn",
+ "Invalid state machine version ARN: "
+ + route.getStateMachineVersionArn(),
+ 400);
+ }
+ if (!versionArns.add(route.getStateMachineVersionArn())) {
+ throw new AwsException(
+ "ValidationException",
+ "routingConfiguration cannot contain a version more than once.", 400);
+ }
+ if (baseArn == null) {
+ baseArn = versionArn.baseArn();
+ } else if (!baseArn.equals(versionArn.baseArn())) {
+ throw new AwsException(
+ "ValidationException",
+ "Alias routes must reference versions of the same state machine.", 400);
+ }
+ if (route.getWeight() < 0 || route.getWeight() > 100) {
+ throw new AwsException(
+ "ValidationException", "Alias routing weights must be between 0 and 100.",
+ 400);
+ }
+ totalWeight += route.getWeight();
+ StateMachine stateMachine = stateMachineStore.get(versionArn.baseArn())
+ .orElseThrow(() -> new AwsException(
+ "ResourceNotFound",
+ "State machine version does not exist: "
+ + route.getStateMachineVersionArn(),
+ 400));
+ boolean versionExists = stateMachine.getVersions().stream()
+ .anyMatch(version -> route.getStateMachineVersionArn().equals(
+ version.getStateMachineVersionArn()));
+ if (!versionExists) {
+ throw new AwsException(
+ "ResourceNotFound",
+ "State machine version does not exist: "
+ + route.getStateMachineVersionArn(),
+ 400);
+ }
+ }
+ if (totalWeight != 100) {
+ throw new AwsException(
+ "ValidationException", "Alias routing weights must add up to 100.", 400);
+ }
+ return baseArn;
+ }
+
private static final String STATE_MACHINE_RESOURCE = "stateMachine";
+ private record QualifiedStateMachineArn(String baseArn, String qualifier) {
+ private boolean isVersion() {
+ return qualifier.chars().allMatch(Character::isDigit);
+ }
+ }
+
private record VersionArn(String baseArn, int version) {
}
/**
- * Splits a state machine <em>version</em> ARN into its base ARN and version number, or returns
- * {@code null} when {@code arn} is not one.
- *
- * <p>Decided by the shape of the resource, not by whether the tail happens to be digits. A
- * state machine ARN is {@code stateMachine:<name>} and a version ARN is
- * {@code stateMachine:<name>:<version>}, so the segment count settles it. Digits are legal in
- * a state machine name, and reading the tail alone meant a machine named {@code 2024} was
- * taken apart into version 2024 of a nameless ARN, which the caller then rejected as
- * InvalidArn: an existing state machine that could not be described.
+ * Splits either a version or alias ARN into the unqualified state-machine ARN and qualifier.
+ * A Distributed Map ARN uses {@code /label}, not a third colon segment, and is deliberately
+ * left to the operation-specific validation that returns AWS's {@code ValidationException}.
*/
- private static VersionArn parseVersionArn(String arn) {
+ private static QualifiedStateMachineArn parseQualifiedStateMachineArn(String arn) {
if (arn == null) {
return null;
}
@@ -1253,16 +1578,36 @@ public class StepFunctionsService implements Resettable, ResourceProvider {
return null;
}
String[] segments = parsed.resource().split(":", -1);
- if (segments.length != 3
+ if (!"states".equals(parsed.service())
+ || segments.length != 3
|| !STATE_MACHINE_RESOURCE.equals(segments[0])
- || segments[2].isEmpty()
- || !segments[2].chars().allMatch(Character::isDigit)) {
+ || segments[1].isEmpty()
+ || segments[2].isEmpty()) {
+ return null;
+ }
+ return new QualifiedStateMachineArn(
+ arn.substring(0, arn.length() - segments[2].length() - 1), segments[2]);
+ }
+
+ /**
+ * Splits a state machine <em>version</em> ARN into its base ARN and version number, or returns
+ * {@code null} when {@code arn} is not one.
+ *
+ * <p>Decided by the shape of the resource, not by whether the tail happens to be digits. A
+ * state machine ARN is {@code stateMachine:<name>} and a version ARN is
+ * {@code stateMachine:<name>:<version>}, so the segment count settles it. Digits are legal in
+ * a state machine name, and reading the tail alone meant a machine named {@code 2024} was
+ * taken apart into version 2024 of a nameless ARN, which the caller then rejected as
+ * InvalidArn: an existing state machine that could not be described.
+ */
+ private static VersionArn parseVersionArn(String arn) {
+ QualifiedStateMachineArn qualifiedArn = parseQualifiedStateMachineArn(arn);
+ if (qualifiedArn == null || !qualifiedArn.isVersion()) {
return null;
}
try {
return new VersionArn(
- arn.substring(0, arn.length() - segments[2].length() - 1),
- Integer.parseInt(segments[2]));
+ qualifiedArn.baseArn(), Integer.parseInt(qualifiedArn.qualifier()));
} catch (NumberFormatException ignored) {
return null;
}
@@ -1459,6 +1804,23 @@ public class StepFunctionsService implements Resettable, ResourceProvider {
}
}
+ private static void validateStateMachineAliasName(String name) {
+ if (name == null
+ || name.length() > 80
+ || !name.matches("(?=.*[A-Za-z_.-])[A-Za-z0-9_.-]+")) {
+ throw new AwsException(
+ "InvalidName", "Invalid state machine alias name: '" + name + "'", 400);
+ }
+ }
+
+ private static void validateAliasDescription(String description) {
+ if (description != null && description.length() > 256) {
+ throw new AwsException(
+ "ValidationException",
+ "State machine alias description must not exceed 256 characters.", 400);
+ }
+ }
+
private static void validateStateMachineArn(String arn) {
if (arn == null || arn.isBlank() || arn.length() > MAX_ARN_LENGTH) {
throw new AwsException("InvalidArn", "Invalid Arn: '" + arn + "'", 400);
@@ -1506,9 +1868,24 @@ public class StepFunctionsService implements Resettable, ResourceProvider {
throw new AwsException("InvalidArn", "Invalid Arn: '" + arn + "'", 400);
}
- VersionArn versionArn = parseVersionArn(arn);
+ QualifiedStateMachineArn qualifiedArn = parseQualifiedStateMachineArn(arn);
validateStateMachineArn(
- versionArn != null ? versionArn.baseArn() : arn);
+ qualifiedArn != null ? qualifiedArn.baseArn() : arn);
+ if (qualifiedArn != null && !qualifiedArn.isVersion()) {
+ validateStateMachineAliasName(qualifiedArn.qualifier());
+ }
+ }
+
+ private static void validateStateMachineAliasArn(String arn) {
+ if (arn == null || arn.isBlank() || arn.length() > MAX_ARN_LENGTH) {
+ throw new AwsException("InvalidArn", "Invalid Arn: '" + arn + "'", 400);
+ }
+ QualifiedStateMachineArn qualifiedArn = parseQualifiedStateMachineArn(arn);
+ if (qualifiedArn == null || qualifiedArn.isVersion()) {
+ throw new AwsException("InvalidArn", "Invalid Arn: '" + arn + "'", 400);
+ }
+ validateStateMachineArn(qualifiedArn.baseArn());
+ validateStateMachineAliasName(qualifiedArn.qualifier());
}
private static void validateUpdateStateMachineArn(String arn) {
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/Execution.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/Execution.java
index c54bad1714..77d4b2b25c 100644
--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/Execution.java
+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/Execution.java
@@ -11,6 +11,8 @@ import java.util.List;
public class Execution {
private String executionArn;
private String stateMachineArn;
+ private String stateMachineVersionArn;
+ private String stateMachineAliasArn;
private String name;
private String status = "RUNNING"; // RUNNING, SUCCEEDED, FAILED, TIMED_OUT, ABORTED
private String input;
@@ -31,6 +33,16 @@ public class Execution {
public String getStateMachineArn() { return stateMachineArn; }
public void setStateMachineArn(String stateMachineArn) { this.stateMachineArn = stateMachineArn; }
+ public String getStateMachineVersionArn() { return stateMachineVersionArn; }
+ public void setStateMachineVersionArn(String stateMachineVersionArn) {
+ this.stateMachineVersionArn = stateMachineVersionArn;
+ }
+
+ public String getStateMachineAliasArn() { return stateMachineAliasArn; }
+ public void setStateMachineAliasArn(String stateMachineAliasArn) {
+ this.stateMachineAliasArn = stateMachineAliasArn;
+ }
+
public String getName() { return name; }
public void setName(String name) { this.name = name; }
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/RoutingConfiguration.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/RoutingConfiguration.java
new file mode 100644
index 0000000000..13233d5c17
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/RoutingConfiguration.java
@@ -0,0 +1,28 @@
+package io.github.hectorvent.floci.services.stepfunctions.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+/** One weighted state-machine version target in an alias routing configuration. */
+@RegisterForReflection
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class RoutingConfiguration {
+ private String stateMachineVersionArn;
+ private int weight;
+
+ public RoutingConfiguration() {
+ }
+
+ public RoutingConfiguration(String stateMachineVersionArn, int weight) {
+ this.stateMachineVersionArn = stateMachineVersionArn;
+ this.weight = weight;
+ }
+
+ public String getStateMachineVersionArn() { return stateMachineVersionArn; }
+ public void setStateMachineVersionArn(String stateMachineVersionArn) {
+ this.stateMachineVersionArn = stateMachineVersionArn;
+ }
+
+ public int getWeight() { return weight; }
+ public void setWeight(int weight) { this.weight = weight; }
+}
diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/StateMachineAlias.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/StateMachineAlias.java
new file mode 100644
index 0000000000..4293584617
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/StateMachineAlias.java
@@ -0,0 +1,51 @@
+package io.github.hectorvent.floci.services.stepfunctions.model;
+
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import io.quarkus.runtime.annotations.RegisterForReflection;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/** A named pointer to one or two published versions of a state machine. */
+@RegisterForReflection
+@JsonIgnoreProperties(ignoreUnknown = true)
+public class StateMachineAlias {
+ private String stateMachineAliasArn;
+ private String stateMachineArn;
+ private String name;
+ private String description;
+ private List<RoutingConfiguration> routingConfiguration = new ArrayList<>();
+ private double creationDate;
+ private double updateDate;
+
+ public StateMachineAlias() {
+ creationDate = System.currentTimeMillis() / 1000.0;
+ updateDate = creationDate;
+ }
+
+ public String getStateMachineAliasArn() { return stateMachineAliasArn; }
+ public void setStateMachineAliasArn(String stateMachineAliasArn) {
+ this.stateMachineAliasArn = stateMachineAliasArn;
+ }
+
+ public String getStateMachineArn() { return stateMachineArn; }
+ public void setStateMachineArn(String stateMachineArn) { this.stateMachineArn = stateMachineArn; }
+
+ public String getName() { return name; }
+ public void setName(String name) { this.name = name; }
+
+ public String getDescription() { return description; }
+ public void setDescription(String description) { this.description = description; }
+
+ public List<RoutingConfiguration> getRoutingConfiguration() { return routingConfiguration; }
+ public void setRoutingConfiguration(List<RoutingConfiguration> routingConfiguration) {
+ this.routingConfiguration = routingConfiguration != null
+ ? routingConfiguration : new ArrayList<>();
+ }
+
+ public double getCreationDate() { return creationDate; }
+ public void setCreationDate(double creationDate) { this.creationDate = creationDate; }
+
+ public double getUpdateDate() { return updateDate; }
+ public void setUpdateDate(double updateDate) { this.updateDate = updateDate; }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsAliasesIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsAliasesIntegrationTest.java
new file mode 100644
index 0000000000..3b201b603a
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsAliasesIntegrationTest.java
@@ -0,0 +1,193 @@
+package io.github.hectorvent.floci.services.stepfunctions;
+
+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;
+import io.quarkus.test.junit.QuarkusTest;
+import io.restassured.response.Response;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import static io.restassured.RestAssured.given;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.is;
+
+/** State-machine aliases resolve to their published version while preserving execution metadata. */
+@QuarkusTest
+class StepFunctionsAliasesIntegrationTest {
+
+ private static final String CT = "application/x-amz-json-1.0";
+ private static final String DEF =
+ "{\\\"StartAt\\\":\\\"D\\\",\\\"States\\\":{\\\"D\\\":{\\\"Type\\\":\\\"Pass\\\",\\\"Result\\\":1,\\\"End\\\":true}}}";
+ private static final String DEF2 =
+ "{\\\"StartAt\\\":\\\"D\\\",\\\"States\\\":{\\\"D\\\":{\\\"Type\\\":\\\"Pass\\\",\\\"Result\\\":2,\\\"End\\\":true}}}";
+
+ @BeforeAll
+ static void setup() {
+ RestAssuredJsonUtils.configureAwsContentTypes();
+ }
+
+ private static Response call(String target, String body) {
+ return given().header("X-Amz-Target", "AWSStepFunctions." + target)
+ .contentType(CT).body(body).when().post("/");
+ }
+
+ @Test
+ void aliasLifecycleResolvesDescribeAndExecutionToPublishedVersions() {
+ String name = "alias-test-" + System.currentTimeMillis();
+ Response created = call("CreateStateMachine", """
+ {"name":"%s","definition":"%s",
+ "roleArn":"arn:aws:iam::000000000000:role/r","publish":true}
+ """.formatted(name, DEF));
+ String stateMachineArn = created.then().statusCode(200)
+ .extract().jsonPath().getString("stateMachineArn");
+ String versionOneArn = created.jsonPath().getString("stateMachineVersionArn");
+
+ String versionTwoArn = call("UpdateStateMachine", """
+ {"stateMachineArn":"%s","definition":"%s","publish":true}
+ """.formatted(stateMachineArn, DEF2))
+ .then().statusCode(200)
+ .extract().jsonPath().getString("stateMachineVersionArn");
+
+ String createAliasRequest = """
+ {"name":"PROD","description":"production",
+ "routingConfiguration":[{"stateMachineVersionArn":"%s","weight":100}]}
+ """.formatted(versionOneArn);
+ String aliasArn = call("CreateStateMachineAlias", createAliasRequest)
+ .then().statusCode(200)
+ .body("stateMachineAliasArn", is(stateMachineArn + ":PROD"))
+ .extract().jsonPath().getString("stateMachineAliasArn");
+
+ // CreateStateMachineAlias is idempotent for the same request.
+ call("CreateStateMachineAlias", createAliasRequest)
+ .then().statusCode(200)
+ .body("stateMachineAliasArn", is(aliasArn));
+
+ call("DescribeStateMachineAlias",
+ "{\"stateMachineAliasArn\":\"" + aliasArn + "\"}")
+ .then().statusCode(200)
+ .body("name", is("PROD"))
+ .body("description", is("production"))
+ .body("routingConfiguration[0].stateMachineVersionArn", is(versionOneArn))
+ .body("routingConfiguration[0].weight", is(100));
+
+ call("ListStateMachineAliases",
+ "{\"stateMachineArn\":\"" + stateMachineArn + "\"}")
+ .then().statusCode(200)
+ .body("stateMachineAliases[0].stateMachineAliasArn", is(aliasArn));
+ call("ListStateMachineAliases",
+ "{\"stateMachineArn\":\"" + versionOneArn + "\"}")
+ .then().statusCode(200)
+ .body("stateMachineAliases[0].stateMachineAliasArn", is(aliasArn));
+
+ // DescribeStateMachine accepts an alias ARN and returns the selected version snapshot.
+ call("DescribeStateMachine", "{\"stateMachineArn\":\"" + aliasArn + "\"}")
+ .then().statusCode(200)
+ .body("stateMachineArn", is(versionOneArn))
+ .body("definition", containsString("\"Result\":1"));
+
+ String executionArn = call("StartExecution", """
+ {"stateMachineArn":"%s","name":"through-alias","input":"{}"}
+ """.formatted(aliasArn))
+ .then().statusCode(200)
+ .extract().jsonPath().getString("executionArn");
+ call("DescribeExecution", "{\"executionArn\":\"" + executionArn + "\"}")
+ .then().statusCode(200)
+ .body("stateMachineArn", is(stateMachineArn))
+ .body("stateMachineVersionArn", is(versionOneArn))
+ .body("stateMachineAliasArn", is(aliasArn));
+
+ call("UpdateStateMachineAlias", """
+ {"stateMachineAliasArn":"%s","description":"promoted",
+ "routingConfiguration":[{"stateMachineVersionArn":"%s","weight":100}]}
+ """.formatted(aliasArn, versionTwoArn))
+ .then().statusCode(200);
+ call("DescribeStateMachine", "{\"stateMachineArn\":\"" + aliasArn + "\"}")
+ .then().statusCode(200)
+ .body("stateMachineArn", is(versionTwoArn))
+ .body("definition", containsString("\"Result\":2"));
+
+ // A Distributed Map-qualified ARN is recognized but rejected, as documented by AWS.
+ call("DescribeStateMachine", "{\"stateMachineArn\":\""
+ + stateMachineArn + "/map-label\"}")
+ .then().statusCode(400)
+ .body(containsString("ValidationException"));
+
+ call("DeleteStateMachineVersion",
+ "{\"stateMachineVersionArn\":\"" + versionTwoArn + "\"}")
+ .then().statusCode(409)
+ .body(containsString("ConflictException"));
+ call("DeleteStateMachineAlias",
+ "{\"stateMachineAliasArn\":\"" + aliasArn + "\"}")
+ .then().statusCode(200);
+ call("DescribeStateMachine", "{\"stateMachineArn\":\"" + aliasArn + "\"}")
+ .then().statusCode(400)
+ .body(containsString("StateMachineDoesNotExist"));
+ }
+
+ @Test
+ void aliasValidationRejectsNamesAndInvalidRoutingConfiguration() {
+ String name = "alias-validation-" + System.currentTimeMillis();
+ Response created = call("CreateStateMachine", """
+ {"name":"%s","definition":"%s",
+ "roleArn":"arn:aws:iam::000000000000:role/r","publish":true}
+ """.formatted(name, DEF));
+ String versionArn = created.then().statusCode(200)
+ .extract().jsonPath().getString("stateMachineVersionArn");
+
+ call("CreateStateMachineAlias", """
+ {"name":"123","routingConfiguration":[
+ {"stateMachineVersionArn":"%s","weight":100}]}
+ """.formatted(versionArn))
+ .then().statusCode(400).body(containsString("InvalidName"));
+ call("CreateStateMachineAlias", """
+ {"name":"TEST","routingConfiguration":[
+ {"stateMachineVersionArn":"%s","weight":90}]}
+ """.formatted(versionArn))
+ .then().statusCode(400).body(containsString("ValidationException"));
+ }
+
+ @Test
+ void listAliasesPaginatesWithAnOpaqueRoundTripToken() {
+ String name = "alias-pagination-" + System.currentTimeMillis();
+ Response created = call("CreateStateMachine", """
+ {"name":"%s","definition":"%s",
+ "roleArn":"arn:aws:iam::000000000000:role/r","publish":true}
+ """.formatted(name, DEF));
+ String stateMachineArn = created.then().statusCode(200)
+ .extract().jsonPath().getString("stateMachineArn");
+ String versionArn = created.jsonPath().getString("stateMachineVersionArn");
+
+ for (String aliasName : new String[] {"ALPHA", "BETA"}) {
+ call("CreateStateMachineAlias", """
+ {"name":"%s","routingConfiguration":[
+ {"stateMachineVersionArn":"%s","weight":100}]}
+ """.formatted(aliasName, versionArn))
+ .then().statusCode(200);
+ }
+
+ Response firstPage = call("ListStateMachineAliases", """
+ {"stateMachineArn":"%s","maxResults":1}
+ """.formatted(stateMachineArn));
+ firstPage.then().statusCode(200)
+ .body("stateMachineAliases.size()", is(1));
+ String firstArn = firstPage.jsonPath().getString("stateMachineAliases[0].stateMachineAliasArn");
+ String nextToken = firstPage.jsonPath().getString("nextToken");
+ assertNotNull(nextToken);
+
+ Response secondPage = call("ListStateMachineAliases", """
+ {"stateMachineArn":"%s","maxResults":1,"nextToken":"%s"}
+ """.formatted(stateMachineArn, nextToken));
+ secondPage.then().statusCode(200)
+ .body("stateMachineAliases.size()", is(1));
+ assertNotEquals(firstArn,
+ secondPage.jsonPath().getString("stateMachineAliases[0].stateMachineAliasArn"));
+ assertNull(secondPage.jsonPath().getString("nextToken"));
+
+ call("ListStateMachineAliases", """
+ {"stateMachineArn":"%s","maxResults":1001}
+ """.formatted(stateMachineArn))
+ .then().statusCode(400).body(containsString("ValidationException"));
+ }
+}