Skip to content

armgit / floci

Public Imported from GitHub
0

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

feat(opensearch): serve the legacy Elasticsearch Service 2015-01-01 API (#5357)

Allen Sanborn4afa7d8e9f5c
diff --git a/docs/services/opensearch.md b/docs/services/opensearch.md
index 76afcab424..497a98d378 100644
--- a/docs/services/opensearch.md
+++ b/docs/services/opensearch.md
@@ -55,6 +55,21 @@ services:
| `ListTags` | `GET /2021-01-01/tags/?arn=` | List tags for a domain |
| `RemoveTags` | `POST /2021-01-01/tags-removal` | Remove tag keys from a domain |
+### Legacy Elasticsearch Service API
+
+The `2015-01-01` API used by `aws es` and Terraform's `aws_elasticsearch_domain` is served over the same domains. It differs only in spelling: `ElasticsearchVersion` (bare, e.g. `7.10`, stored as `Elasticsearch_7.10`; `OS_2.11` and `OpenSearch_2.11` both store and report as `OpenSearch_2.11`) for `EngineVersion`, `ElasticsearchClusterConfig` for `ClusterConfig`, and instance types ending in `.elasticsearch` (`t3.small.elasticsearch` is stored, and reported by the 2021 API, as `t3.small.search`). A domain created without `ElasticsearchVersion` gets `7.10`.
+
+| Operation | Method + Path |
+|---|---|
+| `CreateElasticsearchDomain` | `POST /2015-01-01/es/domain` |
+| `DescribeElasticsearchDomain` | `GET /2015-01-01/es/domain/{name}` |
+| `DescribeElasticsearchDomains` | `POST /2015-01-01/es/domain-info` |
+| `DescribeElasticsearchDomainConfig` | `GET /2015-01-01/es/domain/{name}/config` |
+| `UpdateElasticsearchDomainConfig` | `POST /2015-01-01/es/domain/{name}/config` |
+| `DeleteElasticsearchDomain` | `DELETE /2015-01-01/es/domain/{name}` |
+| `ListDomainNames` | `GET /2015-01-01/domain` |
+| `AddTags` / `ListTags` / `RemoveTags` | `POST /2015-01-01/tags`, `GET /2015-01-01/tags/?arn=`, `POST /2015-01-01/tags-removal` |
+
### Versions & Instance Types
| Operation | Method + Path | Description |
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java b/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java
index d6965e6def..ee055c75d1 100644
--- a/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java
+++ b/src/main/java/io/github/hectorvent/floci/core/common/ResolvedServiceCatalog.java
@@ -52,6 +52,7 @@ import io.github.hectorvent.floci.services.marketplace.MarketplaceDiscoveryContr
import io.github.hectorvent.floci.services.marketplace.MarketplaceReportingController;
import io.github.hectorvent.floci.services.mwaa.MwaaController;
import io.github.hectorvent.floci.services.oam.OamController;
+import io.github.hectorvent.floci.services.opensearch.ElasticsearchController;
import io.github.hectorvent.floci.services.opensearch.OpenSearchController;
import io.github.hectorvent.floci.services.pipes.PipesController;
import io.github.hectorvent.floci.services.rdsdata.RdsDataController;
@@ -331,7 +332,8 @@ public class ResolvedServiceCatalog {
"opensearch", storageMode(config.storage().services().opensearch().mode(), config.storage().mode()),
config.storage().services().opensearch().flushIntervalMs(), null, ServiceProtocol.REST_JSON,
protocols(ServiceProtocol.REST_JSON),
- Set.of(), Set.of("es"), Set.of(), Set.of(OpenSearchController.class)),
+ Set.of(), Set.of("es"), Set.of(),
+ Set.of(OpenSearchController.class, ElasticsearchController.class)),
descriptor("ec2", "ec2", config.services().ec2().enabled(), true,
"ec2", storageMode(config.storage().services().ec2().mode(), config.storage().mode()),
5000L, AwsNamespaces.EC2, ServiceProtocol.QUERY,
diff --git a/src/main/java/io/github/hectorvent/floci/services/opensearch/ElasticsearchController.java b/src/main/java/io/github/hectorvent/floci/services/opensearch/ElasticsearchController.java
new file mode 100644
index 0000000000..08fa6aa11e
--- /dev/null
+++ b/src/main/java/io/github/hectorvent/floci/services/opensearch/ElasticsearchController.java
@@ -0,0 +1,216 @@
+package io.github.hectorvent.floci.services.opensearch;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.node.ObjectNode;
+import io.github.hectorvent.floci.core.common.AwsException;
+import io.github.hectorvent.floci.core.common.RegionResolver;
+import jakarta.inject.Inject;
+import jakarta.ws.rs.Consumes;
+import jakarta.ws.rs.DELETE;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.POST;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.QueryParam;
+import jakarta.ws.rs.core.Context;
+import jakarta.ws.rs.core.HttpHeaders;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+
+import java.io.IOException;
+
+/**
+ * Legacy Amazon Elasticsearch Service API ({@code 2015-01-01}), still used by
+ * {@code aws es} and Terraform's {@code aws_elasticsearch_domain}. It addresses
+ * the same domains as the OpenSearch API, so every operation delegates to
+ * {@link OpenSearchController} and only renames the members the legacy model
+ * spells differently: {@code ElasticsearchVersion} / {@code EngineVersion} and
+ * {@code ElasticsearchClusterConfig} / {@code ClusterConfig}. The legacy version
+ * is bare ({@code 7.10}) where the store holds {@code Elasticsearch_7.10}, and
+ * legacy instance types end in {@code .elasticsearch} where the store holds {@code .search}.
+ */
+@Path("/2015-01-01")
+@Produces(MediaType.APPLICATION_JSON)
+@Consumes(MediaType.APPLICATION_JSON)
+public class ElasticsearchController {
+
+ private static final String ES_PREFIX = "Elasticsearch_";
+ private static final String OS_PREFIX = "OpenSearch_";
+ private static final String LEGACY_SUFFIX = ".elasticsearch";
+ private static final String SEARCH_SUFFIX = ".search";
+ /** The legacy API always creates an Elasticsearch domain; 7.10 is the newest Floci serves. */
+ private static final String DEFAULT_VERSION = ES_PREFIX + "7.10";
+
+ private final OpenSearchController delegate;
+ private final ObjectMapper objectMapper;
+
+ @Inject
+ public ElasticsearchController(OpenSearchService service, RegionResolver regionResolver,
+ ObjectMapper objectMapper) {
+ this.delegate = new OpenSearchController(service, regionResolver, objectMapper);
+ this.objectMapper = objectMapper;
+ }
+
+ @POST
+ @Path("/es/domain")
+ public Response createElasticsearchDomain(@Context HttpHeaders headers, String body) {
+ return toLegacy(delegate.createDomain(headers, toOpenSearch(body, true)));
+ }
+
+ @GET
+ @Path("/es/domain/{domainName}")
+ public Response describeElasticsearchDomain(@Context HttpHeaders headers,
+ @PathParam("domainName") String domainName) {
+ return toLegacy(delegate.describeDomain(headers, domainName));
+ }
+
+ @POST
+ @Path("/es/domain-info")
+ public Response describeElasticsearchDomains(@Context HttpHeaders headers, String body) {
+ return toLegacy(delegate.describeDomains(headers, body));
+ }
+
+ @GET
+ @Path("/domain")
+ public Response listDomainNames(@Context HttpHeaders headers,
+ @QueryParam("engineType") String engineType) {
+ return delegate.listDomainNames(headers, engineType);
+ }
+
+ @GET
+ @Path("/es/domain/{domainName}/config")
+ public Response describeElasticsearchDomainConfig(@Context HttpHeaders headers,
+ @PathParam("domainName") String domainName) {
+ return toLegacy(delegate.describeDomainConfig(headers, domainName));
+ }
+
+ @POST
+ @Path("/es/domain/{domainName}/config")
+ public Response updateElasticsearchDomainConfig(@Context HttpHeaders headers,
+ @PathParam("domainName") String domainName,
+ String body) {
+ return toLegacy(delegate.updateDomainConfig(headers, domainName, toOpenSearch(body, false)));
+ }
+
+ @DELETE
+ @Path("/es/domain/{domainName}")
+ public Response deleteElasticsearchDomain(@Context HttpHeaders headers,
+ @PathParam("domainName") String domainName) {
+ return toLegacy(delegate.deleteDomain(headers, domainName));
+ }
+
+ @POST
+ @Path("/tags")
+ public Response addTags(@Context HttpHeaders headers, String body) {
+ return delegate.addTags(headers, body);
+ }
+
+ @GET
+ @Path("/tags/")
+ public Response listTags(@Context HttpHeaders headers, @QueryParam("arn") String arn) {
+ return delegate.listTags(headers, arn);
+ }
+
+ @POST
+ @Path("/tags-removal")
+ public Response removeTags(@Context HttpHeaders headers, String body) {
+ return delegate.removeTags(headers, body);
+ }
+
+ // ── Member translation ───────────────────────────────────────────────────
+
+ private String toOpenSearch(String body, boolean create) {
+ JsonNode tree;
+ try {
+ tree = objectMapper.readTree(body);
+ } catch (IOException e) {
+ throw new AwsException("ValidationException", e.getMessage(), 400);
+ }
+ if (!(tree instanceof ObjectNode req)) {
+ return body;
+ }
+ rename(req, "ElasticsearchClusterConfig", "ClusterConfig");
+ swapInstanceTypeSuffix(req.path("ClusterConfig"), LEGACY_SUFFIX, SEARCH_SUFFIX);
+ JsonNode version = req.remove("ElasticsearchVersion");
+ if (version != null && !version.isNull()) {
+ // ElasticsearchVersionString is a pattern no blank or non-string value matches.
+ if (!version.isTextual() || version.asText().isBlank()) {
+ throw new AwsException("ValidationException",
+ "ElasticsearchVersion must be a version string such as 7.10.", 400);
+ }
+ req.put("EngineVersion", toEngineVersion(version.asText()));
+ } else if (create) {
+ req.put("EngineVersion", DEFAULT_VERSION);
+ }
+ return req.toString();
+ }
+
+ private static Response toLegacy(Response response) {
+ if (!(response.getEntity() instanceof ObjectNode body)) {
+ return response;
+ }
+ if (body.get("DomainStatus") instanceof ObjectNode status) {
+ toLegacyStatus(status);
+ }
+ body.path("DomainStatusList").forEach(s -> toLegacyStatus((ObjectNode) s));
+ if (body.get("DomainConfig") instanceof ObjectNode config) {
+ rename(config, "ClusterConfig", "ElasticsearchClusterConfig");
+ swapInstanceTypeSuffix(config.path("ElasticsearchClusterConfig").path("Options"),
+ SEARCH_SUFFIX, LEGACY_SUFFIX);
+ if (config.remove("EngineVersion") instanceof ObjectNode version) {
+ version.put("Options", toLegacyVersion(version.path("Options").asText(null)));
+ config.set("ElasticsearchVersion", version);
+ }
+ }
+ return response;
+ }
+
+ private static void toLegacyStatus(ObjectNode status) {
+ rename(status, "ClusterConfig", "ElasticsearchClusterConfig");
+ swapInstanceTypeSuffix(status.path("ElasticsearchClusterConfig"), SEARCH_SUFFIX, LEGACY_SUFFIX);
+ JsonNode version = status.remove("EngineVersion");
+ if (version != null) {
+ status.put("ElasticsearchVersion", toLegacyVersion(version.asText(null)));
+ }
+ }
+
+ /**
+ * ESPartitionInstanceType lists only {@code *.elasticsearch} types while the store
+ * (and the 2021 API) uses {@code *.search}, so instance types are respelled on the
+ * way in and out.
+ */
+ private static void swapInstanceTypeSuffix(JsonNode cluster, String from, String to) {
+ // Only InstanceType: the store keeps no DedicatedMasterType or WarmType to respell.
+ String type = cluster.path("InstanceType").asText("");
+ if (cluster instanceof ObjectNode node && type.endsWith(from)) {
+ node.put("InstanceType", type.substring(0, type.length() - from.length()) + to);
+ }
+ }
+
+ private static void rename(ObjectNode node, String from, String to) {
+ JsonNode value = node.remove(from);
+ if (value != null) {
+ node.set(to, value);
+ }
+ }
+
+ static String toEngineVersion(String legacy) {
+ if (legacy == null || legacy.isBlank()
+ || legacy.startsWith(ES_PREFIX) || legacy.startsWith(OS_PREFIX)) {
+ return legacy;
+ }
+ // ElasticsearchVersionString also accepts the short OS_X.Y spelling of OpenSearch_X.Y.
+ if (legacy.startsWith("OS_")) {
+ return OS_PREFIX + legacy.substring("OS_".length());
+ }
+ return ES_PREFIX + legacy;
+ }
+
+ static String toLegacyVersion(String engineVersion) {
+ return engineVersion != null && engineVersion.startsWith(ES_PREFIX)
+ ? engineVersion.substring(ES_PREFIX.length())
+ : engineVersion;
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/opensearch/ElasticsearchIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/opensearch/ElasticsearchIntegrationTest.java
new file mode 100644
index 0000000000..4ec47f1dca
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/opensearch/ElasticsearchIntegrationTest.java
@@ -0,0 +1,348 @@
+package io.github.hectorvent.floci.services.opensearch;
+
+import io.quarkus.test.junit.QuarkusTest;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Order;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.*;
+
+/** The legacy Elasticsearch Service API ({@code 2015-01-01}) over the shared OpenSearch store. */
+@QuarkusTest
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class ElasticsearchIntegrationTest {
+
+ private static final String DOMAIN_NAME = "legacy-es-domain";
+ private static final String AUTH_HEADER = "AWS4-HMAC-SHA256 Credential=AKID/20260101/us-east-1/es/aws4_request";
+
+ private static String arn;
+
+ @Test
+ @Order(1)
+ void createElasticsearchDomain() {
+ arn = given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("{\"DomainName\":\"" + DOMAIN_NAME + "\",\"ElasticsearchVersion\":\"7.10\","
+ + "\"ElasticsearchClusterConfig\":{\"InstanceType\":\"t3.small.elasticsearch\",\"InstanceCount\":2},"
+ + "\"EBSOptions\":{\"EBSEnabled\":true,\"VolumeType\":\"gp2\",\"VolumeSize\":20}}")
+ .when()
+ .post("/2015-01-01/es/domain")
+ .then()
+ .statusCode(200)
+ .body("DomainStatus.DomainName", equalTo(DOMAIN_NAME))
+ .body("DomainStatus.ElasticsearchVersion", equalTo("7.10"))
+ .body("DomainStatus.ElasticsearchClusterConfig.InstanceType", equalTo("t3.small.elasticsearch"))
+ .body("DomainStatus.ElasticsearchClusterConfig.InstanceCount", equalTo(2))
+ .body("DomainStatus", not(hasKey("EngineVersion")))
+ .body("DomainStatus", not(hasKey("ClusterConfig")))
+ .body("DomainStatus.ARN", containsString(":domain/" + DOMAIN_NAME))
+ .extract().path("DomainStatus.ARN");
+ }
+
+ @Test
+ @Order(2)
+ void storedAsElasticsearchEngineVersion() {
+ // Read back through the OpenSearch API: the legacy version must be stored prefixed.
+ given()
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .get("/2021-01-01/opensearch/domain/" + DOMAIN_NAME)
+ .then()
+ .statusCode(200)
+ .body("DomainStatus.EngineVersion", equalTo("Elasticsearch_7.10"))
+ .body("DomainStatus.ClusterConfig.InstanceType", equalTo("t3.small.search"))
+ .body("DomainStatus.ClusterConfig.InstanceCount", equalTo(2));
+ }
+
+ @Test
+ @Order(3)
+ void describeElasticsearchDomain() {
+ given()
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .get("/2015-01-01/es/domain/" + DOMAIN_NAME)
+ .then()
+ .statusCode(200)
+ .body("DomainStatus.ElasticsearchVersion", equalTo("7.10"))
+ .body("DomainStatus.ElasticsearchClusterConfig.InstanceType", equalTo("t3.small.elasticsearch"))
+ .body("DomainStatus.EBSOptions.VolumeSize", equalTo(20));
+ }
+
+ @Test
+ @Order(4)
+ void describeElasticsearchDomains() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("{\"DomainNames\":[\"" + DOMAIN_NAME + "\"]}")
+ .when()
+ .post("/2015-01-01/es/domain-info")
+ .then()
+ .statusCode(200)
+ .body("DomainStatusList", hasSize(1))
+ .body("DomainStatusList[0].ElasticsearchVersion", equalTo("7.10"))
+ .body("DomainStatusList[0].ElasticsearchClusterConfig.InstanceCount", equalTo(2));
+ }
+
+ @Test
+ @Order(5)
+ void listDomainNames() {
+ given()
+ .header("Authorization", AUTH_HEADER)
+ .queryParam("engineType", "Elasticsearch")
+ .when()
+ .get("/2015-01-01/domain")
+ .then()
+ .statusCode(200)
+ .body("DomainNames.DomainName", hasItem(DOMAIN_NAME))
+ .body("DomainNames.find { it.DomainName == '" + DOMAIN_NAME + "' }.EngineType",
+ equalTo("Elasticsearch"));
+ }
+
+ @Test
+ @Order(6)
+ void describeElasticsearchDomainConfig() {
+ given()
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .get("/2015-01-01/es/domain/" + DOMAIN_NAME + "/config")
+ .then()
+ .statusCode(200)
+ .body("DomainConfig.ElasticsearchVersion.Options", equalTo("7.10"))
+ .body("DomainConfig.ElasticsearchVersion.Status.State", equalTo("Active"))
+ .body("DomainConfig.ElasticsearchClusterConfig.Options.InstanceCount", equalTo(2))
+ .body("DomainConfig", not(hasKey("EngineVersion")))
+ .body("DomainConfig", not(hasKey("ClusterConfig")));
+ }
+
+ @Test
+ @Order(7)
+ void updateElasticsearchDomainConfig() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("{\"ElasticsearchClusterConfig\":{\"InstanceType\":\"m5.large.elasticsearch\",\"InstanceCount\":3}}")
+ .when()
+ .post("/2015-01-01/es/domain/" + DOMAIN_NAME + "/config")
+ .then()
+ .statusCode(200)
+ .body("DomainConfig.ElasticsearchClusterConfig.Options.InstanceCount", equalTo(3));
+
+ // The update must reach the store, not just the response.
+ given()
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .get("/2015-01-01/es/domain/" + DOMAIN_NAME)
+ .then()
+ .statusCode(200)
+ .body("DomainStatus.ElasticsearchClusterConfig.InstanceType", equalTo("m5.large.elasticsearch"))
+ .body("DomainStatus.ElasticsearchClusterConfig.InstanceCount", equalTo(3))
+ .body("DomainStatus.ElasticsearchVersion", equalTo("7.10"));
+
+ given()
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .get("/2021-01-01/opensearch/domain/" + DOMAIN_NAME)
+ .then()
+ .statusCode(200)
+ .body("DomainStatus.ClusterConfig.InstanceType", equalTo("m5.large.search"));
+ }
+
+ @Test
+ @Order(8)
+ void addListRemoveTags() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("{\"ARN\":\"" + arn + "\",\"TagList\":[{\"Key\":\"env\",\"Value\":\"test\"},{\"Key\":\"owner\",\"Value\":\"team\"}]}")
+ .when()
+ .post("/2015-01-01/tags")
+ .then()
+ .statusCode(200);
+
+ given()
+ .header("Authorization", AUTH_HEADER)
+ .queryParam("arn", arn)
+ .when()
+ .get("/2015-01-01/tags/")
+ .then()
+ .statusCode(200)
+ .body("TagList.Key", containsInAnyOrder("env", "owner"));
+
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("{\"ARN\":\"" + arn + "\",\"TagKeys\":[\"owner\"]}")
+ .when()
+ .post("/2015-01-01/tags-removal")
+ .then()
+ .statusCode(200);
+
+ given()
+ .header("Authorization", AUTH_HEADER)
+ .queryParam("arn", arn)
+ .when()
+ .get("/2015-01-01/tags/")
+ .then()
+ .statusCode(200)
+ .body("TagList.Key", contains("env"));
+ }
+
+ @Test
+ @Order(9)
+ void createWithoutVersionIsElasticsearch() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("{\"DomainName\":\"legacy-es-default\"}")
+ .when()
+ .post("/2015-01-01/es/domain")
+ .then()
+ .statusCode(200)
+ .body("DomainStatus.ElasticsearchVersion", equalTo("7.10"))
+ .body("DomainStatus.ElasticsearchClusterConfig.InstanceType", equalTo("m5.large.elasticsearch"));
+
+ given()
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .get("/2015-01-01/es/domain/legacy-es-default/config")
+ .then()
+ .statusCode(200)
+ .body("DomainConfig.ElasticsearchClusterConfig.Options.InstanceType", equalTo("m5.large.elasticsearch"));
+
+ // A domain created with no cluster or EBS block accepts a first update of either.
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("{\"ElasticsearchClusterConfig\":{\"InstanceCount\":2},\"EBSOptions\":{\"EBSEnabled\":true,\"VolumeSize\":30}}")
+ .when()
+ .post("/2015-01-01/es/domain/legacy-es-default/config")
+ .then()
+ .statusCode(200);
+
+ given()
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .get("/2015-01-01/es/domain/legacy-es-default")
+ .then()
+ .statusCode(200)
+ .body("DomainStatus.ElasticsearchClusterConfig.InstanceCount", equalTo(2))
+ .body("DomainStatus.EBSOptions.VolumeSize", equalTo(30));
+
+ given()
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .delete("/2015-01-01/es/domain/legacy-es-default")
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ @Order(10)
+ void shortOpenSearchVersion() {
+ // ElasticsearchVersionString accepts ^OS_[0-9]{1,2}\.[0-9]{1,2}$ alongside OpenSearch_X.Y.
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("{\"DomainName\":\"legacy-es-os\",\"ElasticsearchVersion\":\"OS_2.11\","
+ + "\"ElasticsearchClusterConfig\":{\"InstanceType\":\"r6g.large.elasticsearch\"}}")
+ .when()
+ .post("/2015-01-01/es/domain")
+ .then()
+ .statusCode(200)
+ .body("DomainStatus.ElasticsearchVersion", equalTo("OpenSearch_2.11"))
+ .body("DomainStatus.ElasticsearchClusterConfig.InstanceType", equalTo("r6g.large.elasticsearch"));
+
+ given()
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .get("/2021-01-01/opensearch/domain/legacy-es-os")
+ .then()
+ .statusCode(200)
+ .body("DomainStatus.EngineVersion", equalTo("OpenSearch_2.11"))
+ .body("DomainStatus.ClusterConfig.InstanceType", equalTo("r6g.large.search"));
+
+ given()
+ .header("Authorization", AUTH_HEADER)
+ .queryParam("engineType", "OpenSearch")
+ .when()
+ .get("/2015-01-01/domain")
+ .then()
+ .statusCode(200)
+ .body("DomainNames.DomainName", hasItem("legacy-es-os"));
+
+ given()
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .delete("/2015-01-01/es/domain/legacy-es-os")
+ .then()
+ .statusCode(200);
+ }
+
+ @Test
+ @Order(11)
+ void blankVersionIsRejected() {
+ // ElasticsearchVersionString: ^[0-9]{1}\\.[0-9]{1,2}$|^OpenSearch_...$|^OS_...$ -- "" matches none.
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("{\"DomainName\":\"legacy-es-blank\",\"ElasticsearchVersion\":\"\"}")
+ .when()
+ .post("/2015-01-01/es/domain")
+ .then()
+ .statusCode(400)
+ .body("__type", containsString("ValidationException"));
+
+ given()
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .get("/2015-01-01/es/domain/legacy-es-blank")
+ .then()
+ .statusCode(409);
+ }
+
+ @Test
+ @Order(12)
+ void emptyBodiesAreValidationErrors() {
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("")
+ .when()
+ .post("/2015-01-01/es/domain")
+ .then()
+ .statusCode(400);
+
+ given()
+ .contentType("application/json")
+ .header("Authorization", AUTH_HEADER)
+ .body("")
+ .when()
+ .post("/2015-01-01/es/domain/" + DOMAIN_NAME + "/config")
+ .then()
+ .statusCode(lessThan(500));
+ }
+
+ @Test
+ @Order(13)
+ void deleteElasticsearchDomain() {
+ given()
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .delete("/2015-01-01/es/domain/" + DOMAIN_NAME)
+ .then()
+ .statusCode(200)
+ .body("DomainStatus.Deleted", equalTo(true))
+ .body("DomainStatus.ElasticsearchVersion", equalTo("7.10"));
+
+ given()
+ .header("Authorization", AUTH_HEADER)
+ .when()
+ .get("/2015-01-01/es/domain/" + DOMAIN_NAME)
+ .then()
+ .statusCode(409);
+ }
+}