Light, fluffy, and always free - The AWS Local Emulator alternative
feat(iot): indexing configuration (#4896)
Mario Toffiaf413a667d033
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IotTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IotTest.javaindex bfbc639301..2ede66e98f 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IotTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IotTest.java@@ -41,6 +41,8 @@ import software.amazon.awssdk.services.iot.model.DescribeDomainConfigurationRequimport software.amazon.awssdk.services.iot.model.DescribeDomainConfigurationResponse;import software.amazon.awssdk.services.iot.model.DescribeEndpointRequest;import software.amazon.awssdk.services.iot.model.DescribeEndpointResponse;+import software.amazon.awssdk.services.iot.model.DescribeIndexRequest;+import software.amazon.awssdk.services.iot.model.DescribeIndexResponse;import software.amazon.awssdk.services.iot.model.DescribeJobRequest;import software.amazon.awssdk.services.iot.model.DescribeThingRequest;import software.amazon.awssdk.services.iot.model.DescribeThingResponse;@@ -48,15 +50,20 @@ import software.amazon.awssdk.services.iot.model.DescribeThingTypeRequest;import software.amazon.awssdk.services.iot.model.DescribeThingTypeResponse;import software.amazon.awssdk.services.iot.model.DetachPolicyRequest;import software.amazon.awssdk.services.iot.model.DetachThingPrincipalRequest;+import software.amazon.awssdk.services.iot.model.DeviceDefenderIndexingMode;import software.amazon.awssdk.services.iot.model.DisableTopicRuleRequest;import software.amazon.awssdk.services.iot.model.DomainConfigurationStatus;import software.amazon.awssdk.services.iot.model.DomainConfigurationSummary;import software.amazon.awssdk.services.iot.model.DomainType;import software.amazon.awssdk.services.iot.model.EnableTopicRuleRequest;+import software.amazon.awssdk.services.iot.model.Field;+import software.amazon.awssdk.services.iot.model.GetIndexingConfigurationRequest;+import software.amazon.awssdk.services.iot.model.GetIndexingConfigurationResponse;import software.amazon.awssdk.services.iot.model.GetPolicyRequest;import software.amazon.awssdk.services.iot.model.GetPolicyResponse;import software.amazon.awssdk.services.iot.model.GetTopicRuleRequest;import software.amazon.awssdk.services.iot.model.GetTopicRuleResponse;+import software.amazon.awssdk.services.iot.model.IndexStatus;import software.amazon.awssdk.services.iot.model.InvalidRequestException;import software.amazon.awssdk.services.iot.model.ListCertificatesRequest;import software.amazon.awssdk.services.iot.model.ListCertificatesResponse;@@ -77,6 +84,7 @@ import software.amazon.awssdk.services.iot.model.ListThingsRequest;import software.amazon.awssdk.services.iot.model.ListThingsResponse;import software.amazon.awssdk.services.iot.model.ListTopicRulesRequest;import software.amazon.awssdk.services.iot.model.ListTopicRulesResponse;+import software.amazon.awssdk.services.iot.model.NamedShadowIndexingMode;import software.amazon.awssdk.services.iot.model.RemoveThingFromThingGroupRequest;import software.amazon.awssdk.services.iot.model.ResourceAlreadyExistsException;import software.amazon.awssdk.services.iot.model.ResourceNotFoundException;@@ -85,13 +93,19 @@ import software.amazon.awssdk.services.iot.model.ServiceType;import software.amazon.awssdk.services.iot.model.SqsAction;import software.amazon.awssdk.services.iot.model.Tag;import software.amazon.awssdk.services.iot.model.TagResourceRequest;+import software.amazon.awssdk.services.iot.model.ThingConnectivityIndexingMode;+import software.amazon.awssdk.services.iot.model.ThingGroupIndexingConfiguration;+import software.amazon.awssdk.services.iot.model.ThingGroupIndexingMode;import software.amazon.awssdk.services.iot.model.ThingGroupProperties;+import software.amazon.awssdk.services.iot.model.ThingIndexingConfiguration;+import software.amazon.awssdk.services.iot.model.ThingIndexingMode;import software.amazon.awssdk.services.iot.model.ThingTypeProperties;import software.amazon.awssdk.services.iot.model.TopicRulePayload;import software.amazon.awssdk.services.iot.model.UntagResourceRequest;import software.amazon.awssdk.services.iot.model.UpdateCertificateRequest;import software.amazon.awssdk.services.iot.model.UpdateDomainConfigurationRequest;import software.amazon.awssdk.services.iot.model.UpdateDomainConfigurationResponse;+import software.amazon.awssdk.services.iot.model.UpdateIndexingConfigurationRequest;import software.amazon.awssdk.services.iot.model.UpdateThingRequest;import software.amazon.awssdk.services.iot.model.UpdateThingTypeRequest;import software.amazon.awssdk.services.iot.model.VersionConflictException;@@ -261,6 +275,99 @@ class IotTest {.isInstanceOf(ResourceNotFoundException.class);}+ @Test+ void fleetIndexingConfiguration() {+ GetIndexingConfigurationResponse prior =+ iot.getIndexingConfiguration(GetIndexingConfigurationRequest.builder().build());+ try {+ iot.updateIndexingConfiguration(UpdateIndexingConfigurationRequest.builder()+ .thingIndexingConfiguration(ThingIndexingConfiguration.builder()+ .thingIndexingMode(ThingIndexingMode.REGISTRY)+ .thingConnectivityIndexingMode(ThingConnectivityIndexingMode.STATUS)+ .build())+ .thingGroupIndexingConfiguration(ThingGroupIndexingConfiguration.builder()+ .thingGroupIndexingMode(ThingGroupIndexingMode.ON)+ .build())+ .build());++ GetIndexingConfigurationResponse enabled =+ iot.getIndexingConfiguration(GetIndexingConfigurationRequest.builder().build());+ ThingIndexingConfiguration thing = enabled.thingIndexingConfiguration();+ assertThat(thing.thingIndexingMode()).isEqualTo(ThingIndexingMode.REGISTRY);+ assertThat(thing.thingConnectivityIndexingMode()).isEqualTo(ThingConnectivityIndexingMode.STATUS);+ assertThat(thing.deviceDefenderIndexingMode()).isEqualTo(DeviceDefenderIndexingMode.OFF);+ assertThat(thing.namedShadowIndexingMode()).isEqualTo(NamedShadowIndexingMode.OFF);+ assertThat(thing.managedFields())+ .extracting(field -> field.name() + ":" + field.typeAsString())+ .containsExactlyInAnyOrder(+ "thingName:String", "thingId:String", "registry.version:Number",+ "registry.thingTypeName:String", "registry.thingGroupNames:String",+ "connectivity.connected:Boolean", "connectivity.timestamp:Number",+ "connectivity.disconnectReason:String", "connectivity.clientId:String",+ "connectivity.cleanSession:Boolean", "connectivity.keepAliveDuration:Number",+ "connectivity.sessionExpiry:Number", "connectivity.version:Number");+ assertThat(thing.filter().namedShadowNames()).isEmpty();+ assertThat(enabled.thingGroupIndexingConfiguration().thingGroupIndexingMode())+ .isEqualTo(ThingGroupIndexingMode.ON);+ assertThat(enabled.thingGroupIndexingConfiguration().managedFields())+ .extracting(Field::name)+ .containsExactlyInAnyOrder("parentGroupNames", "description", "version", "thingGroupName",+ "thingGroupId");++ DescribeIndexResponse things = iot.describeIndex(DescribeIndexRequest.builder()+ .indexName("AWS_Things")+ .build());+ assertThat(things.schema()).isEqualTo("REGISTRY_AND_CONNECTIVITY_STATUS");+ assertIndexStatus(things.indexStatus());+ DescribeIndexResponse groups = iot.describeIndex(DescribeIndexRequest.builder()+ .indexName("AWS_ThingGroups")+ .build());+ assertThat(groups.schema()).isEqualTo("REGISTRY");+ assertIndexStatus(groups.indexStatus());++ assertThatThrownBy(() -> iot.updateIndexingConfiguration(UpdateIndexingConfigurationRequest.builder()+ .thingIndexingConfiguration(ThingIndexingConfiguration.builder()+ .thingIndexingMode(ThingIndexingMode.REGISTRY_AND_SHADOW)+ .namedShadowIndexingMode(NamedShadowIndexingMode.ON)+ .build())+ .build()))+ .isInstanceOf(InvalidRequestException.class)+ .hasMessageContaining("NamedShadowNames Filter must not be empty for enabling NamedShadowIndexingMode");++ iot.updateIndexingConfiguration(UpdateIndexingConfigurationRequest.builder()+ .thingIndexingConfiguration(ThingIndexingConfiguration.builder()+ .thingIndexingMode(ThingIndexingMode.OFF)+ .build())+ .build());+ assertThatThrownBy(() -> iot.describeIndex(DescribeIndexRequest.builder().indexName("AWS_Things").build()))+ .isInstanceOf(ResourceNotFoundException.class)+ .hasMessageContaining("Index AWS_Things does not exist");+ GetIndexingConfigurationResponse thingOff =+ iot.getIndexingConfiguration(GetIndexingConfigurationRequest.builder().build());+ assertThat(thingOff.thingIndexingConfiguration().thingIndexingMode()).isEqualTo(ThingIndexingMode.OFF);+ assertThat(thingOff.thingIndexingConfiguration().thingConnectivityIndexingMode())+ .isEqualTo(ThingConnectivityIndexingMode.OFF);+ assertThat(thingOff.thingIndexingConfiguration().managedFields()).isEmpty();+ assertThat(thingOff.thingGroupIndexingConfiguration().thingGroupIndexingMode())+ .isEqualTo(ThingGroupIndexingMode.ON);+ } finally {+ // Indexing is account wide on AWS: put back whatever the account had before this test.+ iot.updateIndexingConfiguration(UpdateIndexingConfigurationRequest.builder()+ .thingIndexingConfiguration(prior.thingIndexingConfiguration())+ .thingGroupIndexingConfiguration(prior.thingGroupIndexingConfiguration())+ .build());+ }+ }++ private static void assertIndexStatus(IndexStatus status) {+ if (TestFixtures.isRealAws()) {+ // AWS builds the index in the background after a mode change; Floci has it ready at once.+ assertThat(status).isIn(IndexStatus.ACTIVE, IndexStatus.BUILDING, IndexStatus.REBUILDING);+ } else {+ assertThat(status).isEqualTo(IndexStatus.ACTIVE);+ }+ }+@Testvoid thingRegistryCrud() {String thingName = "java-iot-thing";diff --git a/docs/services/index.md b/docs/services/index.mdindex f575b1e3bf..ee17d17718 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -142,7 +142,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac| [BCM Data Exports](bcm-data-exports.md) | `POST /` + `X-Amz-Target: AWSBillingAndCostManagementDataExports.*` | JSON 1.1 | 7 || [Transfer Family](transfer.md) | `POST /` + `X-Amz-Target: TransferService.*` | JSON 1.1 | 17 || [DataSync](datasync.md) | `POST /` + `X-Amz-Target: FmrsService.*` | JSON 1.1 | 48 |-| [IoT Core](iot.md) | `/things/...`, `/endpoint`, rules/policies REST paths | REST JSON | 71 |+| [IoT Core](iot.md) | `/things/...`, `/endpoint`, rules/policies REST paths | REST JSON | 74 || [IoT Data](iot.md) | `/things/{thingName}/shadow`, MQTT topics | REST JSON | 11 |**Lambda, ElastiCache, RDS, MSK, MWAA, ECS, EKS, and OpenSearch** spin up real Docker containers and support IAM authentication and SigV4 request signing, the same auth flow as production AWS. **RDS Data API** executes SQL against the local RDS containers through AWS-compatible REST JSON routes.diff --git a/docs/services/iot.md b/docs/services/iot.mdindex 2b1fe5c255..a156363fee 100644--- a/docs/services/iot.md+++ b/docs/services/iot.md@@ -45,7 +45,7 @@ Current MVP 2 limitations:- `SendDirectMessage` publishes to the requested MQTT topic through the embedded broker. Unlike AWS IoT Core, it does not yet bypass subscription matching to deliver to a client that is not subscribed to that topic.- `GetConnection` and `ListSubscriptions` report live in-memory broker state only; offline persistent session subscription reporting is not modeled yet.- Jobs reserved MQTT topics remain follow-up scope; Jobs Data HTTP APIs are implemented first.-- Dynamic thing groups, fleet indexing, job rollouts, cancellations, documents from S3, and advanced job scheduling are not yet modeled.+- Dynamic thing groups, job rollouts, cancellations, documents from S3, and advanced job scheduling are not yet modeled. Fleet indexing has its configuration only, see [Fleet Indexing](#fleet-indexing).## Domain Configurations@@ -102,6 +102,24 @@ Current limitations:- On a connection, the authorizer is looked up in Floci's default account and region.- The MQTT password reaches the function as the broker decodes it, as UTF-8 text, so password bytes that are not valid UTF-8 arrive altered. The broker library, Vert.x MQTT, exposes the password only as a string.+## Fleet Indexing++Status: configuration only.++`UpdateIndexingConfiguration` and `GetIndexingConfiguration` (`/indexing/config`) and `DescribeIndex` (`/indices/{indexName}`) are served on the REST-JSON paths the AWS SDKs use, with the AWS shapes, error codes and validation messages:++- There is one configuration per account and region. Before the first update both indexes are `OFF`.+- An update may carry the thing configuration, the thing group configuration, or both; the one it leaves out keeps its value. Turning `thingIndexingMode` to `OFF` clears the whole thing configuration, as on AWS.+- `managedFields` in `GetIndexingConfiguration` are derived from the modes, as AWS derives them. Managed fields sent in an update are only checked: every entry must be a field AWS manages, with its type, or the update fails with `InvalidRequestException`. A custom shadow path such as `shadow.name.<shadow>.reported.<field>` is rejected this way on AWS too. The thing group's managed fields are checked the same way, also while `thingGroupIndexingMode` is `OFF`.+- The thing configuration's `customFields` and `filter` (named shadow names, geolocations, socket information) are stored and returned as sent, except that a geolocation without an `order` gets `LatLon`. A thing custom field without a name or a type, or named after a managed field, fails with `InvalidRequestException`.+- A member of the wrong JSON type, or content after the JSON body, fails with `SerializationException`.+- `DescribeIndex` reports `AWS_Things` and `AWS_ThingGroups` with the schema the modes select. The index is `ACTIVE` as soon as it is enabled: Floci has no `BUILDING` or `REBUILDING` window. A disabled index is `ResourceNotFoundException`, any other index name `InvalidRequestException`.++Current limitations:++- `SearchIndex`, `ListIndices` and the statistics and aggregation APIs (`GetStatistics`, `GetCardinality`, `GetPercentiles`, `GetBucketsAggregation`) are not modeled yet.+- `managedFields` and `customFields` sent in the thing group configuration are checked (the custom fields for their types only) but not stored: `GetIndexingConfiguration` reports the managed fields the mode selects and no custom fields.+## MQTT BrokerStatus: complete.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.javaindex f39ef69a99..d6965e6def 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@@ -40,6 +40,7 @@ import io.github.hectorvent.floci.services.iot.IotAuthorizerController;import io.github.hectorvent.floci.services.iot.IotController;import io.github.hectorvent.floci.services.iot.IotDataController;import io.github.hectorvent.floci.services.iot.IotDomainConfigurationController;+import io.github.hectorvent.floci.services.iot.IotFleetIndexingController;import io.github.hectorvent.floci.services.lambda.LambdaController;import io.github.hectorvent.floci.services.lambda.durable.DurableExecutionController;import io.github.hectorvent.floci.services.lambdamicrovms.LambdaMicrovmsController;@@ -650,7 +651,7 @@ public class ResolvedServiceCatalog {// signs under its own name while IotController serves its /things/*/jobs routesSet.of(), Set.of("iot", "execute-api", "iot-jobs-data"), Set.of(),Set.of(IotController.class, IotDomainConfigurationController.class,- IotAuthorizerController.class)),+ IotAuthorizerController.class, IotFleetIndexingController.class)),descriptor("iotdata", "iotdata", config.services().iotdata().enabled(), true,"iot", config.storage().mode(), 5000L, null, ServiceProtocol.REST_JSON,protocols(ServiceProtocol.REST_JSON),diff --git a/src/main/java/io/github/hectorvent/floci/services/iot/IotAuthorizerController.java b/src/main/java/io/github/hectorvent/floci/services/iot/IotAuthorizerController.javaindex d519745bed..290f0895b5 100644--- a/src/main/java/io/github/hectorvent/floci/services/iot/IotAuthorizerController.java+++ b/src/main/java/io/github/hectorvent/floci/services/iot/IotAuthorizerController.java@@ -1,13 +1,8 @@package io.github.hectorvent.floci.services.iot;-import com.fasterxml.jackson.core.JsonProcessingException;-import com.fasterxml.jackson.databind.DeserializationFeature;-import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.ObjectMapper;-import com.fasterxml.jackson.databind.ObjectReader;import com.fasterxml.jackson.databind.node.ArrayNode;import com.fasterxml.jackson.databind.node.ObjectNode;-import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.RegionResolver;import io.github.hectorvent.floci.services.iot.model.IotAuthorizer;import jakarta.inject.Inject;@@ -40,7 +35,6 @@ public class IotAuthorizerController {private final IotCustomAuthorizer customAuthorizer;private final RegionResolver regionResolver;private final ObjectMapper objectMapper;- private final ObjectReader strictReader;@Injectpublic IotAuthorizerController(IotAuthorizerService authorizerService, IotCustomAuthorizer customAuthorizer,@@ -49,7 +43,6 @@ public class IotAuthorizerController {this.customAuthorizer = customAuthorizer;this.regionResolver = regionResolver;this.objectMapper = objectMapper;- this.strictReader = objectMapper.reader().with(DeserializationFeature.FAIL_ON_TRAILING_TOKENS);}@POST@@ -57,7 +50,8 @@ public class IotAuthorizerController {public Response createAuthorizer(@Context HttpHeaders headers, @PathParam("authorizerName") String authorizerName,String body) {return Response.ok(nameAndArn(authorizerService.createAuthorizer(- authorizerName, readJson(body), regionResolver.resolveRegion(headers)))).build();+ authorizerName, IotRequestBody.read(objectMapper, body), regionResolver.resolveRegion(headers))))+ .build();}@GET@@ -71,7 +65,8 @@ public class IotAuthorizerController {public Response updateAuthorizer(@Context HttpHeaders headers, @PathParam("authorizerName") String authorizerName,String body) {return Response.ok(nameAndArn(authorizerService.updateAuthorizer(- authorizerName, readJson(body), regionResolver.resolveRegion(headers)))).build();+ authorizerName, IotRequestBody.read(objectMapper, body), regionResolver.resolveRegion(headers))))+ .build();}@DELETE@@ -86,8 +81,8 @@ public class IotAuthorizerController {@Path("/authorizer/{authorizerName}/test")public Response testInvokeAuthorizer(@Context HttpHeaders headers, @PathParam("authorizerName") String authorizerName,String body) {- return Response.ok(customAuthorizer.testInvoke(authorizerName, readJson(body), regionResolver.resolveRegion(headers)))- .build();+ return Response.ok(customAuthorizer.testInvoke(authorizerName, IotRequestBody.read(objectMapper, body),+ regionResolver.resolveRegion(headers))).build();}@GET@@ -110,7 +105,8 @@ public class IotAuthorizerController {@Path("/default-authorizer")public Response setDefaultAuthorizer(@Context HttpHeaders headers, String body) {return Response.ok(nameAndArn(authorizerService.setDefaultAuthorizer(- readJson(body).path("authorizerName").asText(null), regionResolver.resolveRegion(headers)))).build();+ IotRequestBody.read(objectMapper, body).path("authorizerName").asText(null),+ regionResolver.resolveRegion(headers)))).build();}@GET@@ -150,12 +146,4 @@ public class IotAuthorizerController {description.set("tokenSigningPublicKeys", objectMapper.valueToTree(authorizer.getTokenSigningPublicKeys()));return Response.ok(response).build();}-- private JsonNode readJson(String body) {- try {- return strictReader.readTree(body == null || body.isBlank() ? "{}" : body);- } catch (JsonProcessingException e) {- throw new AwsException("InvalidRequestException", e.getMessage(), 400);- }- }}diff --git a/src/main/java/io/github/hectorvent/floci/services/iot/IotDomainConfigurationController.java b/src/main/java/io/github/hectorvent/floci/services/iot/IotDomainConfigurationController.javaindex 1eac96815f..1043a46e87 100644--- a/src/main/java/io/github/hectorvent/floci/services/iot/IotDomainConfigurationController.java+++ b/src/main/java/io/github/hectorvent/floci/services/iot/IotDomainConfigurationController.java@@ -1,11 +1,8 @@package io.github.hectorvent.floci.services.iot;-import com.fasterxml.jackson.core.JsonProcessingException;-import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.databind.node.ArrayNode;import com.fasterxml.jackson.databind.node.ObjectNode;-import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.RegionResolver;import io.github.hectorvent.floci.services.iot.model.IotDomainConfiguration;import io.github.hectorvent.floci.services.iot.model.IotDomainConfiguration.AuthorizerConfig;@@ -55,7 +52,8 @@ public class IotDomainConfigurationController {@PathParam("domainConfigurationName") String domainConfigurationName,String body) {IotDomainConfiguration created = domainConfigurationService.createDomainConfiguration(- domainConfigurationName, readJson(body), regionResolver.resolveRegion(headers));+ domainConfigurationName, IotRequestBody.read(objectMapper, body),+ regionResolver.resolveRegion(headers));return Response.ok(nameAndArn(created)).build();}@@ -74,7 +72,8 @@ public class IotDomainConfigurationController {@PathParam("domainConfigurationName") String domainConfigurationName,String body) {IotDomainConfiguration updated = domainConfigurationService.updateDomainConfiguration(- domainConfigurationName, readJson(body), regionResolver.resolveRegion(headers));+ domainConfigurationName, IotRequestBody.read(objectMapper, body),+ regionResolver.resolveRegion(headers));return Response.ok(nameAndArn(updated)).build();}@@ -166,12 +165,4 @@ public class IotDomainConfigurationController {node.put(field, value);}}-- private JsonNode readJson(String body) {- try {- return objectMapper.readTree(body == null || body.isBlank() ? "{}" : body);- } catch (JsonProcessingException e) {- throw new AwsException("InvalidRequestException", e.getMessage(), 400);- }- }}diff --git a/src/main/java/io/github/hectorvent/floci/services/iot/IotFleetIndexingController.java b/src/main/java/io/github/hectorvent/floci/services/iot/IotFleetIndexingController.javanew file mode 100644index 0000000000..6a1aedf14e--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/iot/IotFleetIndexingController.java@@ -0,0 +1,96 @@+package io.github.hectorvent.floci.services.iot;++import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.services.iot.model.IotIndexingConfiguration;+import io.github.hectorvent.floci.services.iot.model.IotIndexingConfiguration.Field;+import io.github.hectorvent.floci.services.iot.model.IotIndexingConfiguration.ThingIndexing;+import jakarta.inject.Inject;+import jakarta.ws.rs.Consumes;+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.core.Context;+import jakarta.ws.rs.core.HttpHeaders;+import jakarta.ws.rs.core.MediaType;+import jakarta.ws.rs.core.Response;++import java.util.List;++/**+ * REST-JSON routes for AWS IoT fleet indexing: UpdateIndexingConfiguration,+ * GetIndexingConfiguration and DescribeIndex, on the paths and shapes the AWS SDKs use.+ */+@Path("/")+@Produces(MediaType.APPLICATION_JSON)+@Consumes(MediaType.APPLICATION_JSON)+public class IotFleetIndexingController {++ private final IotFleetIndexingService fleetIndexingService;+ private final RegionResolver regionResolver;+ private final ObjectMapper objectMapper;++ @Inject+ public IotFleetIndexingController(IotFleetIndexingService fleetIndexingService, RegionResolver regionResolver,+ ObjectMapper objectMapper) {+ this.fleetIndexingService = fleetIndexingService;+ this.regionResolver = regionResolver;+ this.objectMapper = objectMapper;+ }++ @POST+ @Path("/indexing/config")+ public Response updateIndexingConfiguration(@Context HttpHeaders headers, String body) {+ fleetIndexingService.updateIndexingConfiguration(IotRequestBody.read(objectMapper, body),+ regionResolver.resolveRegion(headers));+ return Response.ok(objectMapper.createObjectNode()).build();+ }++ @GET+ @Path("/indexing/config")+ public Response getIndexingConfiguration(@Context HttpHeaders headers) {+ IotIndexingConfiguration configuration =+ fleetIndexingService.getIndexingConfiguration(regionResolver.resolveRegion(headers));+ ObjectNode response = objectMapper.createObjectNode();+ ThingIndexing thing = configuration.thing();+ ObjectNode thingNode = response.putObject("thingIndexingConfiguration");+ thingNode.put("thingIndexingMode", thing.thingIndexingMode());+ thingNode.put("thingConnectivityIndexingMode", thing.thingConnectivityIndexingMode());+ thingNode.put("deviceDefenderIndexingMode", thing.deviceDefenderIndexingMode());+ thingNode.put("namedShadowIndexingMode", thing.namedShadowIndexingMode());+ List<Field> managedFields = IotFleetIndexingService.thingManagedFields(thing);+ ObjectNode filter = thingNode.putObject("filter");+ // Managed fields exist exactly while thing indexing is on; AWS then reports the full filter too.+ if (!managedFields.isEmpty()) {+ thingNode.set("managedFields", objectMapper.valueToTree(managedFields));+ if (!thing.customFields().isEmpty()) {+ thingNode.set("customFields", objectMapper.valueToTree(thing.customFields()));+ }+ filter.set("namedShadowNames", objectMapper.valueToTree(thing.namedShadowNames()));+ filter.set("geoLocations", objectMapper.valueToTree(thing.geoLocations()));+ filter.putObject("connectivity")+ .set("includeSocketInformation", objectMapper.valueToTree(thing.includeSocketInformation()));+ }+ ObjectNode groupNode = response.putObject("thingGroupIndexingConfiguration");+ groupNode.put("thingGroupIndexingMode", configuration.thingGroupIndexingMode());+ if ("ON".equals(configuration.thingGroupIndexingMode())) {+ groupNode.set("managedFields", objectMapper.valueToTree(IotFleetIndexingService.THING_GROUP_MANAGED_FIELDS));+ }+ return Response.ok(response).build();+ }++ @GET+ @Path("/indices/{indexName}")+ public Response describeIndex(@Context HttpHeaders headers, @PathParam("indexName") String indexName) {+ String schema = fleetIndexingService.describeIndex(indexName, regionResolver.resolveRegion(headers));+ ObjectNode response = objectMapper.createObjectNode();+ response.put("indexName", indexName);+ // ponytail: always ACTIVE, Floci indexes synchronously so there is no BUILDING or REBUILDING window.+ response.put("indexStatus", "ACTIVE");+ response.put("schema", schema);+ return Response.ok(response).build();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/iot/IotFleetIndexingService.java b/src/main/java/io/github/hectorvent/floci/services/iot/IotFleetIndexingService.javanew file mode 100644index 0000000000..ff4850ab67--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/iot/IotFleetIndexingService.java@@ -0,0 +1,362 @@+package io.github.hectorvent.floci.services.iot;++import com.fasterxml.jackson.core.type.TypeReference;+import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.node.JsonNodeType;+import com.fasterxml.jackson.databind.node.MissingNode;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.storage.StorageBackend;+import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.iot.model.IotIndexingConfiguration;+import io.github.hectorvent.floci.services.iot.model.IotIndexingConfiguration.Field;+import io.github.hectorvent.floci.services.iot.model.IotIndexingConfiguration.GeoLocation;+import io.github.hectorvent.floci.services.iot.model.IotIndexingConfiguration.ThingIndexing;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;++import java.util.ArrayList;+import java.util.Collection;+import java.util.List;+import java.util.Locale;+import java.util.Map;+import java.util.Set;+import java.util.stream.Collectors;+import java.util.stream.Stream;++/**+ * AWS IoT fleet indexing configuration: UpdateIndexingConfiguration, GetIndexingConfiguration and+ * DescribeIndex. One configuration per account and region; a region never updated is OFF.+ */+@ApplicationScoped+public class IotFleetIndexingService {++ static final String THINGS_INDEX = "AWS_Things";+ static final String THING_GROUPS_INDEX = "AWS_ThingGroups";++ // Enum value sets in the order AWS prints them in its validation messages.+ private static final List<String> THING_INDEXING_MODES = List.of("REGISTRY_AND_SHADOW", "OFF", "REGISTRY");+ private static final List<String> CONNECTIVITY_MODES = List.of("OFF", "STATUS");+ private static final List<String> DEVICE_DEFENDER_MODES = List.of("VIOLATIONS", "OFF");+ private static final List<String> ON_OFF = List.of("OFF", "ON");+ private static final List<String> FIELD_TYPES = List.of("Boolean", "Number", "String");+ private static final List<String> SOCKET_INFORMATION_APIS = List.of("GET_THING_CONNECTIVITY_DATA");+ private static final List<String> GEO_LOCATION_ORDERS = List.of("LatLon", "LonLat");++ private static final List<Field> REGISTRY_FIELDS = List.of(+ new Field("thingName", "String"),+ new Field("thingId", "String"),+ new Field("registry.version", "Number"),+ new Field("registry.thingTypeName", "String"),+ new Field("registry.thingGroupNames", "String"));+ private static final List<Field> SHADOW_FIELDS = List.of(+ new Field("shadow.version", "Number"),+ new Field("shadow.hasDelta", "Boolean"));+ private static final List<Field> NAMED_SHADOW_FIELDS = List.of(+ new Field("shadow.name.*.hasDelta", "Boolean"),+ new Field("shadow.name.*.version", "Number"));+ private static final List<Field> CONNECTIVITY_FIELDS = List.of(+ new Field("connectivity.connected", "Boolean"),+ new Field("connectivity.timestamp", "Number"),+ new Field("connectivity.disconnectReason", "String"),+ new Field("connectivity.clientId", "String"),+ new Field("connectivity.cleanSession", "Boolean"),+ new Field("connectivity.keepAliveDuration", "Number"),+ new Field("connectivity.sessionExpiry", "Number"),+ new Field("connectivity.version", "Number"));+ private static final List<Field> DEVICE_DEFENDER_FIELDS = List.of(+ new Field("deviceDefender.version", "Number"),+ new Field("deviceDefender.violationCount", "Number"),+ new Field("deviceDefender.*.*.inViolation", "Boolean"),+ new Field("deviceDefender.*.*.lastViolationTime", "Number"),+ new Field("deviceDefender.*.*.metricName", "String"));+ private static final Set<Field> KNOWN_THING_FIELDS = Stream.of(REGISTRY_FIELDS, SHADOW_FIELDS,+ NAMED_SHADOW_FIELDS, CONNECTIVITY_FIELDS, DEVICE_DEFENDER_FIELDS)+ .flatMap(List::stream)+ .collect(Collectors.toUnmodifiableSet());+ static final List<Field> THING_GROUP_MANAGED_FIELDS = List.of(+ new Field("parentGroupNames", "String"),+ new Field("description", "String"),+ new Field("version", "Number"),+ new Field("thingGroupName", "String"),+ new Field("thingGroupId", "String"));++ private final StorageBackend<String, IotIndexingConfiguration> store;+ /** Guards the read-modify-write of an update that changes only one of the two configurations. */+ private final Object lock = new Object();++ @Inject+ public IotFleetIndexingService(StorageFactory storageFactory) {+ this(storageFactory.create("iot", "iot-indexing-configuration.json",+ new TypeReference<Map<String, IotIndexingConfiguration>>() {}));+ }++ IotFleetIndexingService(StorageBackend<String, IotIndexingConfiguration> store) {+ this.store = store;+ }++ public void updateIndexingConfiguration(JsonNode request, String region) {+ if (!request.isObject()) {+ throw serializationError("request body", JsonNodeType.OBJECT);+ }+ String groupPrefix = "thingGroupIndexingConfiguration";+ JsonNode thingNode = object(request.path("thingIndexingConfiguration"), "thingIndexingConfiguration");+ JsonNode groupNode = object(request.path(groupPrefix), groupPrefix);+ if (!present(thingNode) && !present(groupNode)) {+ throw invalid("At least one configuration to update "+ + "(thingIndexingConfiguration / thingGroupIndexingConfiguration) is required");+ }+ List<String> errors = new ArrayList<>();+ ThingIndexing thing = present(thingNode) ? parseThing(thingNode, errors) : null;+ List<Field> managedFields = fields(thingNode.path("managedFields"),+ "thingIndexingConfiguration.managedFields", errors);+ String groupMode = present(groupNode) ? enumValue(groupNode, groupPrefix,+ "thingGroupIndexingMode", ON_OFF, true, errors) : null;+ List<Field> groupManagedFields = fields(groupNode.path("managedFields"), groupPrefix + ".managedFields",+ errors);+ fields(groupNode.path("customFields"), groupPrefix + ".customFields", errors);+ if (!errors.isEmpty()) {+ throw invalid(errors.size() + (errors.size() == 1 ? " validation error" : " validation errors")+ + " detected: " + String.join("; ", errors));+ }+ if (thing != null) {+ thing = validateThing(thing, managedFields);+ }+ // Checked in either mode and never stored: AWS derives the group's managed fields from its mode.+ requireKnownManagedFields(groupManagedFields, THING_GROUP_MANAGED_FIELDS, groupPrefix);+ synchronized (lock) {+ IotIndexingConfiguration current = getIndexingConfiguration(region);+ store.put(key(region), new IotIndexingConfiguration(thing == null ? current.thing() : thing,+ groupMode == null ? current.thingGroupIndexingMode() : groupMode));+ }+ }++ /** The stored configuration, or the OFF one AWS reports before the first update. */+ public IotIndexingConfiguration getIndexingConfiguration(String region) {+ return store.get(key(region)).orElse(IotIndexingConfiguration.OFF);+ }++ /** The schema of an enabled index. */+ public String describeIndex(String indexName, String region) {+ IotIndexingConfiguration configuration = getIndexingConfiguration(region);+ String schema = switch (indexName) {+ case THINGS_INDEX -> thingsSchema(configuration.thing());+ case THING_GROUPS_INDEX -> "OFF".equals(configuration.thingGroupIndexingMode()) ? null : "REGISTRY";+ default -> throw invalid("Unrecognized indexName " + indexName);+ };+ if (schema == null) {+ throw new AwsException("ResourceNotFoundException", "Index " + indexName + " does not exist", 404);+ }+ return schema;+ }++ /** The managed fields AWS derives from the thing indexing modes; none while indexing is OFF. */+ public static List<Field> thingManagedFields(ThingIndexing thing) {+ if ("OFF".equals(thing.thingIndexingMode())) {+ return List.of();+ }+ List<Field> fields = new ArrayList<>(REGISTRY_FIELDS);+ if ("REGISTRY_AND_SHADOW".equals(thing.thingIndexingMode())) {+ fields.addAll(SHADOW_FIELDS);+ }+ if ("ON".equals(thing.namedShadowIndexingMode())) {+ fields.addAll(NAMED_SHADOW_FIELDS);+ }+ if ("STATUS".equals(thing.thingConnectivityIndexingMode())) {+ fields.addAll(CONNECTIVITY_FIELDS);+ }+ if ("VIOLATIONS".equals(thing.deviceDefenderIndexingMode())) {+ fields.addAll(DEVICE_DEFENDER_FIELDS);+ }+ return fields;+ }++ private static String thingsSchema(ThingIndexing thing) {+ if ("OFF".equals(thing.thingIndexingMode())) {+ return null;+ }+ if ("VIOLATIONS".equals(thing.deviceDefenderIndexingMode()) || "ON".equals(thing.namedShadowIndexingMode())) {+ return "MULTI_INDEXING_MODE";+ }+ return "STATUS".equals(thing.thingConnectivityIndexingMode())+ ? thing.thingIndexingMode() + "_AND_CONNECTIVITY_STATUS"+ : thing.thingIndexingMode();+ }++ private static ThingIndexing parseThing(JsonNode node, List<String> errors) {+ String prefix = "thingIndexingConfiguration";+ String mode = enumValue(node, prefix, "thingIndexingMode", THING_INDEXING_MODES, true, errors);+ String connectivity = enumValue(node, prefix, "thingConnectivityIndexingMode", CONNECTIVITY_MODES, false, errors);+ String deviceDefender = enumValue(node, prefix, "deviceDefenderIndexingMode", DEVICE_DEFENDER_MODES, false, errors);+ String namedShadow = enumValue(node, prefix, "namedShadowIndexingMode", ON_OFF, false, errors);+ List<Field> customFields = fields(node.path("customFields"), prefix + ".customFields", errors);+ JsonNode filter = object(node.path("filter"), prefix + ".filter");+ JsonNode connectivityFilter = object(filter.path("connectivity"), prefix + ".filter.connectivity");+ List<String> socketInformation = texts(connectivityFilter.path("includeSocketInformation"),+ prefix + ".filter.connectivity.includeSocketInformation");+ // AWS checks this list as a whole and prints the whole list as the offending value.+ if (!SOCKET_INFORMATION_APIS.containsAll(socketInformation)) {+ errors.add("Value '" + socketInformation + "' at '" + prefix+ + ".filter.connectivity.includeSocketInformation' failed to satisfy constraint: "+ + "Member must satisfy constraint: [Member must satisfy enum value set: "+ + SOCKET_INFORMATION_APIS + "]");+ }+ List<GeoLocation> geoLocations = new ArrayList<>();+ String geoLocationsPath = prefix + ".filter.geoLocations";+ for (JsonNode location : list(filter.path("geoLocations"), geoLocationsPath, JsonNodeType.OBJECT)) {+ String member = geoLocationsPath + "." + (geoLocations.size() + 1) + ".member";+ String name = text(location.path("name"), member + ".name");+ String order = text(location.path("order"), member + ".order");+ if (order != null && !GEO_LOCATION_ORDERS.contains(order)) {+ errors.add(enumError(order, member + ".order", GEO_LOCATION_ORDERS));+ }+ geoLocations.add(new GeoLocation(name, order == null ? "LatLon" : order));+ }+ return new ThingIndexing(mode, connectivity, deviceDefender, namedShadow,+ texts(filter.path("namedShadowNames"), prefix + ".filter.namedShadowNames"),+ geoLocations, socketInformation, customFields);+ }++ private static ThingIndexing validateThing(ThingIndexing thing, List<Field> managedFields) {+ if ("OFF".equals(thing.thingIndexingMode())) {+ requireOff(thing.thingConnectivityIndexingMode(), "ThingConnectivityIndexingMode");+ requireOff(thing.namedShadowIndexingMode(), "NamedShadowIndexingMode");+ requireOff(thing.deviceDefenderIndexingMode(), "DeviceDefenderIndexingMode");+ }+ if ("ON".equals(thing.namedShadowIndexingMode()) && thing.namedShadowNames().isEmpty()) {+ throw invalid("NamedShadowNames Filter must not be empty for enabling NamedShadowIndexingMode");+ }+ for (Field field : thing.customFields()) {+ if (field.name() == null) {+ // AWS's message verbatim, the missing space included.+ throw invalid("Custom field name cannot be nullFieldName: null, FieldType: " + field.type());+ }+ if (field.type() == null) {+ throw invalid("Invalid field type: null. Expecting one of [String, Number, Boolean, Geopoint]");+ }+ if (KNOWN_THING_FIELDS.stream().anyMatch(known -> known.name().equals(field.name()))) {+ throw invalid("Defined field is a reserved field for MULTI_INDEXING_MODE. Field: " + field.name());+ }+ }+ requireKnownManagedFields(managedFields, KNOWN_THING_FIELDS, "thingIndexingConfiguration");+ // AWS keeps nothing of a thing configuration that turns indexing OFF.+ return "OFF".equals(thing.thingIndexingMode()) ? ThingIndexing.OFF : thing;+ }++ private static void requireKnownManagedFields(List<Field> fields, Collection<Field> known, String prefix) {+ List<Field> unknown = fields.stream().filter(field -> !known.contains(field)).toList();+ if (!unknown.isEmpty()) {+ throw invalid("Only managed fields with expected types are allowed in " + prefix+ + ".managedFields. Invalid field(s): " + unknown.stream()+ .map(field -> "name:" + field.name() + ", type:" + field.type())+ .collect(Collectors.joining(", ", "[", "]")));+ }+ }++ private static void requireOff(String mode, String member) {+ if (!"OFF".equals(mode)) {+ throw invalid("ThingIndexingMode must be turned ON for enabling " + member);+ }+ }++ private static List<Field> fields(JsonNode node, String path, List<String> errors) {+ List<Field> fields = new ArrayList<>();+ for (JsonNode field : list(node, path, JsonNodeType.OBJECT)) {+ String member = path + "." + (fields.size() + 1) + ".member";+ String name = text(field.path("name"), member + ".name");+ String type = text(field.path("type"), member + ".type");+ if (type != null && !FIELD_TYPES.contains(type)) {+ errors.add(enumError(type, member + ".type", FIELD_TYPES));+ }+ fields.add(new Field(name, type));+ }+ return fields;+ }++ /** A mode, OFF when an optional one is absent; a violation is collected rather than thrown. */+ private static String enumValue(JsonNode node, String prefix, String member, List<String> allowed,+ boolean required, List<String> errors) {+ String value = text(node.path(member), prefix + "." + member);+ if (value == null) {+ if (required) {+ errors.add("Value null at '" + prefix + "." + member+ + "' failed to satisfy constraint: Member must not be null");+ }+ return "OFF";+ }+ if (!allowed.contains(value)) {+ errors.add(enumError(value, prefix + "." + member, allowed));+ }+ return value;+ }++ private static String enumError(String value, String path, List<String> allowed) {+ return "Value '" + value + "' at '" + path+ + "' failed to satisfy constraint: Member must satisfy enum value set: " + allowed;+ }++ /** An object member, read as missing when it is absent or null. */+ private static JsonNode object(JsonNode node, String path) {+ if (!present(node)) {+ return MissingNode.getInstance();+ }+ if (!node.isObject()) {+ throw serializationError(path, JsonNodeType.OBJECT);+ }+ return node;+ }++ /** The elements of a list member, none when it is absent or null; every element must be of the given type. */+ private static List<JsonNode> list(JsonNode node, String path, JsonNodeType elementType) {+ if (!present(node)) {+ return List.of();+ }+ if (!node.isArray()) {+ throw serializationError(path, JsonNodeType.ARRAY);+ }+ List<JsonNode> elements = new ArrayList<>();+ for (JsonNode element : node) {+ if (element.getNodeType() != elementType) {+ throw serializationError(path + "." + (elements.size() + 1), elementType);+ }+ elements.add(element);+ }+ return elements;+ }++ private static List<String> texts(JsonNode node, String path) {+ List<String> values = new ArrayList<>();+ for (JsonNode value : list(node, path, JsonNodeType.STRING)) {+ values.add(value.asText());+ }+ return values;+ }++ /** A string member, null when it is absent or null. */+ private static String text(JsonNode node, String path) {+ if (!present(node)) {+ return null;+ }+ if (!node.isTextual()) {+ throw serializationError(path, JsonNodeType.STRING);+ }+ return node.asText();+ }++ private static boolean present(JsonNode node) {+ return !node.isMissingNode() && !node.isNull();+ }++ /** A member of the wrong JSON type fails before any validation, as AWS fails to deserialize it. */+ private static AwsException serializationError(String path, JsonNodeType expected) {+ return new AwsException("SerializationException",+ path + " must be a JSON " + expected.name().toLowerCase(Locale.ROOT), 400);+ }++ private static AwsException invalid(String message) {+ return new AwsException("InvalidRequestException", message, 400);+ }++ private static String key(String region) {+ return "indexing:" + region;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/iot/IotRequestBody.java b/src/main/java/io/github/hectorvent/floci/services/iot/IotRequestBody.javanew file mode 100644index 0000000000..268496c3f5--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/iot/IotRequestBody.java@@ -0,0 +1,26 @@+package io.github.hectorvent.floci.services.iot;++import com.fasterxml.jackson.core.JsonProcessingException;+import com.fasterxml.jackson.databind.DeserializationFeature;+import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.common.AwsException;++/**+ * Reads an AWS IoT REST-JSON request body. AWS rejects a malformed body, and content after the+ * JSON value, with {@code SerializationException}.+ */+final class IotRequestBody {++ private IotRequestBody() {+ }++ static JsonNode read(ObjectMapper objectMapper, String body) {+ try {+ return objectMapper.reader().with(DeserializationFeature.FAIL_ON_TRAILING_TOKENS)+ .readTree(body == null || body.isBlank() ? "{}" : body);+ } catch (JsonProcessingException e) {+ throw new AwsException("SerializationException", e.getOriginalMessage(), 400);+ }+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/iot/model/IotIndexingConfiguration.java b/src/main/java/io/github/hectorvent/floci/services/iot/model/IotIndexingConfiguration.javanew file mode 100644index 0000000000..58e51fe98d--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/iot/model/IotIndexingConfiguration.java@@ -0,0 +1,33 @@+package io.github.hectorvent.floci.services.iot.model;++import io.quarkus.runtime.annotations.RegisterForReflection;++import java.util.List;++/**+ * The fleet indexing configuration of an account in one region, as UpdateIndexingConfiguration+ * stores it. Managed fields are not stored: AWS derives them from the modes.+ */+@RegisterForReflection+public record IotIndexingConfiguration(ThingIndexing thing, String thingGroupIndexingMode) {++ public static final IotIndexingConfiguration OFF = new IotIndexingConfiguration(ThingIndexing.OFF, "OFF");++ @RegisterForReflection+ public record ThingIndexing(String thingIndexingMode, String thingConnectivityIndexingMode,+ String deviceDefenderIndexingMode, String namedShadowIndexingMode,+ List<String> namedShadowNames, List<GeoLocation> geoLocations,+ List<String> includeSocketInformation, List<Field> customFields) {++ public static final ThingIndexing OFF =+ new ThingIndexing("OFF", "OFF", "OFF", "OFF", List.of(), List.of(), List.of(), List.of());+ }++ @RegisterForReflection+ public record Field(String name, String type) {+ }++ @RegisterForReflection+ public record GeoLocation(String name, String order) {+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/iot/IotCustomAuthorizerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iot/IotCustomAuthorizerIntegrationTest.javaindex 3cc89bc079..e0683550e2 100644--- a/src/test/java/io/github/hectorvent/floci/services/iot/IotCustomAuthorizerIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iot/IotCustomAuthorizerIntegrationTest.java@@ -127,12 +127,12 @@ class IotCustomAuthorizerIntegrationTest {}@Test- void aTestInvokeBodyWithTrailingContentIsAnInvalidRequest() {+ void aTestInvokeBodyWithTrailingContentIsASerializationError() {given().contentType("application/json").body("{\"mqttContext\": {}} trailing").when().post("/authorizer/" + authorizer + "/test").then().statusCode(400)- .header("X-Amzn-ErrorType", "InvalidRequestException");+ .header("X-Amzn-ErrorType", "SerializationException");}@Testdiff --git a/src/test/java/io/github/hectorvent/floci/services/iot/IotDomainConfigurationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iot/IotDomainConfigurationIntegrationTest.javaindex ac71a64ff1..5bbe842246 100644--- a/src/test/java/io/github/hectorvent/floci/services/iot/IotDomainConfigurationIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iot/IotDomainConfigurationIntegrationTest.java@@ -318,6 +318,26 @@ class IotDomainConfigurationIntegrationTest {.body("__type", equalTo("InvalidRequestException"));}+ @Test+ void createWithTrailingContentAfterTheBodyIsASerializationError() {+ given()+ .contentType("application/json")+ .body(createBody("trailing.it.example.com", "DATA") + " trailing")+ .when()+ .post("/domainConfigurations/it-domain-trailing")+ .then()+ .statusCode(400)+ .header("x-amzn-ErrorType", equalTo("SerializationException"))+ .body("__type", equalTo("SerializationException"));++ given()+ .when()+ .get("/domainConfigurations/it-domain-trailing")+ .then()+ .statusCode(404)+ .body("__type", equalTo("ResourceNotFoundException"));+ }+@Testvoid describeEndpointAcceptsTheCredentialProviderEndpointType() {given()diff --git a/src/test/java/io/github/hectorvent/floci/services/iot/IotFleetIndexingIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iot/IotFleetIndexingIntegrationTest.javanew file mode 100644index 0000000000..f75a03282c--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iot/IotFleetIndexingIntegrationTest.java@@ -0,0 +1,286 @@+package io.github.hectorvent.floci.services.iot;++import io.quarkus.test.junit.QuarkusTest;+import org.junit.jupiter.api.Test;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.aMapWithSize;+import static org.hamcrest.Matchers.anEmptyMap;+import static org.hamcrest.Matchers.contains;+import static org.hamcrest.Matchers.containsInAnyOrder;+import static org.hamcrest.Matchers.empty;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.hasItems;+import static org.hamcrest.Matchers.hasKey;+import static org.hamcrest.Matchers.hasSize;+import static org.hamcrest.Matchers.not;+import static org.hamcrest.Matchers.startsWith;++/**+ * Drives fleet indexing the way the AWS SDKs do: UpdateIndexingConfiguration and+ * GetIndexingConfiguration on {@code /indexing/config}, DescribeIndex on {@code /indices/{indexName}}.+ * Every test signs as its own account, so the configurations they store never meet.+ */+@QuarkusTest+class IotFleetIndexingIntegrationTest {++ private static String auth(String account, String region) {+ return "AWS4-HMAC-SHA256 Credential=" + account + "/20260215/" + region+ + "/iot/aws4_request, SignedHeaders=host, Signature=abc";+ }++ private static void update(String auth, String body) {+ given()+ .header("Authorization", auth)+ .contentType("application/json")+ .body(body)+ .when()+ .post("/indexing/config")+ .then()+ .statusCode(200)+ .body(equalTo("{}"));+ }++ @Test+ void getBeforeAnyUpdateReturnsTheOffShape() {+ given()+ .header("Authorization", auth("111100000001", "us-east-1"))+ .when()+ .get("/indexing/config")+ .then()+ .statusCode(200)+ .body("thingIndexingConfiguration", aMapWithSize(5))+ .body("thingIndexingConfiguration.thingIndexingMode", equalTo("OFF"))+ .body("thingIndexingConfiguration.thingConnectivityIndexingMode", equalTo("OFF"))+ .body("thingIndexingConfiguration.deviceDefenderIndexingMode", equalTo("OFF"))+ .body("thingIndexingConfiguration.namedShadowIndexingMode", equalTo("OFF"))+ .body("thingIndexingConfiguration.filter", anEmptyMap())+ .body("thingGroupIndexingConfiguration", aMapWithSize(1))+ .body("thingGroupIndexingConfiguration.thingGroupIndexingMode", equalTo("OFF"));+ }++ @Test+ void updateThenGetRoundTripsTheWireShape() {+ String auth = auth("111100000002", "us-east-1");+ update(auth, """+ {+ "thingIndexingConfiguration": {+ "thingIndexingMode": "REGISTRY_AND_SHADOW",+ "thingConnectivityIndexingMode": "STATUS",+ "namedShadowIndexingMode": "ON",+ "customFields": [{"name": "attributes.site", "type": "String"}],+ "filter": {+ "namedShadowNames": ["config"],+ "geoLocations": [{"name": "shadow.reported.location", "order": "LatLon"}]+ }+ },+ "thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "ON"}+ }+ """);++ given()+ .header("Authorization", auth)+ .when()+ .get("/indexing/config")+ .then()+ .statusCode(200)+ .body("thingIndexingConfiguration.thingIndexingMode", equalTo("REGISTRY_AND_SHADOW"))+ .body("thingIndexingConfiguration.thingConnectivityIndexingMode", equalTo("STATUS"))+ .body("thingIndexingConfiguration.deviceDefenderIndexingMode", equalTo("OFF"))+ .body("thingIndexingConfiguration.namedShadowIndexingMode", equalTo("ON"))+ .body("thingIndexingConfiguration.managedFields", hasSize(17))+ .body("thingIndexingConfiguration.managedFields.name", hasItems("thingName", "registry.thingGroupNames",+ "shadow.hasDelta", "shadow.name.*.version", "connectivity.connected", "connectivity.sessionExpiry"))+ .body("thingIndexingConfiguration.managedFields.find { it.name == 'connectivity.connected' }.type",+ equalTo("Boolean"))+ .body("thingIndexingConfiguration.customFields", hasSize(1))+ .body("thingIndexingConfiguration.customFields[0].name", equalTo("attributes.site"))+ .body("thingIndexingConfiguration.customFields[0].type", equalTo("String"))+ .body("thingIndexingConfiguration.filter.namedShadowNames", contains("config"))+ .body("thingIndexingConfiguration.filter.geoLocations", hasSize(1))+ .body("thingIndexingConfiguration.filter.geoLocations[0].name", equalTo("shadow.reported.location"))+ .body("thingIndexingConfiguration.filter.geoLocations[0].order", equalTo("LatLon"))+ .body("thingIndexingConfiguration.filter.connectivity.includeSocketInformation", empty())+ .body("thingGroupIndexingConfiguration.thingGroupIndexingMode", equalTo("ON"))+ .body("thingGroupIndexingConfiguration.managedFields.name", containsInAnyOrder("parentGroupNames",+ "description", "version", "thingGroupName", "thingGroupId"));+ }++ @Test+ void describeIndexReportsAnActiveSchemaUntilIndexingIsTurnedOff() {+ String auth = auth("111100000003", "us-east-1");+ update(auth, """+ {+ "thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY", "thingConnectivityIndexingMode": "STATUS"},+ "thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "ON"}+ }+ """);++ given()+ .header("Authorization", auth)+ .when()+ .get("/indices/AWS_Things")+ .then()+ .statusCode(200)+ .body("indexName", equalTo("AWS_Things"))+ .body("indexStatus", equalTo("ACTIVE"))+ .body("schema", equalTo("REGISTRY_AND_CONNECTIVITY_STATUS"));+ given()+ .header("Authorization", auth)+ .when()+ .get("/indices/AWS_ThingGroups")+ .then()+ .statusCode(200)+ .body("indexName", equalTo("AWS_ThingGroups"))+ .body("indexStatus", equalTo("ACTIVE"))+ .body("schema", equalTo("REGISTRY"));++ update(auth, """+ {"thingIndexingConfiguration": {"thingIndexingMode": "OFF"}}+ """);++ given()+ .header("Authorization", auth)+ .when()+ .get("/indices/AWS_Things")+ .then()+ .statusCode(404)+ .body("__type", equalTo("ResourceNotFoundException"))+ .body("message", equalTo("Index AWS_Things does not exist"));+ given()+ .header("Authorization", auth)+ .when()+ .get("/indices/AWS_ThingGroups")+ .then()+ .statusCode(200)+ .body("schema", equalTo("REGISTRY"));+ given()+ .header("Authorization", auth)+ .when()+ .get("/indexing/config")+ .then()+ .statusCode(200)+ .body("thingIndexingConfiguration.thingIndexingMode", equalTo("OFF"))+ .body("thingIndexingConfiguration.thingConnectivityIndexingMode", equalTo("OFF"))+ .body("thingIndexingConfiguration", not(hasKey("managedFields")))+ .body("thingIndexingConfiguration.filter", anEmptyMap())+ .body("thingGroupIndexingConfiguration.thingGroupIndexingMode", equalTo("ON"));+ given()+ .header("Authorization", auth)+ .when()+ .get("/indices/Nope")+ .then()+ .statusCode(400)+ .body("__type", equalTo("InvalidRequestException"))+ .body("message", equalTo("Unrecognized indexName Nope"));+ }++ @Test+ void configurationIsIsolatedPerAccountAndRegion() {+ String home = auth("111100000004", "us-east-1");+ update(home, """+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY"}}+ """);++ given()+ .header("Authorization", auth("111100000005", "us-east-1"))+ .when()+ .get("/indexing/config")+ .then()+ .statusCode(200)+ .body("thingIndexingConfiguration.thingIndexingMode", equalTo("OFF"));+ given()+ .header("Authorization", auth("111100000005", "us-east-1"))+ .when()+ .get("/indices/AWS_Things")+ .then()+ .statusCode(404)+ .body("__type", equalTo("ResourceNotFoundException"));+ given()+ .header("Authorization", auth("111100000004", "eu-west-1"))+ .when()+ .get("/indexing/config")+ .then()+ .statusCode(200)+ .body("thingIndexingConfiguration.thingIndexingMode", equalTo("OFF"));+ given()+ .header("Authorization", home)+ .when()+ .get("/indexing/config")+ .then()+ .statusCode(200)+ .body("thingIndexingConfiguration.thingIndexingMode", equalTo("REGISTRY"));+ }++ @Test+ void invalidUpdatesAreRejectedAndStoreNothing() {+ String auth = auth("111100000006", "us-east-1");+ given()+ .header("Authorization", auth)+ .contentType("application/json")+ .body("{\"thingIndexingConfiguration\": ")+ .when()+ .post("/indexing/config")+ .then()+ .statusCode(400)+ .body("__type", equalTo("SerializationException"));+ given()+ .header("Authorization", auth)+ .contentType("application/json")+ .body("""+ {"thingIndexingConfiguration": {}}+ """)+ .when()+ .post("/indexing/config")+ .then()+ .statusCode(400)+ .body("__type", equalTo("InvalidRequestException"))+ .body("message", equalTo("1 validation error detected: Value null at "+ + "'thingIndexingConfiguration.thingIndexingMode' failed to satisfy constraint: "+ + "Member must not be null"));+ given()+ .header("Authorization", auth)+ .contentType("application/json")+ .body("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY",+ "managedFields": [{"name": "shadow.name.building.reported.type", "type": "String"}]}}+ """)+ .when()+ .post("/indexing/config")+ .then()+ .statusCode(400)+ .body("__type", equalTo("InvalidRequestException"))+ .body("message", startsWith("Only managed fields with expected types are allowed"));++ given()+ .header("Authorization", auth)+ .when()+ .get("/indexing/config")+ .then()+ .statusCode(200)+ .body("thingIndexingConfiguration.thingIndexingMode", equalTo("OFF"));+ }++ @Test+ void anUpdateBodyWithTrailingContentIsASerializationError() {+ String auth = auth("111100000007", "us-east-1");+ given()+ .header("Authorization", auth)+ .contentType("application/json")+ .body("{\"thingIndexingConfiguration\": {\"thingIndexingMode\": \"REGISTRY\"}} trailing")+ .when()+ .post("/indexing/config")+ .then()+ .statusCode(400)+ .header("x-amzn-ErrorType", equalTo("SerializationException"))+ .body("__type", equalTo("SerializationException"));++ given()+ .header("Authorization", auth)+ .when()+ .get("/indexing/config")+ .then()+ .statusCode(200)+ .body("thingIndexingConfiguration.thingIndexingMode", equalTo("OFF"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/iot/IotFleetIndexingServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/iot/IotFleetIndexingServiceTest.javanew file mode 100644index 0000000000..34699f60f3--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iot/IotFleetIndexingServiceTest.java@@ -0,0 +1,678 @@+package io.github.hectorvent.floci.services.iot;++import com.fasterxml.jackson.core.JsonProcessingException;+import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import io.github.hectorvent.floci.services.iot.model.IotIndexingConfiguration;+import io.github.hectorvent.floci.services.iot.model.IotIndexingConfiguration.Field;+import io.github.hectorvent.floci.services.iot.model.IotIndexingConfiguration.GeoLocation;+import io.github.hectorvent.floci.services.iot.model.IotIndexingConfiguration.ThingIndexing;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;+import org.junit.jupiter.params.provider.ValueSource;++import java.util.HashSet;+import java.util.List;+import java.util.Map;+import java.util.Set;+import java.util.stream.Stream;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;++class IotFleetIndexingServiceTest {++ private static final String REGION = "us-east-1";++ private static final List<Field> REGISTRY = List.of(+ new Field("thingName", "String"),+ new Field("thingId", "String"),+ new Field("registry.version", "Number"),+ new Field("registry.thingTypeName", "String"),+ new Field("registry.thingGroupNames", "String"));+ private static final List<Field> SHADOW = List.of(+ new Field("shadow.version", "Number"),+ new Field("shadow.hasDelta", "Boolean"));+ private static final List<Field> NAMED_SHADOW = List.of(+ new Field("shadow.name.*.hasDelta", "Boolean"),+ new Field("shadow.name.*.version", "Number"));+ private static final List<Field> CONNECTIVITY = List.of(+ new Field("connectivity.connected", "Boolean"),+ new Field("connectivity.timestamp", "Number"),+ new Field("connectivity.disconnectReason", "String"),+ new Field("connectivity.clientId", "String"),+ new Field("connectivity.cleanSession", "Boolean"),+ new Field("connectivity.keepAliveDuration", "Number"),+ new Field("connectivity.sessionExpiry", "Number"),+ new Field("connectivity.version", "Number"));+ private static final List<Field> DEVICE_DEFENDER = List.of(+ new Field("deviceDefender.version", "Number"),+ new Field("deviceDefender.violationCount", "Number"),+ new Field("deviceDefender.*.*.inViolation", "Boolean"),+ new Field("deviceDefender.*.*.lastViolationTime", "Number"),+ new Field("deviceDefender.*.*.metricName", "String"));+ private static final List<Field> THING_GROUP = List.of(+ new Field("parentGroupNames", "String"),+ new Field("description", "String"),+ new Field("version", "Number"),+ new Field("thingGroupName", "String"),+ new Field("thingGroupId", "String"));++ private final ObjectMapper mapper = new ObjectMapper();+ private final IotFleetIndexingService service = new IotFleetIndexingService(new InMemoryStorage<>());++ private JsonNode json(String text) {+ try {+ return mapper.readTree(text);+ } catch (JsonProcessingException e) {+ throw new IllegalArgumentException(e);+ }+ }++ private void update(String body) {+ service.updateIndexingConfiguration(json(body), REGION);+ }++ private ThingIndexing thing() {+ return service.getIndexingConfiguration(REGION).thing();+ }++ private Set<Field> managedFieldsAfter(String body) {+ update(body);+ return new HashSet<>(IotFleetIndexingService.thingManagedFields(thing()));+ }++ @SafeVarargs+ private static Set<Field> union(List<Field>... groups) {+ Set<Field> fields = new HashSet<>();+ Stream.of(groups).forEach(fields::addAll);+ return fields;+ }++ private void assertRejected(String body, String message) {+ AwsException failure = assertThrows(AwsException.class, () -> update(body));+ assertEquals("InvalidRequestException", failure.getErrorCode());+ assertEquals(400, failure.getHttpStatus());+ assertEquals(message, failure.getMessage());+ }++ private void assertSerializationError(String body) {+ AwsException failure = assertThrows(AwsException.class, () -> update(body), body);+ assertEquals("SerializationException", failure.getErrorCode(), body);+ assertEquals(400, failure.getHttpStatus(), body);+ }++ private static String enumError(String value, String path, String allowed) {+ return "Value '" + value + "' at '" + path+ + "' failed to satisfy constraint: Member must satisfy enum value set: " + allowed;+ }++ private void assertDescribeFails(String indexName, String code, int status, String message) {+ AwsException failure = assertThrows(AwsException.class, () -> service.describeIndex(indexName, REGION));+ assertEquals(code, failure.getErrorCode());+ assertEquals(status, failure.getHttpStatus());+ assertEquals(message, failure.getMessage());+ }++ @Test+ void unsetConfigurationIsOff() {+ IotIndexingConfiguration configuration = service.getIndexingConfiguration(REGION);++ assertEquals(IotIndexingConfiguration.OFF, configuration);+ assertEquals(List.of(), IotFleetIndexingService.thingManagedFields(configuration.thing()));+ }++ @Test+ void registryModeManagesRegistryFieldsAndDefaultsTheRest() {+ update("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY"}}+ """);++ assertEquals(new ThingIndexing("REGISTRY", "OFF", "OFF", "OFF", List.of(), List.of(), List.of(), List.of()),+ thing());+ assertEquals(new HashSet<>(REGISTRY), new HashSet<>(IotFleetIndexingService.thingManagedFields(thing())));+ assertEquals("OFF", service.getIndexingConfiguration(REGION).thingGroupIndexingMode());+ }++ @Test+ void eachModeAddsItsManagedFields() {+ assertEquals(union(REGISTRY, SHADOW), managedFieldsAfter("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY_AND_SHADOW"}}+ """));+ assertEquals(union(REGISTRY, CONNECTIVITY), managedFieldsAfter("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY", "thingConnectivityIndexingMode": "STATUS"}}+ """));+ assertEquals(union(REGISTRY, NAMED_SHADOW), managedFieldsAfter("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY", "namedShadowIndexingMode": "ON",+ "filter": {"namedShadowNames": ["config"]}}}+ """));+ assertEquals(union(REGISTRY, DEVICE_DEFENDER), managedFieldsAfter("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY", "deviceDefenderIndexingMode": "VIOLATIONS"}}+ """));+ assertEquals(union(REGISTRY, SHADOW, NAMED_SHADOW, CONNECTIVITY, DEVICE_DEFENDER), managedFieldsAfter("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY_AND_SHADOW",+ "thingConnectivityIndexingMode": "STATUS", "deviceDefenderIndexingMode": "VIOLATIONS",+ "namedShadowIndexingMode": "ON", "filter": {"namedShadowNames": ["config"]}}}+ """));+ }++ @Test+ void thingGroupIndexingManagesGroupFields() {+ update("""+ {"thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "ON"}}+ """);++ assertEquals("ON", service.getIndexingConfiguration(REGION).thingGroupIndexingMode());+ assertEquals(new HashSet<>(THING_GROUP), new HashSet<>(IotFleetIndexingService.THING_GROUP_MANAGED_FIELDS));+ }++ @Test+ void clientSentFilterAndCustomFieldsAreKept() {+ update("""+ {"thingIndexingConfiguration": {+ "thingIndexingMode": "REGISTRY_AND_SHADOW",+ "namedShadowIndexingMode": "ON",+ "customFields": [{"name": "attributes.site", "type": "String"}],+ "filter": {+ "namedShadowNames": ["config", "state"],+ "geoLocations": [{"name": "shadow.reported.location", "order": "LatLon"}],+ "connectivity": {"includeSocketInformation": ["GET_THING_CONNECTIVITY_DATA"]}+ }}}+ """);++ assertEquals(new ThingIndexing("REGISTRY_AND_SHADOW", "OFF", "OFF", "ON", List.of("config", "state"),+ List.of(new GeoLocation("shadow.reported.location", "LatLon")), List.of("GET_THING_CONNECTIVITY_DATA"),+ List.of(new Field("attributes.site", "String"))), thing());+ }++ @Test+ void aGeoLocationWithoutAnOrderIsStoredAsLatLon() {+ update("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY_AND_SHADOW",+ "filter": {"geoLocations": [{"name": "shadow.name.building.reported.location"}]}}}+ """);++ assertEquals(List.of(new GeoLocation("shadow.name.building.reported.location", "LatLon")),+ thing().geoLocations());+ }++ @Test+ void turningThingIndexingOffResetsTheThingConfiguration() {+ update("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY_AND_SHADOW",+ "thingConnectivityIndexingMode": "STATUS", "namedShadowIndexingMode": "ON",+ "customFields": [{"name": "attributes.site", "type": "String"}],+ "filter": {"namedShadowNames": ["config"]}}}+ """);++ update("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "OFF",+ "customFields": [{"name": "attributes.site", "type": "String"}],+ "filter": {"namedShadowNames": ["config"]}}}+ """);++ assertEquals(ThingIndexing.OFF, thing());+ assertEquals(List.of(), IotFleetIndexingService.thingManagedFields(thing()));+ }++ @Test+ void updatingOneConfigurationLeavesTheOtherUnchanged() {+ update("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY"},+ "thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "ON"}}+ """);++ update("""+ {"thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "OFF"}}+ """);+ assertEquals("REGISTRY", thing().thingIndexingMode());++ update("""+ {"thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "ON"}}+ """);+ update("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY_AND_SHADOW"}}+ """);+ assertEquals("REGISTRY_AND_SHADOW", thing().thingIndexingMode());+ assertEquals("ON", service.getIndexingConfiguration(REGION).thingGroupIndexingMode());+ }++ @Test+ void configurationIsKeptPerRegion() {+ update("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY"}}+ """);++ assertEquals(IotIndexingConfiguration.OFF, service.getIndexingConfiguration("eu-west-1"));+ assertEquals("REGISTRY", thing().thingIndexingMode());+ }++ @Test+ void updateWithoutAnyConfigurationIsRejected() {+ String message = "At least one configuration to update "+ + "(thingIndexingConfiguration / thingGroupIndexingConfiguration) is required";+ assertRejected("{}", message);+ assertRejected("""+ {"thingIndexingConfiguration": null}+ """, message);+ }++ @Test+ void missingModesAreReportedAsNullMembers() {+ assertRejected("""+ {"thingIndexingConfiguration": {}}+ """, "1 validation error detected: Value null at 'thingIndexingConfiguration.thingIndexingMode' "+ + "failed to satisfy constraint: Member must not be null");+ assertRejected("""+ {"thingGroupIndexingConfiguration": {}}+ """, "1 validation error detected: Value null at 'thingGroupIndexingConfiguration.thingGroupIndexingMode' "+ + "failed to satisfy constraint: Member must not be null");+ }++ @Test+ void enumViolationsAreReportedWithAwsValueSets() {+ Map<String, String> violations = Map.of(+ """+ {"thingIndexingConfiguration": {"thingIndexingMode": "BOGUS"}}+ """, enumError("BOGUS", "thingIndexingConfiguration.thingIndexingMode",+ "[REGISTRY_AND_SHADOW, OFF, REGISTRY]"),+ """+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY", "thingConnectivityIndexingMode": "BOGUS"}}+ """, enumError("BOGUS", "thingIndexingConfiguration.thingConnectivityIndexingMode", "[OFF, STATUS]"),+ """+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY", "deviceDefenderIndexingMode": "BOGUS"}}+ """, enumError("BOGUS", "thingIndexingConfiguration.deviceDefenderIndexingMode", "[VIOLATIONS, OFF]"),+ """+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY", "namedShadowIndexingMode": "BOGUS"}}+ """, enumError("BOGUS", "thingIndexingConfiguration.namedShadowIndexingMode", "[OFF, ON]"),+ """+ {"thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "BOGUS"}}+ """, enumError("BOGUS", "thingGroupIndexingConfiguration.thingGroupIndexingMode", "[OFF, ON]"),+ """+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY",+ "customFields": [{"name": "attributes.site", "type": "Bogus"}]}}+ """, enumError("Bogus", "thingIndexingConfiguration.customFields.1.member.type",+ "[Boolean, Number, String]"));++ violations.forEach((body, error) -> assertRejected(body, "1 validation error detected: " + error));+ }++ @Test+ void severalViolationsAreReportedTogether() {+ AwsException failure = assertThrows(AwsException.class, () -> update("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "BOGUS", "thingConnectivityIndexingMode": "BOGUS"}}+ """));++ assertEquals("InvalidRequestException", failure.getErrorCode());+ assertTrue(failure.getMessage().startsWith("2 validation errors detected: "), failure.getMessage());+ assertTrue(failure.getMessage().contains(enumError("BOGUS", "thingIndexingConfiguration.thingIndexingMode",+ "[REGISTRY_AND_SHADOW, OFF, REGISTRY]")), failure.getMessage());+ assertTrue(failure.getMessage().contains("; "), failure.getMessage());+ assertTrue(failure.getMessage().contains(enumError("BOGUS",+ "thingIndexingConfiguration.thingConnectivityIndexingMode", "[OFF, STATUS]")), failure.getMessage());+ }++ @Test+ void filterEnumsAreValidatedEvenWithThingIndexingOff() {+ assertRejected("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "OFF", "filter": {+ "geoLocations": [{"name": "shadow.reported.loc", "order": "BOGUS"}],+ "connectivity": {"includeSocketInformation": ["GetConnection"]}}}}+ """, "2 validation errors detected: Value '[GetConnection]' at "+ + "'thingIndexingConfiguration.filter.connectivity.includeSocketInformation' failed to satisfy "+ + "constraint: Member must satisfy constraint: [Member must satisfy enum value set: "+ + "[GET_THING_CONNECTIVITY_DATA]]; Value 'BOGUS' at "+ + "'thingIndexingConfiguration.filter.geoLocations.1.member.order' failed to satisfy constraint: "+ + "Member must satisfy enum value set: [LatLon, LonLat]");+ }++ @Test+ void secondaryModesNeedThingIndexingOn() {+ assertRejected("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "OFF", "thingConnectivityIndexingMode": "STATUS"}}+ """, "ThingIndexingMode must be turned ON for enabling ThingConnectivityIndexingMode");+ assertRejected("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "OFF", "namedShadowIndexingMode": "ON",+ "filter": {"namedShadowNames": ["config"]}}}+ """, "ThingIndexingMode must be turned ON for enabling NamedShadowIndexingMode");+ assertRejected("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "OFF", "deviceDefenderIndexingMode": "VIOLATIONS"}}+ """, "ThingIndexingMode must be turned ON for enabling DeviceDefenderIndexingMode");+ }++ @Test+ void namedShadowIndexingNeedsShadowNames() {+ String message = "NamedShadowNames Filter must not be empty for enabling NamedShadowIndexingMode";+ assertRejected("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY_AND_SHADOW", "namedShadowIndexingMode": "ON"}}+ """, message);+ assertRejected("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY_AND_SHADOW", "namedShadowIndexingMode": "ON",+ "filter": {"namedShadowNames": []}}}+ """, message);+ }++ @Test+ void managedFieldsMustBeKnownWithTheirExpectedType() {+ String prefix = "Only managed fields with expected types are allowed in "+ + "thingIndexingConfiguration.managedFields. Invalid field(s): ";+ assertRejected("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY",+ "managedFields": [{"name": "thingName", "type": "Number"}]}}+ """, prefix + "[name:thingName, type:Number]");+ assertRejected("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY",+ "managedFields": [{"name": "thingId", "type": "String"}, {"name": "a", "type": "String"},+ {"name": "b", "type": "String"}]}}+ """, prefix + "[name:a, type:String, name:b, type:String]");+ // The configuration TEOS deploys: AWS rejects custom shadow paths sent as managed fields.+ assertRejected("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY_AND_SHADOW", "namedShadowIndexingMode": "ON",+ "filter": {"namedShadowNames": ["building"]},+ "managedFields": [{"name": "shadow.name.building.reported.type", "type": "String"},+ {"name": "shadow.name.building.reported.tz", "type": "String"}]}}+ """, prefix + "[name:shadow.name.building.reported.type, type:String, "+ + "name:shadow.name.building.reported.tz, type:String]");+ }++ @Test+ void knownManagedFieldsAreAcceptedInAnyModeAndNotStored() {+ update("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY",+ "managedFields": [{"name": "shadow.version", "type": "Number"},+ {"name": "connectivity.connected", "type": "Boolean"}]}}+ """);++ assertEquals(new HashSet<>(REGISTRY), new HashSet<>(IotFleetIndexingService.thingManagedFields(thing())));+ }++ @Test+ void rejectedUpdateChangesNothing() {+ update("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY"},+ "thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "ON"}}+ """);++ assertThrows(AwsException.class, () -> update("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY_AND_SHADOW", "namedShadowIndexingMode": "ON"},+ "thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "OFF"}}+ """));++ assertEquals("REGISTRY", thing().thingIndexingMode());+ assertEquals("ON", service.getIndexingConfiguration(REGION).thingGroupIndexingMode());+ }++ // Single quotes stand in for double quotes to keep the bodies on one line.+ @ParameterizedTest+ @ValueSource(strings = {+ "[]",+ "'x'",+ "{'thingIndexingConfiguration': 'x'}",+ "{'thingGroupIndexingConfiguration': []}",+ "{'thingIndexingConfiguration': {'thingIndexingMode': 1}}",+ "{'thingGroupIndexingConfiguration': {'thingGroupIndexingMode': 1}}",+ "{'thingIndexingConfiguration': {'thingIndexingMode': 'BOGUS', 'customFields': {}}}",+ "{'thingIndexingConfiguration': {'thingIndexingMode': 'BOGUS'}, "+ + "'thingGroupIndexingConfiguration': {'thingGroupIndexingMode': 'ON', 'customFields': [1]}}"+ })+ void aBodyOrConfigurationOfTheWrongJsonKindIsASerializationError(String body) {+ assertSerializationError(body.replace('\'', '"'));+ }++ @ParameterizedTest+ @ValueSource(strings = {+ "'thingConnectivityIndexingMode': true",+ "'deviceDefenderIndexingMode': {}",+ "'namedShadowIndexingMode': []",+ "'customFields': {}",+ "'customFields': [1]",+ "'customFields': [null]",+ "'customFields': [{'name': 1, 'type': 'String'}]",+ "'customFields': [{'name': 'attributes.x', 'type': 1}]",+ "'managedFields': 'x'",+ "'managedFields': ['thingName']",+ "'filter': 'bad'",+ "'filter': {'namedShadowNames': 'config'}",+ "'filter': {'namedShadowNames': [1]}",+ "'filter': {'namedShadowNames': [null]}",+ "'filter': {'geoLocations': {}}",+ "'filter': {'geoLocations': [1]}",+ "'filter': {'geoLocations': [{'name': 1}]}",+ "'filter': {'geoLocations': [{'name': 'shadow.reported.location', 'order': 1}]}",+ "'filter': {'connectivity': 1}",+ "'filter': {'connectivity': {'includeSocketInformation': 'GET_THING_CONNECTIVITY_DATA'}}",+ "'filter': {'connectivity': {'includeSocketInformation': [1]}}",+ "'filter': {'connectivity': {'includeSocketInformation': [null]}}"+ })+ void aThingMemberOfTheWrongJsonKindIsASerializationError(String member) {+ assertSerializationError(("{'thingIndexingConfiguration': {'thingIndexingMode': 'REGISTRY', " + member + "}}")+ .replace('\'', '"'));+ }++ @ParameterizedTest+ @ValueSource(strings = {+ "'managedFields': 'x'",+ "'managedFields': [null]",+ "'managedFields': [{'name': 'version', 'type': 2}]",+ "'customFields': {}",+ "'customFields': [true]"+ })+ void aThingGroupMemberOfTheWrongJsonKindIsASerializationError(String member) {+ assertSerializationError(("{'thingGroupIndexingConfiguration': {'thingGroupIndexingMode': 'OFF', " + member + "}}")+ .replace('\'', '"'));+ }++ @Test+ void absentAndNullMembersAreNotSent() {+ update("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY", "thingConnectivityIndexingMode": null,+ "customFields": null, "managedFields": null,+ "filter": {"namedShadowNames": null, "geoLocations": null, "connectivity": {"includeSocketInformation": null}}},+ "thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "ON", "managedFields": null, "customFields": null}}+ """);+ assertEquals(new ThingIndexing("REGISTRY", "OFF", "OFF", "OFF", List.of(), List.of(), List.of(), List.of()),+ thing());++ update("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY_AND_SHADOW", "filter": null},+ "thingGroupIndexingConfiguration": null}+ """);+ update("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY_AND_SHADOW", "filter": {"connectivity": null}}}+ """);+ assertEquals(new IotIndexingConfiguration(new ThingIndexing("REGISTRY_AND_SHADOW", "OFF", "OFF", "OFF",+ List.of(), List.of(), List.of(), List.of()), "ON"), service.getIndexingConfiguration(REGION));+ }++ @Test+ void thingCustomFieldsNeedANameAndThenAType() {+ String noName = "Custom field name cannot be nullFieldName: null, FieldType: ";+ String noType = "Invalid field type: null. Expecting one of [String, Number, Boolean, Geopoint]";+ assertRejected("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY", "customFields": [{}]}}+ """, noName + "null");+ assertRejected("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY", "customFields": [{"type": "String"}]}}+ """, noName + "String");+ assertRejected("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY", "customFields": [{"name": "attributes.x"}]}}+ """, noType);+ assertRejected("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY",+ "customFields": [{"name": "attributes.a"}, {"type": "Number"}]}}+ """, noType);+ assertRejected("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY",+ "customFields": [{"name": "attributes.a", "type": "String"}, {"type": "Number"}]}}+ """, noName + "Number");+ assertRejected("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY", "customFields": [{}],+ "managedFields": [{"name": "bogus", "type": "String"}]}}+ """, noName + "null");+ }++ @Test+ void customFieldTypeViolationsAreReportedBeforeAMissingName() {+ assertRejected("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY",+ "customFields": [{}, {"name": "attributes.x", "type": "Bogus"}]}}+ """, "1 validation error detected: " + enumError("Bogus",+ "thingIndexingConfiguration.customFields.2.member.type", "[Boolean, Number, String]"));+ }++ @ParameterizedTest+ @CsvSource({+ "thingName, String",+ "registry.version, Number",+ "connectivity.connected, Boolean"+ })+ void aThingCustomFieldNamedAfterAManagedFieldIsRejected(String name, String type) {+ assertRejected(("{'thingIndexingConfiguration': {'thingIndexingMode': 'REGISTRY_AND_SHADOW', "+ + "'thingConnectivityIndexingMode': 'STATUS', "+ + "'customFields': [{'name': '" + name + "', 'type': '" + type + "'}]}}").replace('\'', '"'),+ "Defined field is a reserved field for MULTI_INDEXING_MODE. Field: " + name);+ }++ @Test+ void theFirstReservedCustomFieldNameIsReportedWhateverItsType() {+ assertRejected("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY_AND_SHADOW",+ "thingConnectivityIndexingMode": "STATUS",+ "customFields": [{"name": "shadow.name.building.reported.x", "type": "String"},+ {"name": "thingName", "type": "Number"},+ {"name": "registry.version", "type": "String"}]}}+ """, "Defined field is a reserved field for MULTI_INDEXING_MODE. Field: thingName");+ }++ @Test+ void thingGroupManagedFieldsMustBeKnownWithTheirExpectedTypeInEitherMode() {+ String prefix = "Only managed fields with expected types are allowed in "+ + "thingGroupIndexingConfiguration.managedFields. Invalid field(s): ";+ assertRejected("""+ {"thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "ON",+ "managedFields": [{"name": "bogus", "type": "String"}]}}+ """, prefix + "[name:bogus, type:String]");+ assertRejected("""+ {"thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "OFF",+ "managedFields": [{"name": "bogus", "type": "String"}]}}+ """, prefix + "[name:bogus, type:String]");+ assertRejected("""+ {"thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "ON",+ "managedFields": [{"name": "version", "type": "Number"}, {"name": "description", "type": "Number"}]}}+ """, prefix + "[name:description, type:Number]");+ }++ @Test+ void thingGroupFieldTypesAreValidated() {+ assertRejected("""+ {"thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "ON",+ "managedFields": [{"name": "description", "type": "Bogus"}]}}+ """, "1 validation error detected: " + enumError("Bogus",+ "thingGroupIndexingConfiguration.managedFields.1.member.type", "[Boolean, Number, String]"));+ assertRejected("""+ {"thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "OFF",+ "customFields": [{"name": "attributes.x", "type": "Bogus"}]}}+ """, "1 validation error detected: " + enumError("Bogus",+ "thingGroupIndexingConfiguration.customFields.1.member.type", "[Boolean, Number, String]"));+ }++ @Test+ void thingGroupFieldsAreAcceptedButNotStored() {+ update("""+ {"thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "ON",+ "managedFields": [{"name": "parentGroupNames", "type": "String"}, {"name": "description", "type": "String"},+ {"name": "version", "type": "Number"}, {"name": "thingGroupName", "type": "String"},+ {"name": "thingGroupId", "type": "String"}],+ "customFields": [{"name": "attributes.x", "type": "String"}, {}]}}+ """);++ assertEquals(new IotIndexingConfiguration(ThingIndexing.OFF, "ON"), service.getIndexingConfiguration(REGION));+ }++ @Test+ void rejectedThingGroupFieldsChangeNothing() {+ update("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY"},+ "thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "ON"}}+ """);+ IotIndexingConfiguration stored = service.getIndexingConfiguration(REGION);++ assertRejected("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "OFF"},+ "thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "OFF",+ "managedFields": [{"name": "bogus", "type": "String"}]}}+ """, "Only managed fields with expected types are allowed in "+ + "thingGroupIndexingConfiguration.managedFields. Invalid field(s): [name:bogus, type:String]");+ assertSerializationError("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "OFF"},+ "thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "OFF", "customFields": {}}}+ """);++ assertEquals(stored, service.getIndexingConfiguration(REGION));+ }++ @Test+ void describeIndexSchemaFollowsTheModes() {+ Map<String, String> schemas = Map.of(+ """+ {"thingIndexingMode": "REGISTRY"}+ """, "REGISTRY",+ """+ {"thingIndexingMode": "REGISTRY_AND_SHADOW"}+ """, "REGISTRY_AND_SHADOW",+ """+ {"thingIndexingMode": "REGISTRY", "thingConnectivityIndexingMode": "STATUS"}+ """, "REGISTRY_AND_CONNECTIVITY_STATUS",+ """+ {"thingIndexingMode": "REGISTRY_AND_SHADOW", "thingConnectivityIndexingMode": "STATUS"}+ """, "REGISTRY_AND_SHADOW_AND_CONNECTIVITY_STATUS",+ """+ {"thingIndexingMode": "REGISTRY", "deviceDefenderIndexingMode": "VIOLATIONS"}+ """, "MULTI_INDEXING_MODE",+ """+ {"thingIndexingMode": "REGISTRY_AND_SHADOW", "thingConnectivityIndexingMode": "STATUS",+ "namedShadowIndexingMode": "ON", "filter": {"namedShadowNames": ["config"]}}+ """, "MULTI_INDEXING_MODE");++ schemas.forEach((thingConfiguration, schema) -> {+ update("{\"thingIndexingConfiguration\": " + thingConfiguration + "}");+ assertEquals(schema, service.describeIndex("AWS_Things", REGION), thingConfiguration);+ });++ update("""+ {"thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "ON"}}+ """);+ assertEquals("REGISTRY", service.describeIndex("AWS_ThingGroups", REGION));+ }++ @Test+ void describeIndexOfADisabledIndexIsNotFound() {+ assertDescribeFails("AWS_Things", "ResourceNotFoundException", 404, "Index AWS_Things does not exist");+ assertDescribeFails("AWS_ThingGroups", "ResourceNotFoundException", 404,+ "Index AWS_ThingGroups does not exist");++ update("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY"},+ "thingGroupIndexingConfiguration": {"thingGroupIndexingMode": "ON"}}+ """);+ update("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "OFF"}}+ """);+ assertDescribeFails("AWS_Things", "ResourceNotFoundException", 404, "Index AWS_Things does not exist");+ assertEquals("REGISTRY", service.describeIndex("AWS_ThingGroups", REGION));+ }++ @Test+ void describeIndexOfAnUnknownNameIsInvalid() {+ assertDescribeFails("Nope", "InvalidRequestException", 400, "Unrecognized indexName Nope");++ update("""+ {"thingIndexingConfiguration": {"thingIndexingMode": "REGISTRY"}}+ """);+ assertDescribeFails("AWS_Thing", "InvalidRequestException", 400, "Unrecognized indexName AWS_Thing");+ }+}