Light, fluffy, and always free - The AWS Local Emulator alternative
fix(s3): refuse DeleteBucket while versions or delete markers remain (#5548)
TiMe023ae9ff4e2
diff --git a/compatibility-tests/sdk-test-awscli/test/s3.bats b/compatibility-tests/sdk-test-awscli/test/s3.batsindex a18c2b2694..62cf0ecc4e 100644--- a/compatibility-tests/sdk-test-awscli/test/s3.bats+++ b/compatibility-tests/sdk-test-awscli/test/s3.bats@@ -7,9 +7,34 @@ setup() {}teardown() {- # Clean up all objects in bucket+ local buckets bucket_present+ buckets=$(aws_cmd s3api list-buckets) || return 1+ bucket_present=$(jq -r --arg name "$BUCKET" '.Buckets | any(.Name == $name)' <<< "$buckets") || return 1+ if [[ "$bucket_present" == "false" ]]; then+ return+ fi+ [[ "$bucket_present" == "true" ]] || return 1+aws_cmd s3 rm "s3://$BUCKET" --recursive >/dev/null 2>&1 || true- aws_cmd s3api delete-bucket --bucket "$BUCKET" >/dev/null 2>&1 || true+ local versions entries entry key version_id+ versions=$(aws_cmd s3api list-object-versions --bucket "$BUCKET") || return 1+ jq -es 'length == 1+ and (.[0] | type == "object")+ and (.[0] | (has("Versions") | not) or (.Versions | type == "array"))+ and (.[0] | (has("DeleteMarkers") | not) or (.DeleteMarkers | type == "array"))' \+ <<< "$versions" >/dev/null || return 1+ entries=$(jq -c '(.Versions[]?, .DeleteMarkers[]?) | {Key, VersionId}' <<< "$versions") || return 1+ if [[ -n "$entries" ]]; then+ while IFS= read -r entry; do+ key=$(jq -er '.Key' <<< "$entry") || return 1+ version_id=$(jq -er '.VersionId' <<< "$entry") || return 1+ aws_cmd s3api delete-object --bucket "$BUCKET" --key "$key" --version-id "$version_id" >/dev/null || return 1+ done <<< "$entries"+ fi+ aws_cmd s3api delete-bucket --bucket "$BUCKET" >/dev/null || return 1+ buckets=$(aws_cmd s3api list-buckets) || return 1+ bucket_present=$(jq -r --arg name "$BUCKET" '.Buckets | any(.Name == $name)' <<< "$buckets") || return 1+ [[ "$bucket_present" == "false" ]]}@test "S3: create bucket" {diff --git a/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java b/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.javaindex 88873bd2d4..ad3d485c53 100644--- a/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java+++ b/compatibility-tests/sdk-test-java/src/main/java/com/floci/test/TestFixtures.java@@ -121,6 +121,14 @@ import software.amazon.awssdk.services.route53.model.ResourceRecordSet;import software.amazon.awssdk.services.rum.RumClient;import software.amazon.awssdk.services.s3.S3AsyncClient;import software.amazon.awssdk.services.s3.S3Client;+import software.amazon.awssdk.services.s3.model.DeleteMarkerEntry;+import software.amazon.awssdk.services.s3.model.DeleteObjectRequest;+import software.amazon.awssdk.services.s3.model.ListObjectVersionsRequest;+import software.amazon.awssdk.services.s3.model.ListObjectVersionsResponse;+import software.amazon.awssdk.services.s3.model.ListObjectsV2Request;+import software.amazon.awssdk.services.s3.model.ListObjectsV2Response;+import software.amazon.awssdk.services.s3.model.ObjectVersion;+import software.amazon.awssdk.services.s3.model.S3Object;import software.amazon.awssdk.services.s3control.S3ControlClient;import software.amazon.awssdk.services.s3control.endpoints.S3ControlEndpointProvider;import software.amazon.awssdk.services.s3tables.S3TablesClient;@@ -162,6 +170,7 @@ import java.security.GeneralSecurityException;import java.security.SecureRandom;import java.security.cert.X509Certificate;import java.time.Duration;+import java.util.ArrayList;import java.util.List;import java.util.UUID;import java.util.function.BooleanSupplier;@@ -644,6 +653,42 @@ public final class TestFixtures {.build();}+ /** Removes objects, versions and delete markers before a test deletes its bucket. */+ public static void deleteBucketContents(S3Client s3, String bucket) {+ String token = null;+ do {+ ListObjectsV2Response response = s3.listObjectsV2(ListObjectsV2Request.builder()+ .bucket(bucket).continuationToken(token).build());+ for (S3Object object : response.contents()) {+ s3.deleteObject(DeleteObjectRequest.builder().bucket(bucket).key(object.key()).build());+ }+ token = response.isTruncated() ? response.nextContinuationToken() : null;+ } while (token != null);++ // Collect every page before deleting: deleting a page invalidates its resume marker.+ List<ObjectVersion> versions = new ArrayList<>();+ List<DeleteMarkerEntry> markers = new ArrayList<>();+ String keyMarker = null;+ String versionMarker = null;+ do {+ ListObjectVersionsResponse response = s3.listObjectVersions(+ ListObjectVersionsRequest.builder()+ .bucket(bucket).keyMarker(keyMarker).versionIdMarker(versionMarker).build());+ versions.addAll(response.versions());+ markers.addAll(response.deleteMarkers());+ keyMarker = response.isTruncated() ? response.nextKeyMarker() : null;+ versionMarker = response.isTruncated() ? response.nextVersionIdMarker() : null;+ } while (keyMarker != null);+ for (ObjectVersion version : versions) {+ s3.deleteObject(DeleteObjectRequest.builder()+ .bucket(bucket).key(version.key()).versionId(version.versionId()).build());+ }+ for (DeleteMarkerEntry marker : markers) {+ s3.deleteObject(DeleteObjectRequest.builder()+ .bucket(bucket).key(marker.key()).versionId(marker.versionId()).build());+ }+ }+/** Async client with the Java-based multipart support enabled (5 MiB threshold and parts), for the transfer manager. */public static S3AsyncClient s3MultipartAsyncClient() {long fiveMiB = 5L * 1024 * 1024;diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/S3AnnotationsTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/S3AnnotationsTest.javaindex 767ceec471..72b26501be 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/S3AnnotationsTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/S3AnnotationsTest.java@@ -18,8 +18,7 @@ import software.amazon.awssdk.services.s3.model.PutObjectAnnotationRequest;import software.amazon.awssdk.services.s3.model.PutObjectAnnotationResponse;import software.amazon.awssdk.services.s3.model.VersioningConfiguration;-import java.util.logging.Level;-import java.util.logging.Logger;+import java.util.List;import static org.assertj.core.api.Assertions.*;@@ -27,7 +26,6 @@ import static org.assertj.core.api.Assertions.*;@TestMethodOrder(MethodOrderer.OrderAnnotation.class)class S3AnnotationsTest {- private static final Logger LOG = Logger.getLogger(S3AnnotationsTest.class.getName());private static S3Client s3;private static final String BUCKET = "sdk-annotations-bucket";private static final String KEY = "docs/annotated.txt";@@ -41,20 +39,9 @@ class S3AnnotationsTest {@AfterAllstatic void teardown() {- // Cleanup failures are logged with context instead of swallowed: a leaked object or a- // bucket that failed to delete would otherwise hide from later test runs.- for (String key : new String[]{"docs/annotated.txt", "docs/annotated-copy.txt", "docs/annotated-copied.txt"}) {- try {- s3.deleteObject(r -> r.bucket(BUCKET).key(key));- } catch (Exception e) {- LOG.log(Level.WARNING, "Failed to clean up object " + BUCKET + "/" + key, e);- }- }- try {- s3.deleteBucket(r -> r.bucket(BUCKET));- } catch (Exception e) {- LOG.log(Level.WARNING, "Failed to clean up bucket " + BUCKET, e);- }+ TestFixtures.deleteBucketContents(s3, BUCKET);+ s3.deleteBucket(r -> r.bucket(BUCKET));+ assertThat(s3.listBuckets().buckets()).noneMatch(bucket -> BUCKET.equals(bucket.name()));}@Test@@ -229,4 +216,4 @@ class S3AnnotationsTest {assertThat(copied.asUtf8String()).isEqualTo("copied annotation");s3.deleteObject(r -> r.bucket(BUCKET).key("docs/annotated-copied.txt"));}-}\ No newline at end of file+}diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/S3FeaturesTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/S3FeaturesTest.javaindex ccbbd3de2e..375dab765c 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/S3FeaturesTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/S3FeaturesTest.java@@ -39,14 +39,22 @@ class S3FeaturesTest {@AfterAllstatic void cleanup() {if (s3 == null) return;- deleteBucketContents(BUCKET_VERSIONS);- deleteBucketContents(BUCKET_PAB);- deleteBucketContents(BUCKET_PAGINATE);- deleteBucketContents(BUCKET_334);+ for (String bucket : List.of(BUCKET_VERSIONS, BUCKET_PAB, BUCKET_PAGINATE, BUCKET_334)) {+ try {+ TestFixtures.deleteBucketContents(s3, bucket);+ } catch (Exception ignored) {+ // Continue with other buckets; the final assertion reports any cleanup leak.+ }+ }quietDeleteBucket(BUCKET_VERSIONS);quietDeleteBucket(BUCKET_PAB);quietDeleteBucket(BUCKET_PAGINATE);quietDeleteBucket(BUCKET_334);+ assertThat(s3.listBuckets().buckets()).noneMatch(bucket ->+ bucket.name().equals(BUCKET_VERSIONS)+ || bucket.name().equals(BUCKET_PAB)+ || bucket.name().equals(BUCKET_PAGINATE)+ || bucket.name().equals(BUCKET_334));s3.close();}@@ -388,40 +396,6 @@ class S3FeaturesTest {} catch (BucketAlreadyOwnedByYouException ignored) {}}- private static void deleteBucketContents(String bucket) {- try {- // Delete all ordinary objects- String token = null;- do {- ListObjectsV2Response resp = s3.listObjectsV2(ListObjectsV2Request.builder()- .bucket(bucket).continuationToken(token).build());- for (S3Object obj : resp.contents()) {- s3.deleteObject(DeleteObjectRequest.builder().bucket(bucket).key(obj.key()).build());- }- token = resp.isTruncated() ? resp.nextContinuationToken() : null;- } while (token != null);-- // Delete all versions and delete-markers- String keyMarker = null;- String versionMarker = null;- do {- ListObjectVersionsResponse resp = s3.listObjectVersions(- ListObjectVersionsRequest.builder()- .bucket(bucket).keyMarker(keyMarker).versionIdMarker(versionMarker).build());- for (ObjectVersion v : resp.versions()) {- s3.deleteObject(DeleteObjectRequest.builder()- .bucket(bucket).key(v.key()).versionId(v.versionId()).build());- }- for (DeleteMarkerEntry dm : resp.deleteMarkers()) {- s3.deleteObject(DeleteObjectRequest.builder()- .bucket(bucket).key(dm.key()).versionId(dm.versionId()).build());- }- keyMarker = resp.isTruncated() ? resp.nextKeyMarker() : null;- versionMarker = resp.isTruncated() ? resp.nextVersionIdMarker() : null;- } while (keyMarker != null);- } catch (Exception ignored) {}- }-private static void quietDeleteBucket(String bucket) {try { s3.deleteBucket(DeleteBucketRequest.builder().bucket(bucket).build()); }catch (Exception ignored) {}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 bcde48e784..f48a2f3e87 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@@ -498,9 +498,7 @@ public class S3Service implements Resettable, ResourceProvider {}private void deleteBucketLocked(String bucketName) {- // Check if bucket is empty- List<S3Object> objects = listObjects(bucketName, null, null, 1);- if (!objects.isEmpty()) {+ if (!objectStore.scan(key -> key.startsWith(bucketPrefix(bucketName))).isEmpty()) {throw new AwsException("BucketNotEmpty","The bucket you tried to delete is not empty.", 409);}@@ -6033,6 +6031,10 @@ public class S3Service implements Resettable, ResourceProvider {}}+ private String bucketPrefix(String bucketName) {+ return bucketName + "/";+ }+private String objectKey(String bucketName, String key) {return bucketName + "/" + key;}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/S3ObjectTagConditionEnforcementIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/S3ObjectTagConditionEnforcementIntegrationTest.javaindex 96b512e896..658b708435 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/S3ObjectTagConditionEnforcementIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/S3ObjectTagConditionEnforcementIntegrationTest.java@@ -167,10 +167,8 @@ class S3ObjectTagConditionEnforcementIntegrationTest {String suffix = Long.toString(System.nanoTime(), 36);bucket = "objtag-" + name + "-" + suffix;user = "objtag-" + name + "-" + suffix;- if (!versioned) {- cleanup.register(() -> EnforcementFixtures.removeBucket(baseUri.getPort(),- auth(ADMIN, "s3"), bucket));- }+ cleanup.register(() -> EnforcementFixtures.removeBucket(baseUri.getPort(),+ auth(ADMIN, "s3"), bucket));given().header("Authorization", auth(ADMIN, "s3")).when().put("/" + bucket).then().statusCode(200);seed("a/tagged-a", "env=a");seed("a/tagged-b", "env=b");diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/S3ServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/S3ServiceTest.javaindex f60f35aba5..35d76bedde 100644--- a/src/test/java/io/github/hectorvent/floci/services/s3/S3ServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/s3/S3ServiceTest.java@@ -405,6 +405,30 @@ class S3ServiceTest {assertFalse(Files.exists(tempDir.resolve("s3/test-bucket")));}+ @Test+ void refusedDeletePreservesVersionBytesAndPurgeRemovesThem() throws IOException {+ s3Service.createBucket("test-bucket", "us-east-1");+ s3Service.putBucketVersioning("test-bucket", "Enabled");+ S3Object version = s3Service.putObject("test-bucket", "file.txt",+ "version data".getBytes(StandardCharsets.UTF_8), "text/plain", null);+ S3Object marker = s3Service.deleteObject("test-bucket", "file.txt");+ Path versionDirectory = tempDir.resolve("s3/.accounts/000000000000/.versions/test-bucket");++ AwsException error = assertThrows(AwsException.class, () -> s3Service.deleteBucket("test-bucket"));+ assertEquals("BucketNotEmpty", error.getErrorCode());+ assertEquals(409, error.getHttpStatus());+ assertArrayEquals("version data".getBytes(StandardCharsets.UTF_8),+ s3Service.getObject("test-bucket", "file.txt", version.getVersionId()).getData());+ assertTrue(Files.exists(versionDirectory));++ s3Service.deleteObject("test-bucket", "file.txt", marker.getVersionId());+ s3Service.deleteObject("test-bucket", "file.txt", version.getVersionId());+ s3Service.deleteBucket("test-bucket");+ try (Stream<Path> paths = Files.walk(versionDirectory)) {+ assertTrue(paths.noneMatch(Files::isRegularFile));+ }+ }+@Testvoid getObjectNotFoundThrows() {s3Service.createBucket("test-bucket", "us-east-1");diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/S3VersioningIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/S3VersioningIntegrationTest.javaindex b873d749bb..cad52aaec3 100644--- a/src/test/java/io/github/hectorvent/floci/services/s3/S3VersioningIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/s3/S3VersioningIntegrationTest.java@@ -497,4 +497,24 @@ class S3VersioningIntegrationTest {.post("/");}}++ @Test+ @Order(21)+ void deleteBucketRejectsVersionsBehindDeleteMarker() {+ String bucket = "versioned-delete-bucket-test";+ given().when().put("/" + bucket).then().statusCode(200);+ given().body("<VersioningConfiguration><Status>Enabled</Status></VersioningConfiguration>")+ .when().put("/" + bucket + "?versioning").then().statusCode(200);+ String versionId = given().body("data").when().put("/" + bucket + "/key")+ .then().statusCode(200).extract().header("x-amz-version-id");+ String markerId = given().when().delete("/" + bucket + "/key")+ .then().statusCode(204).extract().header("x-amz-version-id");++ given().when().delete("/" + bucket).then().statusCode(409)+ .body(containsString("<Code>BucketNotEmpty</Code>"));++ given().when().delete("/" + bucket + "/key?versionId=" + markerId).then().statusCode(204);+ given().when().delete("/" + bucket + "/key?versionId=" + versionId).then().statusCode(204);+ given().when().delete("/" + bucket).then().statusCode(204);+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/S3VersioningServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/S3VersioningServiceTest.javaindex 7daecc0b6c..d7ba4ca15b 100644--- a/src/test/java/io/github/hectorvent/floci/services/s3/S3VersioningServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/s3/S3VersioningServiceTest.java@@ -178,6 +178,55 @@ class S3VersioningServiceTest {assertTrue(result.versions().stream().anyMatch(S3Object::isDeleteMarker));}+ @Test+ void deleteBucketRejectsDeleteMarkerOnlyUntilPurged() {+ s3Service.putBucketVersioning("versioned-bucket", "Enabled");+ S3Object version = s3Service.putObject("versioned-bucket", "key",+ "data".getBytes(StandardCharsets.UTF_8), "text/plain", null);+ s3Service.deleteObject("versioned-bucket", "key");+ s3Service.deleteObject("versioned-bucket", "key", version.getVersionId());++ assertEquals(1, s3Service.listObjectVersions("versioned-bucket", null, 100, null).versions().size());+ assertBucketNotEmptyThenPurgeAndDelete();+ }++ @Test+ void deleteBucketRejectsSuspendedBucketWithOlderVersionUntilPurged() {+ s3Service.putBucketVersioning("versioned-bucket", "Enabled");+ s3Service.putObject("versioned-bucket", "key",+ "data".getBytes(StandardCharsets.UTF_8), "text/plain", null);+ s3Service.deleteObject("versioned-bucket", "key");+ s3Service.putBucketVersioning("versioned-bucket", "Suspended");++ assertBucketNotEmptyThenPurgeAndDelete();+ }++ @Test+ void purgedBucketCanBeRecreatedWithoutResurrectingVersions() {+ s3Service.putBucketVersioning("versioned-bucket", "Enabled");+ s3Service.putObject("versioned-bucket", "key",+ "data".getBytes(StandardCharsets.UTF_8), "text/plain", null);+ s3Service.deleteObject("versioned-bucket", "key");++ assertBucketNotEmptyThenPurgeAndDelete();+ s3Service.createBucket("versioned-bucket", "us-east-1");+ assertTrue(s3Service.listObjectVersions("versioned-bucket", null, 100, null).versions().isEmpty());+ }++ private void assertBucketNotEmptyThenPurgeAndDelete() {+ AwsException error = assertThrows(AwsException.class,+ () -> s3Service.deleteBucket("versioned-bucket"));+ assertEquals("BucketNotEmpty", error.getErrorCode());+ assertEquals(409, error.getHttpStatus());+ List<S3Object> versions = s3Service.listObjectVersions("versioned-bucket", null, 100, null).versions();+ assertFalse(versions.isEmpty());+ for (S3Object version : versions) {+ s3Service.deleteObject("versioned-bucket", version.getKey(), version.getVersionId());+ }+ assertTrue(s3Service.listObjectVersions("versioned-bucket", null, 100, null).versions().isEmpty());+ assertDoesNotThrow(() -> s3Service.deleteBucket("versioned-bucket"));+ }+@Testvoid getObjectWithNonExistentVersionIdThrowsNoSuchVersion() {s3Service.putBucketVersioning("versioned-bucket", "Enabled");diff --git a/src/test/java/io/github/hectorvent/floci/testing/EnforcementFixtures.java b/src/test/java/io/github/hectorvent/floci/testing/EnforcementFixtures.javaindex 7e505c5802..7d3eb973b1 100644--- a/src/test/java/io/github/hectorvent/floci/testing/EnforcementFixtures.java+++ b/src/test/java/io/github/hectorvent/floci/testing/EnforcementFixtures.java@@ -4,6 +4,11 @@ import io.restassured.path.xml.XmlPath;import io.restassured.response.ValidatableResponse;import io.restassured.specification.RequestSpecification;+import java.net.URLEncoder;+import java.nio.charset.StandardCharsets;+import java.util.ArrayList;+import java.util.List;+import static io.restassured.RestAssured.given;/**@@ -200,30 +205,57 @@ public final class EnforcementFixtures {}/**- * Deletes an unversioned S3 bucket after its current objects. This helper lists one page of- * objects and does not remove old versions or delete markers, so callers must use it only for- * unversioned buckets with at most one page of objects.+ * Deletes an S3 bucket after all its object versions and delete markers. Repeatedly removes+ * the first page so deleting a page cannot invalidate a continuation marker. Retained or+ * locked versions are left for the caller's cleanup to report as a failure.*- * @param authorization an S3-scoped header for an identity allowed to read and delete here+ * @param authorization an S3-scoped header for an identity allowed to list bucket versions,+ * delete object versions, and delete the bucket*/public static void removeBucket(int port, String authorization, String bucket) {if (s3(port, authorization).when().head("/" + bucket).then().extract().statusCode() == 404) {return;}- for (String key : s3(port, authorization)- .queryParam("list-type", "2")- .when()- .get("/" + bucket)- .then()- .statusCode(200)- .extract().xmlPath().getList("ListBucketResult.Contents.Key", String.class)) {- s3(port, authorization).when().delete("/" + bucket + "/" + key)- .then().statusCode(204);+ List<ObjectVersion> previousPage = List.of();+ while (true) {+ XmlPath listing = s3(port, authorization).queryParam("versions", "")+ .queryParam("max-keys", 10)+ .when().get("/" + bucket)+ .then().statusCode(200).extract().xmlPath();+ List<ObjectVersion> page = new ArrayList<>();+ addVersions(page, listing, "Version");+ addVersions(page, listing, "DeleteMarker");+ if (page.isEmpty()) {+ break;+ }+ if (page.equals(previousPage)) {+ throw new IllegalStateException("S3 fixture purge made no progress for bucket " + bucket);+ }+ for (ObjectVersion version : page) {+ String encodedKey = URLEncoder.encode(version.key(), StandardCharsets.UTF_8)+ .replace("+", "%20").replace("%2F", "/");+ s3(port, authorization).urlEncodingEnabled(false)+ .queryParam("versionId", version.versionId())+ .when().delete("/" + bucket + "/" + encodedKey)+ .then().statusCode(204);+ }+ previousPage = page;}s3(port, authorization).when().delete("/" + bucket).then().statusCode(204);}+ private static void addVersions(List<ObjectVersion> page, XmlPath listing, String element) {+ List<String> keys = listing.getList("ListVersionsResult." + element + ".Key", String.class);+ List<String> versionIds = listing.getList("ListVersionsResult." + element + ".VersionId", String.class);+ for (int i = 0; i < keys.size(); i++) {+ page.add(new ObjectVersion(keys.get(i), versionIds.get(i)));+ }+ }++ private record ObjectVersion(String key, String versionId) {+ }+private static ValidatableResponse iam(int port, String authorization, String action,String... params) {RequestSpecification request = given().port(port)diff --git a/src/test/java/io/github/hectorvent/floci/testing/EnforcementFixturesIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/testing/EnforcementFixturesIntegrationTest.javanew file mode 100644index 0000000000..e67adfcfd5--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/testing/EnforcementFixturesIntegrationTest.java@@ -0,0 +1,67 @@+package io.github.hectorvent.floci.testing;++import io.quarkus.test.common.http.TestHTTPResource;+import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.TestProfile;+import org.junit.jupiter.api.Test;++import java.net.URI;+import java.util.UUID;++import static io.github.hectorvent.floci.testing.EnforcementFixtures.auth;+import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;++@QuarkusTest+@TestProfile(IamEnforcementProfile.class)+class EnforcementFixturesIntegrationTest {++ @TestHTTPResource("/")+ URI baseUri;++ @Test+ void removeBucketPurgesNullVersionVersionsAndMarkersAcrossPages() {+ String bucket = "fixture-purge-" + UUID.randomUUID();+ String authorization = auth("test", "s3");+ String key = "/" + bucket + "/first.txt";++ given().header("Authorization", authorization).when().put("/" + bucket)+ .then().statusCode(200);+ given().header("Authorization", authorization).body("before versioning")+ .when().put("/" + bucket + "/null.txt").then().statusCode(200);+ given().header("Authorization", authorization)+ .body("<VersioningConfiguration><Status>Enabled</Status></VersioningConfiguration>")+ .queryParam("versioning", "")+ .when().put("/" + bucket).then().statusCode(200);+ for (int i = 0; i < 11; i++) {+ given().header("Authorization", authorization).body("version " + i)+ .when().put(key).then().statusCode(200);+ }+ given().header("Authorization", authorization).when().delete(key).then().statusCode(204);+ given().header("Authorization", authorization).body("other key")+ .when().put("/" + bucket + "/second.txt").then().statusCode(200);+ given().urlEncodingEnabled(false).header("Authorization", authorization)+ .body("reserved key")+ .when().put("/" + bucket + "/dir/reserved%3Fhash%23%2Bpercent%25%20space.txt")+ .then().statusCode(200);++ given().header("Authorization", authorization).queryParam("versions", "")+ .queryParam("max-keys", 10)+ .when().get("/" + bucket).then().statusCode(200)+ .body(containsString("<IsTruncated>true</IsTruncated>"))+ .body(containsString("<NextKeyMarker>first.txt</NextKeyMarker>"));+ given().header("Authorization", authorization).queryParam("versions", "")+ .queryParam("prefix", "null.txt")+ .when().get("/" + bucket).then().statusCode(200)+ .body(containsString("<VersionId>null</VersionId>"));+ given().header("Authorization", authorization).queryParam("versions", "")+ .queryParam("prefix", "dir/")+ .when().get("/" + bucket).then().statusCode(200)+ .body(containsString("<Key>dir/reserved?hash#+percent% space.txt</Key>"));++ EnforcementFixtures.removeBucket(baseUri.getPort(), authorization, bucket);++ given().header("Authorization", authorization).when().head("/" + bucket)+ .then().statusCode(404);+ }+}