Light, fluffy, and always free - The AWS Local Emulator alternative
feat(stepfunctions): add state machine version APIs (Publish/List/DeleteStateMachineVersion) (#1562)
Alex Banna3fe7a60a58ca
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.javaindex 7a5b7fdf0c..d0fb078d31 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@@ -37,6 +37,9 @@ public class StepFunctionsJsonHandler {case "DescribeStateMachine" -> handleDescribeStateMachine(request);case "ListStateMachines" -> handleListStateMachines(request, region);case "DeleteStateMachine" -> handleDeleteStateMachine(request);+ case "PublishStateMachineVersion" -> handlePublishStateMachineVersion(request);+ case "ListStateMachineVersions" -> handleListStateMachineVersions(request);+ case "DeleteStateMachineVersion" -> handleDeleteStateMachineVersion(request);case "ValidateStateMachineDefinition" -> handleValidateStateMachineDefinition(request);case "StartExecution" -> handleStartExecution(request, region);case "StartSyncExecution" -> handleStartSyncExecution(request, region);@@ -73,9 +76,39 @@ public class StepFunctionsJsonHandler {ObjectNode response = objectMapper.createObjectNode();response.put("stateMachineArn", sm.getStateMachineArn());response.put("creationDate", sm.getCreationDate());+ // Publishing a version on create is opt-in (publish=true).+ if (request.path("publish").asBoolean(false)) {+ var version = service.publishStateMachineVersion(sm.getStateMachineArn());+ response.put("stateMachineVersionArn", version.getStateMachineVersionArn());+ }+ return Response.ok(response).build();+ }++ private Response handlePublishStateMachineVersion(JsonNode request) {+ var version = service.publishStateMachineVersion(request.path("stateMachineArn").asText());+ ObjectNode response = objectMapper.createObjectNode();+ response.put("stateMachineVersionArn", version.getStateMachineVersionArn());+ response.put("creationDate", version.getCreationDate());+ return Response.ok(response).build();+ }++ private Response handleListStateMachineVersions(JsonNode request) {+ var versions = service.listStateMachineVersions(request.path("stateMachineArn").asText());+ ObjectNode response = objectMapper.createObjectNode();+ ArrayNode array = response.putArray("stateMachineVersions");+ for (var v : versions) {+ ObjectNode item = array.addObject();+ item.put("stateMachineVersionArn", v.getStateMachineVersionArn());+ item.put("creationDate", v.getCreationDate());+ }return Response.ok(response).build();}+ private Response handleDeleteStateMachineVersion(JsonNode request) {+ service.deleteStateMachineVersion(request.path("stateMachineVersionArn").asText());+ return Response.ok(objectMapper.createObjectNode()).build();+ }+private Response handleDescribeStateMachine(JsonNode request) {StateMachine sm = service.describeStateMachine(request.path("stateMachineArn").asText());ObjectNode response = objectMapper.createObjectNode();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.javaindex 13c6845738..5252a7f7a1 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@@ -12,6 +12,7 @@ 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.StateMachine;+import io.github.hectorvent.floci.services.stepfunctions.model.StateMachineVersion;import io.github.hectorvent.floci.core.common.Resettable;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;@@ -107,6 +108,51 @@ public class StepFunctionsService implements Resettable {return stateMachineStore.scan(k -> k.startsWith(prefix));}+ // ── State machine versions ──────────────────────────────────────────────++ public StateMachineVersion publishStateMachineVersion(String stateMachineArn) {+ StateMachine sm = describeStateMachine(stateMachineArn);+ int next = sm.getVersionCounter() + 1;+ sm.setVersionCounter(next);+ StateMachineVersion version = new StateMachineVersion(+ stateMachineArn + ":" + next, next, System.currentTimeMillis() / 1000.0);+ sm.getVersions().add(version);+ stateMachineStore.put(stateMachineArn, sm);+ return version;+ }++ public List<StateMachineVersion> listStateMachineVersions(String stateMachineArn) {+ // AWS returns InvalidArn for a non-existent state machine here — StateMachineDoesNotExist is+ // not one of ListStateMachineVersions' declared errors (Publish, which does declare it, keeps+ // using describeStateMachine).+ StateMachine sm = stateMachineStore.get(stateMachineArn)+ .orElseThrow(() -> new AwsException("InvalidArn",+ "Invalid Arn: '" + stateMachineArn + "'", 400));+ // AWS lists versions newest first (descending by creationDate). creationDate is only+ // second-resolution, so tie-break on the version number (also descending) to keep the order+ // correct when several versions are published within the same second — otherwise the+ // Terraform provider can latch onto the wrong version ARN.+ List<StateMachineVersion> versions = new ArrayList<>(sm.getVersions());+ versions.sort(Comparator+ .comparingDouble(StateMachineVersion::getCreationDate)+ .thenComparingInt(StateMachineVersion::getVersion)+ .reversed());+ // Defensive copy so callers can't mutate (or trip over concurrent mutation of) the stored list.+ return List.copyOf(versions);+ }++ public void deleteStateMachineVersion(String stateMachineVersionArn) {+ int lastColon = stateMachineVersionArn.lastIndexOf(':');+ if (lastColon < 0) {+ return;+ }+ String baseArn = stateMachineVersionArn.substring(0, lastColon);+ stateMachineStore.get(baseArn).ifPresent(sm -> {+ sm.getVersions().removeIf(v -> stateMachineVersionArn.equals(v.getStateMachineVersionArn()));+ stateMachineStore.put(baseArn, sm);+ });+ }+public void deleteStateMachine(String arn) {stateMachineStore.delete(arn);}diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/StateMachine.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/StateMachine.javaindex e89f2c3559..45cfa61675 100644--- a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/StateMachine.java+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/StateMachine.java@@ -3,7 +3,9 @@ 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.HashMap;+import java.util.List;import java.util.Map;@RegisterForReflection@@ -17,6 +19,8 @@ public class StateMachine {private String status = "ACTIVE";private double creationDate;private Map<String, String> tags = new HashMap<>();+ private int versionCounter = 0;+ private List<StateMachineVersion> versions = new ArrayList<>();public StateMachine() {this.creationDate = System.currentTimeMillis() / 1000.0;@@ -45,4 +49,10 @@ public class StateMachine {public Map<String, String> getTags() { return tags; }public void setTags(Map<String, String> tags) { this.tags = tags; }++ public int getVersionCounter() { return versionCounter; }+ public void setVersionCounter(int versionCounter) { this.versionCounter = versionCounter; }++ public List<StateMachineVersion> getVersions() { return versions; }+ public void setVersions(List<StateMachineVersion> versions) { this.versions = versions; }}diff --git a/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/StateMachineVersion.java b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/StateMachineVersion.javanew file mode 100644index 0000000000..805a69a620--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/stepfunctions/model/StateMachineVersion.java@@ -0,0 +1,31 @@+package io.github.hectorvent.floci.services.stepfunctions.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++/** A published version of a state machine ({@code <stateMachineArn>:<version>}). */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class StateMachineVersion {+ private String stateMachineVersionArn;+ private int version;+ private double creationDate;++ public StateMachineVersion() {+ }++ public StateMachineVersion(String stateMachineVersionArn, int version, double creationDate) {+ this.stateMachineVersionArn = stateMachineVersionArn;+ this.version = version;+ this.creationDate = creationDate;+ }++ public String getStateMachineVersionArn() { return stateMachineVersionArn; }+ public void setStateMachineVersionArn(String stateMachineVersionArn) { this.stateMachineVersionArn = stateMachineVersionArn; }++ public int getVersion() { return version; }+ public void setVersion(int version) { this.version = version; }++ public double getCreationDate() { return creationDate; }+ public void setCreationDate(double creationDate) { this.creationDate = creationDate; }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsVersionsIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsVersionsIntegrationTest.javanew file mode 100644index 0000000000..8efc05cbce--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/stepfunctions/StepFunctionsVersionsIntegrationTest.java@@ -0,0 +1,100 @@+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.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.emptyOrNullString;+import static org.hamcrest.Matchers.is;+import static org.hamcrest.Matchers.not;++/**+ * State machine version APIs — the Terraform AWS provider calls ListStateMachineVersions after+ * creating an aws_sfn_state_machine; previously Floci returned UnsupportedOperation.+ */+@QuarkusTest+class StepFunctionsVersionsIntegrationTest {++ private static final String CT = "application/x-amz-json-1.0";+ private static final String DEF = "{\\\"StartAt\\\":\\\"D\\\",\\\"States\\\":{\\\"D\\\":{\\\"Type\\\":\\\"Pass\\\",\\\"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 listVersionsEmptyByDefaultThenPublishAndDelete() {+ String name = "ver-test-" + System.currentTimeMillis();+ String arn = call("CreateStateMachine",+ "{\"name\":\"" + name + "\",\"definition\":\"" + DEF + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/r\"}")+ .then().statusCode(200).extract().jsonPath().getString("stateMachineArn");++ // No versions published yet -> empty list (the call that previously failed).+ call("ListStateMachineVersions", "{\"stateMachineArn\":\"" + arn + "\"}")+ .then().statusCode(200).body("stateMachineVersions", is(java.util.Collections.emptyList()));++ // Publish a version.+ String versionArn = call("PublishStateMachineVersion", "{\"stateMachineArn\":\"" + arn + "\"}")+ .then().statusCode(200).body("stateMachineVersionArn", containsString(arn + ":1"))+ .extract().jsonPath().getString("stateMachineVersionArn");++ call("ListStateMachineVersions", "{\"stateMachineArn\":\"" + arn + "\"}")+ .then().statusCode(200).body("stateMachineVersions[0].stateMachineVersionArn", is(versionArn));++ // Delete it.+ call("DeleteStateMachineVersion", "{\"stateMachineVersionArn\":\"" + versionArn + "\"}")+ .then().statusCode(200);+ call("ListStateMachineVersions", "{\"stateMachineArn\":\"" + arn + "\"}")+ .then().statusCode(200).body("stateMachineVersions", is(java.util.Collections.emptyList()));+ }++ @Test+ void listVersionsAreReturnedNewestFirst() {+ String name = "ver-order-" + System.currentTimeMillis();+ String arn = call("CreateStateMachine",+ "{\"name\":\"" + name + "\",\"definition\":\"" + DEF + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/r\"}")+ .then().statusCode(200).extract().jsonPath().getString("stateMachineArn");++ // Publish three versions (1, 2, 3). AWS lists them newest first, and the Terraform provider+ // reads the version ARN off this list, so the order must be descending — even though the three+ // publishes land within the same (second-resolution) creationDate, the version-number tie-break+ // keeps 3 ahead of 2 ahead of 1.+ call("PublishStateMachineVersion", "{\"stateMachineArn\":\"" + arn + "\"}").then().statusCode(200);+ call("PublishStateMachineVersion", "{\"stateMachineArn\":\"" + arn + "\"}").then().statusCode(200);+ call("PublishStateMachineVersion", "{\"stateMachineArn\":\"" + arn + "\"}").then().statusCode(200);++ call("ListStateMachineVersions", "{\"stateMachineArn\":\"" + arn + "\"}")+ .then().statusCode(200)+ .body("stateMachineVersions[0].stateMachineVersionArn", is(arn + ":3"))+ .body("stateMachineVersions[1].stateMachineVersionArn", is(arn + ":2"))+ .body("stateMachineVersions[2].stateMachineVersionArn", is(arn + ":1"));+ }++ @Test+ void listVersionsForMissingStateMachineReturnsInvalidArn() {+ // AWS returns InvalidArn (not StateMachineDoesNotExist) when the state machine does not exist,+ // since StateMachineDoesNotExist is not a declared error for ListStateMachineVersions.+ String missing = "arn:aws:states:us-east-1:000000000000:stateMachine:missing-" + System.currentTimeMillis();+ call("ListStateMachineVersions", "{\"stateMachineArn\":\"" + missing + "\"}")+ .then().statusCode(400).body(containsString("InvalidArn"));+ }++ @Test+ void createWithPublishReturnsVersionArn() {+ String name = "ver-pub-" + System.currentTimeMillis();+ call("CreateStateMachine",+ "{\"name\":\"" + name + "\",\"definition\":\"" + DEF + "\",\"roleArn\":\"arn:aws:iam::000000000000:role/r\",\"publish\":true}")+ .then().statusCode(200)+ .body("stateMachineVersionArn", not(emptyOrNullString()))+ .body("stateMachineVersionArn", containsString(":1"));+ }+}