Skip to content

armgit / floci

Public Imported from GitHub
0

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.bats
index 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.java
index 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.java
index 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 {
@AfterAll
static 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.java
index 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 {
@AfterAll
static 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.java
index 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.java
index 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.java
index 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));
+ }
+ }
+
@Test
void 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.java
index 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.java
index 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"));
+ }
+
@Test
void 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.java
index 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.java
new file mode 100644
index 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);
+ }
+}