Light, fluffy, and always free - The AWS Local Emulator alternative
fix(dynamodb): evaluate legacy Expected under the item lock (#6278)
Dmitriy Polomoshnovf94e0583b723
diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbService.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbService.javaindex d0f77cdd7d..b19f3fa5c0 100644--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbService.java+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbService.java@@ -967,10 +967,24 @@ public class DynamoDbService {String conditionExpression,JsonNode exprAttrNames, JsonNode exprAttrValues,String region, String returnValuesOnConditionCheckFailure) {- var canonicalTableName = canonicalTableName(region, tableName);+ return putItem(tableName, item, conditionExpression, exprAttrNames, exprAttrValues,+ region, returnValuesOnConditionCheckFailure, null);+ }++ /**+ * As above, and {@code existingItemCheck}, when present, receives the stored item (null when+ * absent) under the item's lock and rejects the put by throwing. A check made against an item+ * read before the lock is taken can be invalidated by a concurrent write.+ */+ public JsonNode putItem(String tableName, JsonNode item,+ String conditionExpression,+ JsonNode exprAttrNames, JsonNode exprAttrValues,+ String region, String returnValuesOnConditionCheckFailure,+ Consumer<JsonNode> existingItemCheck) {+ String canonicalTableName = canonicalTableName(region, tableName);requireActiveTable(regionKey(region, canonicalTableName));return putItemInternal(tableName, item, conditionExpression, exprAttrNames, exprAttrValues,- region, returnValuesOnConditionCheckFailure, true);+ region, returnValuesOnConditionCheckFailure, true, null, null, existingItemCheck);}private JsonNode putItemInternal(String tableName, JsonNode item,@@ -989,7 +1003,7 @@ public class DynamoDbService {boolean shouldPersist,Consumer<Runnable> deferredStreamEvents) {return putItemInternal(tableName, item, conditionExpression, exprAttrNames, exprAttrValues,- region, returnValuesOnConditionCheckFailure, shouldPersist, deferredStreamEvents, null);+ region, returnValuesOnConditionCheckFailure, shouldPersist, deferredStreamEvents, null, null);}private JsonNode putItemInternal(String tableName, JsonNode item,@@ -998,7 +1012,8 @@ public class DynamoDbService {String region, String returnValuesOnConditionCheckFailure,boolean shouldPersist,Consumer<Runnable> deferredStreamEvents,- Map<String, ConcurrentSkipListMap<String, JsonNode>> stagedItems) {+ Map<String, ConcurrentSkipListMap<String, JsonNode>> stagedItems,+ Consumer<JsonNode> existingItemCheck) {String canonicalTableName = canonicalTableName(region, tableName);String storageKey = regionKey(region, canonicalTableName);TableDefinition table = tableStore.get(storageKey)@@ -1018,6 +1033,9 @@ public class DynamoDbService {if (conditionExpression != null) {evaluateCondition(existing, conditionExpression, exprAttrNames, exprAttrValues, returnValuesOnConditionCheckFailure);}+ if (existingItemCheck != null) {+ existingItemCheck.accept(existing);+ }requireItemNestingWithinLimit(normalizedItem);if (stagedItems == null) {@@ -1076,8 +1094,21 @@ public class DynamoDbService {String conditionExpression,JsonNode exprAttrNames, JsonNode exprAttrValues,String region, String returnValuesOnConditionCheckFailure) {+ return deleteItem(tableName, key, conditionExpression, exprAttrNames, exprAttrValues,+ region, returnValuesOnConditionCheckFailure, null);+ }++ /**+ * As above, and {@code existingItemCheck}, when present, receives the stored item (null when+ * absent) under the item's lock and rejects the delete by throwing.+ */+ public JsonNode deleteItem(String tableName, JsonNode key,+ String conditionExpression,+ JsonNode exprAttrNames, JsonNode exprAttrValues,+ String region, String returnValuesOnConditionCheckFailure,+ Consumer<JsonNode> existingItemCheck) {return deleteItemInternal(tableName, key, conditionExpression, exprAttrNames, exprAttrValues,- region, returnValuesOnConditionCheckFailure, true);+ region, returnValuesOnConditionCheckFailure, true, null, null, existingItemCheck);}private JsonNode deleteItemInternal(String tableName, JsonNode key,@@ -1096,7 +1127,7 @@ public class DynamoDbService {boolean shouldPersist,Consumer<Runnable> deferredStreamEvents) {return deleteItemInternal(tableName, key, conditionExpression, exprAttrNames, exprAttrValues,- region, returnValuesOnConditionCheckFailure, shouldPersist, deferredStreamEvents, null);+ region, returnValuesOnConditionCheckFailure, shouldPersist, deferredStreamEvents, null, null);}private JsonNode deleteItemInternal(String tableName, JsonNode key,@@ -1105,7 +1136,8 @@ public class DynamoDbService {String region, String returnValuesOnConditionCheckFailure,boolean shouldPersist,Consumer<Runnable> deferredStreamEvents,- Map<String, ConcurrentSkipListMap<String, JsonNode>> stagedItems) {+ Map<String, ConcurrentSkipListMap<String, JsonNode>> stagedItems,+ Consumer<JsonNode> existingItemCheck) {String canonicalTableName = canonicalTableName(region, tableName);String storageKey = regionKey(region, canonicalTableName);TableDefinition table = requireActiveTable(storageKey);@@ -1114,6 +1146,9 @@ public class DynamoDbService {return withItemLock(storageKey, itemKey, () -> {var items = itemsFor(storageKey, stagedItems, false);+ if (existingItemCheck != null) {+ existingItemCheck.accept(items == null ? null : items.get(itemKey));+ }if (items == null) return null;if (conditionExpression != null) {@@ -1174,6 +1209,22 @@ public class DynamoDbService {returnValuesOnConditionCheckFailure, UpdateSizeRule.UPDATE_ITEM);}+ /**+ * As above, and {@code existingItemCheck}, when present, receives the stored item (null when+ * absent) under the item's lock and rejects the update by throwing.+ */+ public UpdateResult updateItem(String tableName, JsonNode key, JsonNode attributeUpdates,+ String updateExpression,+ JsonNode expressionAttrNames, JsonNode expressionAttrValues,+ String returnValues, String conditionExpression, String region,+ String returnValuesOnConditionCheckFailure,+ Consumer<JsonNode> existingItemCheck) {+ return updateItemInternal(tableName, key, attributeUpdates, updateExpression,+ expressionAttrNames, expressionAttrValues, returnValues,+ conditionExpression, region, returnValuesOnConditionCheckFailure, true, null, null,+ UpdateSizeRule.UPDATE_ITEM, existingItemCheck);+ }+UpdateResult updateItem(String tableName, JsonNode key, JsonNode attributeUpdates,String updateExpression,JsonNode expressionAttrNames, JsonNode expressionAttrValues,@@ -1209,7 +1260,7 @@ public class DynamoDbService {return updateItemInternal(tableName, key, attributeUpdates, updateExpression,expressionAttrNames, expressionAttrValues, returnValues,conditionExpression, region, returnValuesOnConditionCheckFailure, shouldPersist,- deferredStreamEvents, null, sizeRule);+ deferredStreamEvents, null, sizeRule, null);}private UpdateResult updateItemInternal(String tableName, JsonNode key, JsonNode attributeUpdates,@@ -1220,7 +1271,8 @@ public class DynamoDbService {boolean shouldPersist,Consumer<Runnable> deferredStreamEvents,Map<String, ConcurrentSkipListMap<String, JsonNode>> stagedItems,- UpdateSizeRule sizeRule) {+ UpdateSizeRule sizeRule,+ Consumer<JsonNode> existingItemCheck) {String canonicalTableName = canonicalTableName(region, tableName);String storageKey = regionKey(region, canonicalTableName);TableDefinition table = requireActiveTable(storageKey);@@ -1236,6 +1288,9 @@ public class DynamoDbService {if (conditionExpression != null) {evaluateCondition(existing, conditionExpression, expressionAttrNames, expressionAttrValues, returnValuesOnConditionCheckFailure);}+ if (existingItemCheck != null) {+ existingItemCheck.accept(existing);+ }ObjectNode item;if (existing != null) {@@ -1896,14 +1951,14 @@ public class DynamoDbService {String tableName = put.path("TableName").asText();String storageKey = regionKey(region, canonicalTableName(region, tableName));putItemInternal(tableName, put.get("Item"), null, null, null, region, "NONE", false,- pendingStreamEvents::add, staged);+ pendingStreamEvents::add, staged, null);affectedStorageKeys.add(storageKey);} else if (transactItem.has("Delete")) {JsonNode del = transactItem.get("Delete");String tableName = del.path("TableName").asText();String storageKey = regionKey(region, canonicalTableName(region, tableName));deleteItemInternal(tableName, del.get("Key"), null, null, null, region, "NONE", false,- pendingStreamEvents::add, staged);+ pendingStreamEvents::add, staged, null);affectedStorageKeys.add(storageKey);} else if (transactItem.has("Update")) {JsonNode upd = transactItem.get("Update");@@ -1914,7 +1969,7 @@ public class DynamoDbService {upd.has("ExpressionAttributeNames") ? upd.get("ExpressionAttributeNames") : null,upd.has("ExpressionAttributeValues") ? upd.get("ExpressionAttributeValues") : null,"NONE", null, region, "NONE", false, pendingStreamEvents::add, staged,- UpdateSizeRule.FINISHED_ITEM);+ UpdateSizeRule.FINISHED_ITEM, null);affectedStorageKeys.add(storageKey);}}@@ -4703,6 +4758,14 @@ public class DynamoDbService {return requireActiveTable(regionKey(region, canonicalTableName));}+ /**+ * Resolves the table for an item call and validates the key it names, without reading the+ * stored item, so a caller can report table and key errors before its own validation.+ */+ public void requireItemCallKey(String tableName, JsonNode keyOrItem, boolean isKeyArg, String region) {+ buildItemKey(requireTableForItemCall(tableName, region), keyOrItem, isKeyArg);+ }+public record UpdateResult(JsonNode newItem, JsonNode oldItem, List<TouchedPath> touched) {}// One path the update expression acted on, with the value there before and after.diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/NativeDynamoDbJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/NativeDynamoDbJsonHandler.javaindex ac18b2a578..0d70b1eb12 100644--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/NativeDynamoDbJsonHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/NativeDynamoDbJsonHandler.java@@ -44,6 +44,7 @@ import java.util.LinkedHashSet;import java.util.List;import java.util.Map;import java.util.Set;+import java.util.function.Consumer;import java.util.function.Supplier;import java.util.regex.Pattern;@@ -626,22 +627,14 @@ public class NativeDynamoDbJsonHandler {validateItemSets(item);- JsonNode oldItem = null;- if ("ALL_OLD".equals(returnValues) || expected != null) {- dynamoDbService.requireTableForItemCall(tableName, region);- oldItem = dynamoDbService.getItem(tableName, item, region);- }-- if (expected != null) {- evaluateLegacyExpected(oldItem, expected, conditionalOperator, returnValuesOnConditionCheckFailure);- }-- var previousItem = dynamoDbService.putItem(tableName, item, conditionExpression,- exprAttrNames, exprAttrValues, region, returnValuesOnConditionCheckFailure);+ Consumer<JsonNode> expectedCheck = legacyExpectedCheck(tableName, region, item, false, expected,+ conditionalOperator, returnValuesOnConditionCheckFailure);+ JsonNode previousItem = dynamoDbService.putItem(tableName, item, conditionExpression,+ exprAttrNames, exprAttrValues, region, returnValuesOnConditionCheckFailure, expectedCheck);ObjectNode response = objectMapper.createObjectNode();- if ("ALL_OLD" .equals(returnValues) && oldItem != null) {- response.set("Attributes", oldItem);+ if ("ALL_OLD".equals(returnValues) && previousItem != null) {+ response.set("Attributes", previousItem);}addItemCollectionMetrics(response, request, tableName, item, region);addWriteConsumedCapacity(response, request, tableName, region, previousItem, item);@@ -745,13 +738,10 @@ public class NativeDynamoDbJsonHandler {String condOpDel = request.has("ConditionalOperator")? request.get("ConditionalOperator").asText() : "AND";- if (expectedDel != null) {- JsonNode existingForDel = dynamoDbService.getItem(tableName, key, region);- evaluateLegacyExpected(existingForDel, expectedDel, condOpDel, returnValuesOnConditionCheckFailure);- }-+ Consumer<JsonNode> expectedCheck = legacyExpectedCheck(tableName, region, key, true, expectedDel,+ condOpDel, returnValuesOnConditionCheckFailure);JsonNode oldItem = dynamoDbService.deleteItem(tableName, key, conditionExpression,- exprAttrNames, exprAttrValues, region, returnValuesOnConditionCheckFailure);+ exprAttrNames, exprAttrValues, region, returnValuesOnConditionCheckFailure, expectedCheck);ObjectNode response = objectMapper.createObjectNode();if ("ALL_OLD" .equals(returnValues) && oldItem != null) {@@ -855,14 +845,11 @@ public class NativeDynamoDbJsonHandler {ExpressionEvaluator.validateSemantics(conditionExpression, "ConditionExpression", exprAttrNames, exprAttrValues);}- if (expectedUpd != null) {- JsonNode existingForUpd = dynamoDbService.getItem(tableName, key, region);- evaluateLegacyExpected(existingForUpd, expectedUpd, conditionalOperatorUpd, returnValuesOnConditionCheckFailure);- }-+ Consumer<JsonNode> expectedCheck = legacyExpectedCheck(tableName, region, key, true, expectedUpd,+ conditionalOperatorUpd, returnValuesOnConditionCheckFailure);DynamoDbService.UpdateResult result = dynamoDbService.updateItem(tableName, key, updateData, updateExpression, exprAttrNames, exprAttrValues,- returnValues, conditionExpression, region, returnValuesOnConditionCheckFailure);+ returnValues, conditionExpression, region, returnValuesOnConditionCheckFailure, expectedCheck);ObjectNode response = objectMapper.createObjectNode();if ("ALL_NEW" .equals(returnValues) && result.newItem() != null) {@@ -881,10 +868,26 @@ public class NativeDynamoDbJsonHandler {return Response.ok(response).build();}+ /**+ * Validates a legacy Expected map and returns its evaluation, for the service to run against+ * the stored item under the item's lock, or null when the request has no Expected. The table+ * and the key are checked first, so their errors take precedence over the map's.+ */+ private Consumer<JsonNode> legacyExpectedCheck(String tableName, String region, JsonNode keyOrItem,+ boolean isKeyArg, JsonNode expected,+ String conditionalOperator,+ String returnValuesOnConditionCheckFailure) {+ if (expected == null) {+ return null;+ }+ dynamoDbService.requireItemCallKey(tableName, keyOrItem, isKeyArg, region);+ validateLegacyExpected(expected);+ return existing -> evaluateLegacyExpected(existing, expected, conditionalOperator,+ returnValuesOnConditionCheckFailure);+ }+private void evaluateLegacyExpected(JsonNode existing, JsonNode expected, String conditionalOperator,String returnValuesOnConditionCheckFailure) {- if (expected == null) return;- validateLegacyExpected(expected);boolean useOr = "OR".equals(conditionalOperator);boolean overall = !useOr;var fields = expected.fields();diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbConcurrencyIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbConcurrencyIntegrationTest.javaindex 732fc61cbe..69ab52c256 100644--- a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbConcurrencyIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbConcurrencyIntegrationTest.java@@ -18,6 +18,7 @@ import io.github.hectorvent.floci.services.dynamodb.model.TableDefinition;import io.github.hectorvent.floci.services.kinesis.KinesisService;import io.github.hectorvent.floci.services.kinesis.model.KinesisRecord;import io.github.hectorvent.floci.services.kinesis.model.KinesisStream;+import io.github.hectorvent.floci.testing.StartGate;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.RepeatedTest;import org.junit.jupiter.api.Test;@@ -30,10 +31,6 @@ import java.util.List;import java.util.Map;import java.util.Set;import java.util.concurrent.ConcurrentHashMap;-import java.util.concurrent.CountDownLatch;-import java.util.concurrent.ExecutorService;-import java.util.concurrent.Executors;-import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.AtomicInteger;import static org.junit.jupiter.api.Assertions.*;@@ -45,7 +42,7 @@ import static org.mockito.Mockito.when;/*** Concurrency compatibility suite for {@link DynamoDbService}.*- * <p>All scenarios use a {@link CountDownLatch} starting gate so threads release+ * <p>All scenarios use a {@link StartGate} so threads release* simultaneously, maximising contention. Wrapped in {@code @RepeatedTest(5)} so a* regression that surfaces intermittently has a real chance of being observed in a* single CI run.@@ -106,32 +103,10 @@ class DynamoDbConcurrencyIntegrationTest {/** Run {@code work} in {@code threadCount} threads, released together. */private List<Throwable> runConcurrently(int threadCount, Runnable work) throws InterruptedException {- ExecutorService pool = Executors.newFixedThreadPool(threadCount);- CountDownLatch startGate = new CountDownLatch(1);- CountDownLatch doneGate = new CountDownLatch(threadCount);- List<Throwable> errors = Collections.synchronizedList(new ArrayList<>());- try {- for (int i = 0; i < threadCount; i++) {- pool.submit(() -> {- try {- startGate.await();- work.run();- } catch (Throwable t) {- errors.add(t);- } finally {- doneGate.countDown();- }- });- }- startGate.countDown();- assertTrue(doneGate.await(30, TimeUnit.SECONDS),- "concurrent tasks did not complete within 30s");- return errors;- } finally {- pool.shutdownNow();- assertTrue(pool.awaitTermination(5, TimeUnit.SECONDS),- "thread pool did not terminate");- }+ return StartGate.runConcurrently(threadCount, i -> {+ work.run();+ return null;+ }).errors();}@RepeatedTest(REPEATS)diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbLegacyExpectedIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbLegacyExpectedIntegrationTest.javanew file mode 100644index 0000000000..b8db71083d--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbLegacyExpectedIntegrationTest.java@@ -0,0 +1,197 @@+package io.github.hectorvent.floci.services.dynamodb;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.github.hectorvent.floci.testing.StartGate;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.ValidatableResponse;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.RepeatedTest;+import org.junit.jupiter.api.Test;++import java.util.ArrayList;+import java.util.Collections;+import java.util.List;+import java.util.UUID;+import java.util.function.BiFunction;+import java.util.function.IntFunction;++import static io.github.hectorvent.floci.testing.DynamoDbRequests.ddb;+import static org.hamcrest.Matchers.equalTo;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * Writes carrying a legacy {@code Expected} condition, sent over HTTP so the condition goes through+ * the request handler. Concurrent writers of one version: exactly one may win, as on DynamoDB.+ */+@QuarkusTest+class DynamoDbLegacyExpectedIntegrationTest {++ private static final int REPEATS = 3;+ private static final int WRITERS = 16;+ private static final int ROUNDS = 5;++ private String table;++ @BeforeAll+ static void configureJson() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @BeforeEach+ void createTable() {+ table = "legacy-expected-" + UUID.randomUUID();+ ddb("CreateTable", """+ {"TableName":"%s","KeySchema":[{"AttributeName":"pk","KeyType":"HASH"}],+ "AttributeDefinitions":[{"AttributeName":"pk","AttributeType":"S"}],+ "BillingMode":"PAY_PER_REQUEST"}+ """.formatted(table)).statusCode(200);+ }++ @AfterEach+ void deleteTable() {+ ddb("DeleteTable", "{\"TableName\":\"" + table + "\"}").statusCode(200);+ }++ @RepeatedTest(REPEATS)+ void updateItem_concurrentWritersOfOneVersion_acceptsExactlyOne() throws InterruptedException {+ assertOneWriterWinsEachRound("update", (pk, writer) -> ddb("UpdateItem", """+ {"TableName":"%s","Key":{"pk":{"S":"%s"}},+ "AttributeUpdates":{"version":{"Action":"PUT","Value":{"N":"1"}},+ "writer":{"Action":"PUT","Value":{"S":"%d"}}},+ "Expected":{"version":{"Value":{"N":"0"}}}}+ """.formatted(table, pk, writer)));+ }++ @RepeatedTest(REPEATS)+ void putItem_concurrentWritersOfOneVersion_acceptsExactlyOne() throws InterruptedException {+ assertOneWriterWinsEachRound("put", (pk, writer) -> ddb("PutItem", """+ {"TableName":"%s",+ "Item":{"pk":{"S":"%s"},"version":{"N":"1"},"writer":{"S":"%d"}},+ "Expected":{"version":{"Value":{"N":"0"}}}}+ """.formatted(table, pk, writer)));+ }++ @RepeatedTest(REPEATS)+ void deleteItem_concurrentDeletesOfOneVersion_acceptsExactlyOne() throws InterruptedException {+ assertOneWriterWinsEachRound("delete", (pk, writer) -> ddb("DeleteItem", """+ {"TableName":"%s","Key":{"pk":{"S":"%s"}},+ "Expected":{"version":{"Value":{"N":"0"}}}}+ """.formatted(table, pk)));+ }++ @RepeatedTest(REPEATS)+ void putItem_concurrentAllOld_returnsTheItemEachPutReplaced() throws InterruptedException {+ String pk = "all-old";+ ddb("PutItem", """+ {"TableName":"%s","Item":{"pk":{"S":"%s"},"writer":{"S":"seed"}}}+ """.formatted(table, pk)).statusCode(200);++ List<ValidatableResponse> responses = runConcurrently(writer -> ddb("PutItem", """+ {"TableName":"%s","Item":{"pk":{"S":"%s"},"writer":{"S":"%d"}},+ "ReturnValues":"ALL_OLD"}+ """.formatted(table, pk, writer)));++ List<String> replaced = new ArrayList<>();+ for (ValidatableResponse response : responses) {+ replaced.add(response.statusCode(200).extract().jsonPath().getString("Attributes.writer.S"));+ }+ replaced.add(ddb("GetItem", """+ {"TableName":"%s","Key":{"pk":{"S":"%s"}},"ConsistentRead":true}+ """.formatted(table, pk)).extract().jsonPath().getString("Item.writer.S"));++ List<String> everyValue = new ArrayList<>();+ everyValue.add("seed");+ for (int writer = 0; writer < WRITERS; writer++) {+ everyValue.add(String.valueOf(writer));+ }+ Collections.sort(replaced);+ Collections.sort(everyValue);+ assertEquals(everyValue, replaced,+ "every value but the last must be replaced by exactly one put, and the last must be stored");+ }++ @Test+ void updateItem_staleExpectedVersion_isRejected() {+ seed("stale");+ String update = """+ {"TableName":"%s","Key":{"pk":{"S":"stale"}},+ "AttributeUpdates":{"version":{"Action":"PUT","Value":{"N":"1"}}},+ "Expected":{"version":{"Value":{"N":"0"}}}}+ """.formatted(table);+ ddb("UpdateItem", update).statusCode(200);+ ddb("UpdateItem", update).statusCode(400)+ .body("__type", equalTo("ConditionalCheckFailedException"));+ }++ @Test+ void updateAndDelete_malformedKeyAndInvalidExpected_reportTheKeyError() {+ ddb("UpdateItem", """+ {"TableName":"%s","Key":{"other":{"S":"a"}},+ "AttributeUpdates":{"version":{"Action":"PUT","Value":{"N":"1"}}},+ "Expected":{"version":{}}}+ """.formatted(table)).statusCode(400)+ .body("__type", equalTo("ValidationException"))+ .body("message", equalTo("The provided key element does not match the schema"));+ ddb("DeleteItem", """+ {"TableName":"%s","Key":{"other":{"S":"a"}},"Expected":{"version":{}}}+ """.formatted(table)).statusCode(400)+ .body("__type", equalTo("ValidationException"))+ .body("message", equalTo("The provided key element does not match the schema"));+ }++ @Test+ void putItem_itemWithoutItsKey_reportsTheItemKeyErrorWithAnyReturnValuesOrExpected() {+ for (String extra : List.of("", ",\"ReturnValues\":\"ALL_OLD\"", ",\"Expected\":{\"version\":{}}")) {+ ddb("PutItem", """+ {"TableName":"%s","Item":{"other":{"S":"a"}}%s}+ """.formatted(table, extra)).statusCode(400)+ .body("__type", equalTo("ValidationException"))+ .body("message", equalTo("One of the required keys was not given a value"));+ }+ }++ @Test+ void updateItem_invalidExpectedOnAMissingTable_reportsTheMissingTable() {+ ddb("UpdateItem", """+ {"TableName":"absent-%s","Key":{"pk":{"S":"a"}},"Expected":{"version":{}}}+ """.formatted(UUID.randomUUID())).statusCode(400)+ .body("__type", equalTo("ResourceNotFoundException"));+ }++ private void seed(String pk) {+ ddb("PutItem", """+ {"TableName":"%s","Item":{"pk":{"S":"%s"},"version":{"N":"0"}}}+ """.formatted(table, pk)).statusCode(200);+ }++ /** Seeds a fresh item at version 0 each round and races every writer at it. */+ private void assertOneWriterWinsEachRound(String keyPrefix, BiFunction<String, Integer, ValidatableResponse> request)+ throws InterruptedException {+ for (int round = 0; round < ROUNDS; round++) {+ String pk = keyPrefix + "-" + round;+ seed(pk);+ List<ValidatableResponse> responses = runConcurrently(writer -> request.apply(pk, writer));+ int accepted = 0;+ for (ValidatableResponse response : responses) {+ if (response.extract().statusCode() == 200) {+ accepted++;+ } else {+ response.statusCode(400)+ .body("__type", equalTo("ConditionalCheckFailedException"));+ }+ }+ assertEquals(1, accepted, "exactly one writer of a version may be accepted");+ }+ }++ /** Sends one request per writer, all released together. */+ private static List<ValidatableResponse> runConcurrently(IntFunction<ValidatableResponse> request)+ throws InterruptedException {+ StartGate.Results<ValidatableResponse> results = StartGate.runConcurrently(WRITERS, request);+ assertTrue(results.errors().isEmpty(), () -> "unexpected errors: " + results.errors());+ return results.values();+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/testing/StartGate.java b/src/test/java/io/github/hectorvent/floci/testing/StartGate.javanew file mode 100644index 0000000000..8f224eaf41--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/testing/StartGate.java@@ -0,0 +1,62 @@+package io.github.hectorvent.floci.testing;++import java.util.ArrayList;+import java.util.Arrays;+import java.util.Collections;+import java.util.List;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.ExecutorService;+import java.util.concurrent.Executors;+import java.util.concurrent.TimeUnit;+import java.util.function.IntFunction;++import static org.junit.jupiter.api.Assertions.assertTrue;++/** Runs tasks on their own threads, all released together, so a race in the code under test has its best chance. */+public final class StartGate {++ private StartGate() {}++ /**+ * What the tasks returned, in task order, with {@code null} for a task that threw, and what the+ * throwing tasks threw.+ */+ public record Results<T>(List<T> values, List<Throwable> errors) {}++ /**+ * Runs {@code task} once per index from 0 to {@code threadCount - 1}, each on its own thread, and+ * waits up to 30 seconds for all of them.+ */+ public static <T> Results<T> runConcurrently(int threadCount, IntFunction<T> task) throws InterruptedException {+ ExecutorService pool = Executors.newFixedThreadPool(threadCount);+ CountDownLatch startGate = new CountDownLatch(1);+ CountDownLatch doneGate = new CountDownLatch(threadCount);+ Object[] values = new Object[threadCount];+ List<Throwable> errors = Collections.synchronizedList(new ArrayList<>());+ try {+ for (int i = 0; i < threadCount; i++) {+ int index = i;+ pool.submit(() -> {+ try {+ startGate.await();+ values[index] = task.apply(index);+ } catch (Throwable t) {+ errors.add(t);+ } finally {+ doneGate.countDown();+ }+ });+ }+ startGate.countDown();+ assertTrue(doneGate.await(30, TimeUnit.SECONDS),+ "concurrent tasks did not complete within 30s");+ } finally {+ pool.shutdownNow();+ assertTrue(pool.awaitTermination(5, TimeUnit.SECONDS),+ "thread pool did not terminate");+ }+ @SuppressWarnings("unchecked")+ List<T> results = (List<T>) Arrays.asList(values);+ return new Results<>(results, List.copyOf(errors));+ }+}