Light, fluffy, and always free - The AWS Local Emulator alternative
fix(s3): honour If-Match on DeleteObject and the ETag element on DeleteObjects (#4526)
TiM18ef1f58e9dc
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java b/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.javaindex fec161005e..2cb25f7ab9 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java@@ -423,6 +423,33 @@ public class IamEnforcementFilter implements ContainerRequestFilter {abortIfDenied(ctx, caller, "s3:GetObject", credentialScope, resources,withoutObjectTags(targetContexts), region, accountId, akid);}+ // A DeleteObject conditioned on an ETag reveals whether the object still has it, and the+ // conditional-deletes guide requires s3:GetObject for it; If-Match: * (existence only)+ // needs just s3:DeleteObject. The read is checked the way the PutObject case above is.+ if ("s3:DeleteObject".equals(action) && isPlainDeleteObject(ctx)+ && isETagCondition(ctx.getHeaderString("If-Match"))) {+ abortIfDenied(ctx, caller, "s3:GetObject", credentialScope, resources,+ withoutObjectTags(targetContexts), region, accountId, akid);+ }+ }++ // The DELETE subresources S3Controller.deleteObject routes away from DeleteObject (?uploadId= is+ // AbortMultipartUpload, which the action registry also files under s3:DeleteObject). Everything+ // else, including the x-id and X-Amz-* parameters SDKs and presigned URLs add, is a DeleteObject.+ private static final Set<String> NON_DELETE_OBJECT_SUBRESOURCES = Set.of("uploadId", "tagging", "annotation");++ private static boolean isPlainDeleteObject(ContainerRequestContext ctx) {+ return "DELETE".equalsIgnoreCase(ctx.getMethod())+ && ctx.getUriInfo().getQueryParameters().keySet().stream()+ .noneMatch(NON_DELETE_OBJECT_SUBRESOURCES::contains);+ }++ private static boolean isETagCondition(String ifMatch) {+ if (ifMatch == null) {+ return false;+ }+ String value = ifMatch.trim();+ return !value.equals("*") && !value.equals("\"*\"");}/**diff --git a/src/main/java/io/github/hectorvent/floci/core/common/XmlParser.java b/src/main/java/io/github/hectorvent/floci/core/common/XmlParser.javaindex 1453138374..a8f23de491 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/XmlParser.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/XmlParser.java@@ -187,11 +187,18 @@ public final class XmlParser {return extractAll(xml, elementName).stream().anyMatch(value::equals);}- /** A key paired with an optional version id, extracted from a {@code Delete} request's {@code <Object>} block. */- public record KeyVersion(String key, String versionId) {}+ /**+ * A key paired with an optional version id and an optional {@code If-Match} ETag, extracted from a+ * {@code Delete} request's {@code <Object>} block.+ */+ public record KeyVersion(String key, String versionId, String eTag) {+ public KeyVersion(String key, String versionId) {+ this(key, versionId, null);+ }+ }/**- * Extracts {@code (Key, VersionId)} pairs from an S3 {@code DeleteObjects} request body,+ * Extracts {@code (Key, VersionId, ETag)} entries from an S3 {@code DeleteObjects} request body,* one entry per {@code <Object>} block.** <p>Unlike {@link #extractAll(String, String)}, which flattens every {@code <Key>} across@@ -199,8 +206,9 @@ public final class XmlParser {* {@code <Object>} block. This is needed so a batch delete can target the exact version named,* rather than discarding it and always falling back to "no version specified".*- * <p>{@code <VersionId>} is optional per the {@code Delete} request schema; an {@code <Object>}- * block that omits it yields an entry with a {@code null} versionId.+ * <p>{@code <VersionId>} and {@code <ETag>} are optional per the {@code Delete} request schema; an+ * {@code <Object>} block that omits one yields an entry with {@code null} in its place. The ETag is a+ * conditional-delete precondition, checked like an {@code If-Match} header on DeleteObject.** <pre>{@code* List<XmlParser.KeyVersion> entries = XmlParser.extractDeleteObjectEntries(body);@@ -216,6 +224,7 @@ public final class XmlParser {boolean inObject = false;String key = null;String versionId = null;+ String eTag = null;while (r.hasNext()) {int event = r.next();if (event == XMLStreamConstants.START_ELEMENT) {@@ -224,15 +233,18 @@ public final class XmlParser {inObject = true;key = null;versionId = null;+ eTag = null;} else if (inObject && "Key".equals(local)) {key = r.getElementText();} else if (inObject && "VersionId".equals(local)) {versionId = r.getElementText();+ } else if (inObject && "ETag".equals(local)) {+ eTag = r.getElementText();}} else if (event == XMLStreamConstants.END_ELEMENT&& inObject && "Object".equals(r.getLocalName())) {if (key != null) {- result.add(new KeyVersion(key, versionId));+ result.add(new KeyVersion(key, versionId, eTag));}inObject = false;}diff --git a/src/main/java/io/github/hectorvent/floci/services/s3/S3Controller.java b/src/main/java/io/github/hectorvent/floci/services/s3/S3Controller.javaindex 60317ba7b4..84cb9a698f 100644--- a/src/main/java/io/github/hectorvent/floci/services/s3/S3Controller.java+++ b/src/main/java/io/github/hectorvent/floci/services/s3/S3Controller.java@@ -1347,11 +1347,13 @@ public class S3Controller {}boolean bypass = "true".equalsIgnoreCase(httpHeaders.getHeaderString("x-amz-bypass-governance-retention"));+ String ifMatch = httpHeaders.getHeaderString("If-Match");s3Service.authorizeDeleteObject(bucket, key, versionId, authorization);+ authorizeDeleteETagRead(bucket, key, ifMatch, authorization);if (bypass) {s3Service.authorizeObjectWrite(bucket, key, "s3:BypassGovernanceRetention", authorization);}- S3Object result = s3Service.deleteObject(bucket, key, versionId, bypass);+ S3Object result = s3Service.deleteObject(bucket, key, versionId, bypass, ifMatch);var resp = Response.noContent();if (result != null) {if (result.isDeleteMarker()) {@@ -1542,6 +1544,7 @@ public class S3Controller {for (XmlParser.KeyVersion entry : entries) {try {s3Service.authorizeDeleteObject(bucket, entry.key(), entry.versionId(), authorization);+ authorizeDeleteETagRead(bucket, entry.key(), entry.eTag(), authorization);if (bypass && s3Service.isGovernanceRetentionActive(bucket, entry.key(), entry.versionId())) {s3Service.authorizeObjectWrite(bucket, entry.key(),@@ -1591,6 +1594,20 @@ public class S3Controller {return Response.ok(builder.build()).type(MediaType.APPLICATION_XML).build();}+ // A conditional delete against an ETag reveals whether the object still has it, so S3 requires+ // s3:GetObject as well as s3:DeleteObject. The existence check (If-Match: *) needs only the delete.+ private void authorizeDeleteETagRead(String bucket, String key, String ifMatch,+ S3Service.RequestAuthorization authorization) {+ if (ifMatch == null) {+ return;+ }+ String value = ifMatch.trim();+ if (value.equals("*") || value.equals("\"*\"")) {+ return;+ }+ s3Service.authorizeGetObject(bucket, key, null, authorization);+ }+private Response handleListParts(String bucket, String key, String uploadId,Integer maxPartsParam, String partNumberMarkerParam) {MultipartUpload upload = s3Service.listParts(bucket, key, uploadId);diff --git a/src/main/java/io/github/hectorvent/floci/services/s3/S3Service.java b/src/main/java/io/github/hectorvent/floci/services/s3/S3Service.javaindex 486dec964b..701dc0211f 100644--- a/src/main/java/io/github/hectorvent/floci/services/s3/S3Service.java+++ b/src/main/java/io/github/hectorvent/floci/services/s3/S3Service.java@@ -1503,18 +1503,50 @@ public class S3Service implements Resettable, ResourceProvider {}public S3Object deleteObject(String bucketName, String key, String versionId, boolean bypassGovernance) {+ return deleteObject(bucketName, key, versionId, bypassGovernance, null);+ }++ /**+ * Deletes an object, first checking an {@code If-Match} precondition when one is given.+ *+ * <p>As on S3, the precondition is evaluated against the current version of the key even+ * when {@code versionId} addresses an older one: a missing key, or a current delete marker,+ * answers {@code NoSuchKey}, and an ETag that does not match answers {@code 412}.+ */+ public S3Object deleteObject(String bucketName, String key, String versionId, boolean bypassGovernance,+ String ifMatch) {Bucket bucket = bucketStore.get(bucketName).orElseThrow(() -> new AwsException("NoSuchBucket","The specified bucket does not exist.", 404));// The bucket monitor serializes this against PutObject's annotation cleanup and the// annotation subresource writes, which hold the same monitor (storeObjectInternal- // already runs under it via storeObject).+ // already runs under it via storeObject). The precondition is checked under it too,+ // so a concurrent overwrite cannot land between the check and the delete.synchronized (bucket) {+ checkDeletePrecondition(bucketName, key, ifMatch);return deleteObjectLocked(bucket, bucketName, key, versionId, bypassGovernance);}}+ // A current delete marker answers 404 NoSuchKey, the same as a missing key. That is deliberate:+ // the S3 conditional-deletes guide says "If the latest version of the object is a delete marker,+ // the object doesn't exist and the DeleteObject API will fail and return a 412 Precondition+ // Failed response", but real S3 (general purpose bucket, ap-southeast-2, measured 2026-09-07)+ // answered 404 NoSuchKey for If-Match: * over a current delete marker. Follow the measurement.+ private void checkDeletePrecondition(String bucketName, String key, String ifMatch) {+ if (ifMatch == null) {+ return;+ }+ S3Object current = objectStore.get(objectKey(bucketName, key)).orElse(null);+ if (current == null || current.isDeleteMarker()) {+ throw new AwsException("NoSuchKey", "The specified key does not exist.", 404);+ }+ if (!eTagMatches(ifMatch, current.getETag())) {+ throw new S3PreconditionFailedException("If-Match");+ }+ }+private S3Object deleteObjectLocked(Bucket bucket, String bucketName, String key,String versionId, boolean bypassGovernance) {if (bucket.isVersioningEnabled() && versionId == null) {@@ -2028,7 +2060,8 @@ public class S3Service implements Resettable, ResourceProvider {List<DeleteError> errors = new ArrayList<>();for (XmlParser.KeyVersion entry : entries) {try {- S3Object result = deleteObject(bucketName, entry.key(), entry.versionId(), bypassGovernance);+ S3Object result = deleteObject(bucketName, entry.key(), entry.versionId(), bypassGovernance,+ entry.eTag());if (result != null && result.isDeleteMarker()) {deleted.add(new DeleteResult(entry.key(), entry.versionId(), true, result.getVersionId()));} else {diff --git a/src/test/java/io/github/hectorvent/floci/core/common/XmlParserTest.java b/src/test/java/io/github/hectorvent/floci/core/common/XmlParserTest.javaindex 99b5ce2ab9..df13be48a3 100644--- a/src/test/java/io/github/hectorvent/floci/core/common/XmlParserTest.java+++ b/src/test/java/io/github/hectorvent/floci/core/common/XmlParserTest.java@@ -220,6 +220,24 @@ class XmlParserTest {assertEquals(new XmlParser.KeyVersion("b.txt", "v2"), entries.get(1));}+ @Test+ void extractDeleteObjectEntriesKeepsEachObjectsETag() {+ String xml = """+ <Delete>+ <Object><Key>a.txt</Key><ETag>"abc"</ETag></Object>+ <Object><Key>b.txt</Key><VersionId>v2</VersionId></Object>+ <Object><Key>c.txt</Key><ETag>*</ETag></Object>+ </Delete>+ """;++ List<XmlParser.KeyVersion> entries = XmlParser.extractDeleteObjectEntries(xml);++ assertEquals(List.of(+ new XmlParser.KeyVersion("a.txt", null, "\"abc\""),+ new XmlParser.KeyVersion("b.txt", "v2", null),+ new XmlParser.KeyVersion("c.txt", null, "*")), entries);+ }+@Testvoid extractDeleteObjectEntriesVersionIdIsOptional() {String xml = """diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/S3ConditionalDeleteIamEnforcementIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/S3ConditionalDeleteIamEnforcementIntegrationTest.javanew file mode 100644index 0000000000..0c8f5d4971--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/S3ConditionalDeleteIamEnforcementIntegrationTest.java@@ -0,0 +1,79 @@+package io.github.hectorvent.floci.services.iam;++import io.github.hectorvent.floci.testing.IamEnforcementProfile;+import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.TestProfile;+import org.junit.jupiter.api.Test;++import static io.restassured.RestAssured.given;+import static org.junit.jupiter.api.Assertions.assertEquals;++/**+ * A DeleteObject conditioned on an ETag needs {@code s3:GetObject} as well as {@code s3:DeleteObject};+ * {@code If-Match: *} needs only the delete. Per the S3 conditional-deletes guide, not a measurement.+ */+@QuarkusTest+@TestProfile(IamEnforcementProfile.class)+class S3ConditionalDeleteIamEnforcementIntegrationTest {++ private static final String ADMIN = "test";+ private static final String REGION = "us-east-1";++ @Test+ void anETagConditionedDeleteAlsoNeedsGetObject() {+ String suffix = Long.toString(System.nanoTime(), 36);+ String bucket = "conddel-" + suffix;+ String user = "conddel-" + suffix;+ given().header("Authorization", auth(ADMIN, "s3")).when().put("/" + bucket).then().statusCode(200);+ for (String key : new String[] {"etag.txt", "star.txt"}) {+ given().header("Authorization", auth(ADMIN, "s3")).body("seed")+ .when().put("/" + bucket + "/" + key).then().statusCode(200);+ }+ given().formParam("Action", "CreateUser").formParam("UserName", user)+ .header("Authorization", auth(ADMIN, "iam")).when().post("/").then().statusCode(200);+ String accessKeyId = given().formParam("Action", "CreateAccessKey").formParam("UserName", user)+ .header("Authorization", auth(ADMIN, "iam")).when().post("/").then().statusCode(200)+ .extract().path("CreateAccessKeyResponse.CreateAccessKeyResult.AccessKey.AccessKeyId");+ String eTag = given().header("Authorization", auth(ADMIN, "s3")).when().head("/" + bucket + "/etag.txt")+ .then().statusCode(200).extract().header("ETag");+ String objects = "arn:aws:s3:::" + bucket + "/*";++ policy(user, "{\"Effect\":\"Allow\",\"Action\":\"s3:DeleteObject\",\"Resource\":\"" + objects + "\"}");+ assertEquals(403, delete(accessKeyId, bucket, "etag.txt", eTag), "an ETag condition with no GetObject");+ assertEquals(403, given().header("Authorization", auth(accessKeyId, "s3")).header("If-Match", eTag)+ .when().delete("/" + bucket + "/etag.txt?x-id=DeleteObject").statusCode(),+ "an SDK's x-id query parameter does not skip the check");+ assertEquals(204, delete(accessKeyId, bucket, "star.txt", "*"), "the existence check needs only DeleteObject");++ // AbortMultipartUpload shares the DELETE verb and the s3:DeleteObject action here, but is not+ // a conditional object delete, so an If-Match on it asks for no GetObject.+ String uploadId = given().header("Authorization", auth(ADMIN, "s3"))+ .when().post("/" + bucket + "/mpu.txt?uploads").then().statusCode(200)+ .extract().xmlPath().getString("InitiateMultipartUploadResult.UploadId");+ policy(user, "{\"Effect\":\"Allow\",\"Action\":[\"s3:DeleteObject\",\"s3:AbortMultipartUpload\"],\"Resource\":\""+ + objects + "\"}");+ assertEquals(204, given().header("Authorization", auth(accessKeyId, "s3")).header("If-Match", eTag)+ .when().delete("/" + bucket + "/mpu.txt?uploadId=" + uploadId).statusCode(),+ "an abort carrying If-Match is not a conditional delete");++ policy(user, "{\"Effect\":\"Allow\",\"Action\":[\"s3:DeleteObject\",\"s3:GetObject\"],\"Resource\":\""+ + objects + "\"}");+ assertEquals(204, delete(accessKeyId, bucket, "etag.txt", eTag), "with GetObject the condition is evaluated");+ }++ private static void policy(String user, String statement) {+ given().formParam("Action", "PutUserPolicy").formParam("UserName", user).formParam("PolicyName", "p")+ .formParam("PolicyDocument", "{\"Version\":\"2012-10-17\",\"Statement\":[" + statement + "]}")+ .header("Authorization", auth(ADMIN, "iam")).when().post("/").then().statusCode(200);+ }++ private static int delete(String accessKeyId, String bucket, String key, String ifMatch) {+ return given().header("Authorization", auth(accessKeyId, "s3")).header("If-Match", ifMatch)+ .when().delete("/" + bucket + "/" + key).statusCode();+ }++ private static String auth(String accessKeyId, String service) {+ return "AWS4-HMAC-SHA256 Credential=" + accessKeyId + "/20260629/" + REGION + "/" + service+ + "/aws4_request, SignedHeaders=host, Signature=abc";+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/S3AuthEnforcementIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/S3AuthEnforcementIntegrationTest.javaindex a352661290..388ab90a60 100644--- a/src/test/java/io/github/hectorvent/floci/services/s3/S3AuthEnforcementIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/s3/S3AuthEnforcementIntegrationTest.java@@ -2282,6 +2282,80 @@ class S3AuthEnforcementIntegrationTest {return publicObjectActionPolicy(bucket, key, "s3:GetObject");}+ @Test+ @Order(56)+ void conditionalDeleteByETagAlsoNeedsGetObject() {+ String bucket = "auth-conditional-delete-bucket";+ given().filter(LOCAL_SIGNER).when().put("/" + bucket).then().statusCode(200);+ String eTag = given().filter(LOCAL_SIGNER).body("etag-guarded")+ .when().put("/" + bucket + "/etag.txt")+ .then().statusCode(200).extract().header("ETag");+ given().filter(LOCAL_SIGNER).body("batch-guarded")+ .when().put("/" + bucket + "/batch.txt")+ .then().statusCode(200);+ given().filter(LOCAL_SIGNER).body("star-guarded")+ .when().put("/" + bucket + "/star.txt")+ .then().statusCode(200);+ given()+ .filter(LOCAL_SIGNER)+ .contentType("application/json")+ .body(publicObjectActionPolicy(bucket, "s3:DeleteObject"))+ .when()+ .put("/" + bucket + "?policy")+ .then()+ .statusCode(200);++ // s3:DeleteObject alone: an ETag condition is refused, the existence check is allowed.+ given()+ .header("If-Match", eTag)+ .when()+ .delete("/" + bucket + "/etag.txt")+ .then()+ .statusCode(403)+ .body(containsString("AccessDenied"));+ given()+ .contentType("application/xml")+ .body("<Delete><Object><Key>batch.txt</Key><ETag>" + eTag + "</ETag></Object></Delete>")+ .when()+ .post("/" + bucket + "?delete")+ .then()+ .statusCode(200)+ .body(containsString("<Error><Key>batch.txt</Key>"))+ .body(containsString("<Code>AccessDenied</Code>"));+ given()+ .header("If-Match", "*")+ .when()+ .delete("/" + bucket + "/star.txt")+ .then()+ .statusCode(204);++ // With s3:GetObject granted as well, the ETag condition is evaluated.+ given()+ .filter(LOCAL_SIGNER)+ .contentType("application/json")+ .body("""+ {+ "Version": "2012-10-17",+ "Statement": {+ "Effect": "Allow",+ "Principal": "*",+ "Action": ["s3:DeleteObject", "s3:GetObject"],+ "Resource": "arn:aws:s3:::%s/*"+ }+ }+ """.formatted(bucket))+ .when()+ .put("/" + bucket + "?policy")+ .then()+ .statusCode(200);+ given()+ .header("If-Match", eTag)+ .when()+ .delete("/" + bucket + "/etag.txt")+ .then()+ .statusCode(204);+ }+private static String publicObjectActionPolicy(String bucket, String action) {return publicObjectActionPolicy(bucket, "*", action);}diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/S3ConditionalWriteIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/S3ConditionalWriteIntegrationTest.javaindex 1032ba757e..f2e775f841 100644--- a/src/test/java/io/github/hectorvent/floci/services/s3/S3ConditionalWriteIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/s3/S3ConditionalWriteIntegrationTest.java@@ -1,6 +1,7 @@package io.github.hectorvent.floci.services.s3;import io.quarkus.test.junit.QuarkusTest;+import io.restassured.path.xml.XmlPath;import io.restassured.response.ValidatableResponse;import org.junit.jupiter.api.Test;@@ -25,6 +26,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;class S3ConditionalWriteIntegrationTest {private static final String PRECONDITION_FAILED_MESSAGE ="At least one of the pre-conditions you specified did not hold";+ private static final String STALE_ETAG = "\"00000000000000000000000000000000\"";@Testvoid putObject_ifNoneMatchStar_succeedsWhenKeyMissing() {@@ -263,6 +265,192 @@ class S3ConditionalWriteIntegrationTest {assertObjectBody(bucket, "object.txt", "first");}+ @Test+ void deleteObject_ifMatch_deletesOnMatch() {+ String bucket = createBucket("delete-if-match");+ String eTag = putObject(bucket, "object.txt", "first");++ given()+ .header("If-Match", eTag)+ .when()+ .delete("/" + bucket + "/object.txt")+ .then()+ .statusCode(204);++ assertObjectMissing(bucket, "object.txt");+ }++ @Test+ void deleteObject_ifMatch_412OnMismatchAndDoesNotDelete() {+ String bucket = createBucket("delete-if-match-stale");+ putObject(bucket, "object.txt", "first");++ ValidatableResponse response = given()+ .header("If-Match", STALE_ETAG)+ .when()+ .delete("/" + bucket + "/object.txt")+ .then();++ assertPreconditionFailed(response, "If-Match");+ assertObjectBody(bucket, "object.txt", "first");+ }++ @Test+ void deleteObject_ifMatch_404WhenKeyMissing() {+ String bucket = createBucket("delete-if-match-missing");++ for (String ifMatch : List.of(STALE_ETAG, "*")) {+ given()+ .header("If-Match", ifMatch)+ .when()+ .delete("/" + bucket + "/missing.txt")+ .then()+ .statusCode(404)+ .body("Error.Code", equalTo("NoSuchKey"));+ }+ }++ @Test+ void deleteObject_ifMatchStar_deletesWhenKeyExists() {+ String bucket = createBucket("delete-if-match-star");+ putObject(bucket, "object.txt", "first");++ given()+ .header("If-Match", "*")+ .when()+ .delete("/" + bucket + "/object.txt")+ .then()+ .statusCode(204);++ assertObjectMissing(bucket, "object.txt");+ }++ @Test+ void deleteObject_versioned_ifMatchMismatchCreatesNoDeleteMarker() {+ String bucket = createVersionedBucket("delete-if-match-versioned");+ String eTag = putObject(bucket, "object.txt", "first");++ assertPreconditionFailed(given()+ .header("If-Match", STALE_ETAG)+ .when()+ .delete("/" + bucket + "/object.txt")+ .then(), "If-Match");+ assertObjectBody(bucket, "object.txt", "first");++ given()+ .header("If-Match", eTag)+ .when()+ .delete("/" + bucket + "/object.txt")+ .then()+ .statusCode(204)+ .header("x-amz-delete-marker", "true");+ assertObjectMissing(bucket, "object.txt");+ }++ @Test+ void deleteObject_versioned_ifMatch404WhenCurrentVersionIsDeleteMarker() {+ String bucket = createVersionedBucket("delete-if-match-marker");+ putObject(bucket, "object.txt", "first");+ given().when().delete("/" + bucket + "/object.txt").then().statusCode(204);++ given()+ .header("If-Match", "*")+ .when()+ .delete("/" + bucket + "/object.txt")+ .then()+ .statusCode(404)+ .body("Error.Code", equalTo("NoSuchKey"));+ }++ @Test+ void deleteObject_versioned_ifMatchIsEvaluatedAgainstTheCurrentVersion() {+ String bucket = createVersionedBucket("delete-if-match-version-id");+ String olderETag = putObject(bucket, "object.txt", "older");+ String olderVersionId = versionIdOf(bucket, "object.txt", 1);+ String currentETag = putObject(bucket, "object.txt", "current");++ // The addressed version's own ETag is not what the precondition checks.+ assertPreconditionFailed(given()+ .header("If-Match", olderETag)+ .when()+ .delete("/" + bucket + "/object.txt?versionId=" + olderVersionId)+ .then(), "If-Match");+ given().when().get("/" + bucket + "/object.txt?versionId=" + olderVersionId).then().statusCode(200);++ given()+ .header("If-Match", currentETag)+ .when()+ .delete("/" + bucket + "/object.txt?versionId=" + olderVersionId)+ .then()+ .statusCode(204);+ given().when().get("/" + bucket + "/object.txt?versionId=" + olderVersionId).then().statusCode(404);+ assertObjectBody(bucket, "object.txt", "current");+ }++ @Test+ void deleteObjects_perObjectETag_isAPreconditionPerEntry() {+ String bucket = createBucket("delete-objects-etag");+ String matchingETag = putObject(bucket, "matching.txt", "matching");+ putObject(bucket, "stale.txt", "stale");+ putObject(bucket, "unconditional.txt", "unconditional");++ String response = given()+ .contentType("application/xml")+ .body("""+ <Delete>+ <Object><Key>matching.txt</Key><ETag>%s</ETag></Object>+ <Object><Key>stale.txt</Key><ETag>%s</ETag></Object>+ <Object><Key>missing.txt</Key><ETag>*</ETag></Object>+ <Object><Key>unconditional.txt</Key></Object>+ </Delete>""".formatted(stripQuotes(matchingETag), stripQuotes(STALE_ETAG)))+ .when()+ .post("/" + bucket + "?delete")+ .then()+ .statusCode(200)+ .extract().asString();++ XmlPath xml = XmlPath.from(response);+ assertEquals(List.of("matching.txt", "unconditional.txt"), xml.getList("DeleteResult.Deleted.Key"));+ assertEquals(List.of("stale.txt", "missing.txt"), xml.getList("DeleteResult.Error.Key"));+ assertEquals(List.of("PreconditionFailed", "NoSuchKey"), xml.getList("DeleteResult.Error.Code"));+ assertObjectBody(bucket, "stale.txt", "stale");+ assertObjectMissing(bucket, "matching.txt");+ assertObjectMissing(bucket, "unconditional.txt");+ }++ @Test+ void concurrentDeleteObject_ifMatch_neverDeletesAnOverwrite() throws Exception {+ String bucket = createBucket("delete-if-match-concurrent");+ ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();+ try {+ for (int round = 0; round < 25; round++) {+ String key = "object-" + round + ".txt";+ String original = putObject(bucket, key, "original");+ CyclicBarrier barrier = new CyclicBarrier(2);+ Future<Integer> delete = executor.submit(() -> {+ barrier.await();+ return given().header("If-Match", original)+ .when().delete("/" + bucket + "/" + key)+ .then().extract().statusCode();+ });+ Future<Integer> overwrite = executor.submit(() -> {+ barrier.await();+ return given().body("overwrite")+ .when().put("/" + bucket + "/" + key)+ .then().extract().statusCode();+ });+ assertEquals(200, overwrite.get(10, SECONDS));+ int deleteStatus = delete.get(10, SECONDS);+ // Delete-then-overwrite and overwrite-then-412 both leave the overwrite in place.+ // Only a check that is not atomic with the delete can remove it.+ assertEquals(true, deleteStatus == 204 || deleteStatus == 412, "delete status " + deleteStatus);+ assertObjectBody(bucket, key, "overwrite");+ }+ } finally {+ executor.shutdownNow();+ }+ }+private static String createBucket(String label) {String bucket = "cond-" + label + "-" + UUID.randomUUID().toString().substring(0, 8);given()@@ -273,6 +461,36 @@ class S3ConditionalWriteIntegrationTest {return bucket;}+ private static String createVersionedBucket(String label) {+ String bucket = createBucket(label);+ given()+ .body("<VersioningConfiguration><Status>Enabled</Status></VersioningConfiguration>")+ .when()+ .put("/" + bucket + "?versioning")+ .then()+ .statusCode(200);+ return bucket;+ }++ /** Version id of the {@code n}-th version written to {@code key} (1-based, oldest first). */+ private static String versionIdOf(String bucket, String key, int n) {+ List<String> ids = given()+ .when()+ .get("/" + bucket + "?versions&prefix=" + key)+ .then()+ .statusCode(200)+ .extract().xmlPath().getList("ListVersionsResult.Version.VersionId");+ return ids.get(ids.size() - n);+ }++ private static void assertObjectMissing(String bucket, String key) {+ given()+ .when()+ .get("/" + bucket + "/" + key)+ .then()+ .statusCode(404);+ }+private static String putObject(String bucket, String key, String body) {return given().body(body)