Add CTST coverage for Days=0 lifecycle expiration

Add an end-to-end test using the S3 PutBucketLifecycleConfiguration API:
a Scenario Outline over non-versioned, versioned and suspended buckets
that sets a whole-bucket Days=0 expiration (current version, or current
and noncurrent versions) and asserts the bucket empties.

Factor the lifecycle-config PUT-with-retry logic shared with the
transition workflow helper into putBucketLifecycleConfigurationWithRetry,
and add an addExpirationWorkflow helper. Days=0 makes objects immediately
eligible, so the test needs no time-progression or one-day-earlier tricks.

Issue: ZENKO-5314

Author: delthas

tests/functional/ctst/features/lifecycleExpiration.feature

@@ -0,0 +1,17 @@
+Feature: Lifecycle expiration
+
+    @2.16.0
+    @PreMerge
+    @Expiration
+    @Lifecycle
+    Scenario Outline: Days=0 expiration empties a "<versioningConfiguration>" bucket
+    Given a "<versioningConfiguration>" bucket
+    And 5 objects "expire-obj" of size 100 bytes
+    When i set a lifecycle expiration of 0 days for the "<scope>"
+    Then the bucket should contain 0 objects within 180 seconds
+
+    Examples:
+        | versioningConfiguration | scope                           |
+        |           Non versioned | current version                 |
+        |               Versioned | current and noncurrent versions |
+        |               Suspended | current and noncurrent versions |

tests/functional/ctst/steps/lifecycleExpiration.ts

@@ -0,0 +1,39 @@
+import { Then, When } from '@cucumber/cucumber';
+import { S3, Utils } from 'cli-testing';
+import { ListObjectVersionsOutput } from '@aws-sdk/client-s3';
+import assert from 'assert';
+import Zenko from 'world/Zenko';
+import { safeJsonParse } from 'common/utils';
+import { addExpirationWorkflow } from './utils/utils';
+
+When('i set a lifecycle expiration of {int} days for the {string}',
+    async function (this: Zenko, days: number, scope: string) {
+        const includeNoncurrent: Record<string, boolean> = {
+            'current version': false,
+            'current and noncurrent versions': true,
+        };
+        assert(scope in includeNoncurrent, `Unknown expiration scope "${scope}"`);
+        await addExpirationWorkflow.call(this, days, includeNoncurrent[scope]);
+    });
+
+Then('the bucket should contain {int} objects within {int} seconds', { timeout: 6 * 60 * 1000 },
+    async function (this: Zenko, expectedCount: number, seconds: number) {
+        const bucketName = this.getSaved<string>('bucketName');
+        const deadline = Date.now() + seconds * 1000;
+        let count = -1;
+        do {
+            const res = await S3.listObjectVersions({ bucket: bucketName, maxItems: '1000' });
+            const parsed = safeJsonParse<ListObjectVersionsOutput>(res.stdout || '{}');
+            assert.ok(parsed.ok, `Failed to list versions in bucket ${bucketName}: ${parsed.error}`);
+            const versions = parsed.result?.Versions ?? [];
+            const deleteMarkers = parsed.result?.DeleteMarkers ?? [];
+            count = versions.length + deleteMarkers.length;
+            if (count === expectedCount) {
+                return;
+            }
+            await Utils.sleep(2000);
+        } while (Date.now() < deadline);
+        assert.fail(
+            `Bucket ${bucketName} has ${count} versions/delete markers, ` +
+            `expected ${expectedCount} after ${seconds}s`);
+    });

tests/functional/ctst/steps/utils/utils.ts

@@ -378,35 +378,52 @@ async function emptyVersionedBucket(world: Zenko) {
     }));
 }
 
-async function addTransitionWorkflow(this: Zenko, location: string, enabled = true) {
-    let conditionOk = false;
-    this.resetCommand();
-    this.addCommandParameter({ bucket: this.getSaved<string>('bucketName') });
-    const enabledStr = enabled ? 'Enabled' : 'Disabled';
-    const lifecycleConfiguration = JSON.stringify({
-        Rules: [
-            {
-                Status: enabledStr,
-                Prefix: '',
-                Transitions: [
-                    {
-                        Days: 0,
-                        StorageClass: location,
-                    },
-                ],
-            },
-        ],
-    });
-    this.addCommandParameter({
-        lifecycleConfiguration,
+async function putBucketLifecycleConfigurationWithRetry(world: Zenko, rules: Record<string, unknown>[]) {
+    world.resetCommand();
+    world.addCommandParameter({ bucket: world.getSaved<string>('bucketName') });
+    world.addCommandParameter({
+        lifecycleConfiguration: JSON.stringify({ Rules: rules }),
     });
-    const commandParameters = this.getCommandParameters();
+    const commandParameters = world.getCommandParameters();
+    let conditionOk = false;
     while (!conditionOk) {
         const res = await S3.putBucketLifecycleConfiguration(commandParameters);
         conditionOk = res.err === null;
-        // Wait for the transition to be accepted because the deployment of the location's pods can take some time
-        await Utils.sleep(5000); 
+        // Wait for the configuration to be accepted because the deployment of the location's pods can take some time
+        await Utils.sleep(5000);
+    }
+}
+
+async function addTransitionWorkflow(this: Zenko, location: string, enabled = true) {
+    const enabledStr = enabled ? 'Enabled' : 'Disabled';
+    await putBucketLifecycleConfigurationWithRetry(this, [
+        {
+            Status: enabledStr,
+            Prefix: '',
+            Transitions: [
+                {
+                    Days: 0,
+                    StorageClass: location,
+                },
+            ],
+        },
+    ]);
+}
+
+async function addExpirationWorkflow(this: Zenko, days: number, includeNoncurrentVersions = false) {
+    const rule: Record<string, unknown> = {
+        Status: 'Enabled',
+        Prefix: '',
+        Expiration: {
+            Days: days,
+        },
+    };
+    if (includeNoncurrentVersions) {
+        rule.NoncurrentVersionExpiration = {
+            NoncurrentDays: days,
+        };
     }
+    await putBucketLifecycleConfigurationWithRetry(this, [rule]);
 }
 
 async function getReplicationLocationConfig(world: Zenko, location: string): Promise<{
@@ -601,6 +618,7 @@ export {
     getObjectNameWithBackendFlakiness,
     restoreObject,
     addTransitionWorkflow,
+    addExpirationWorkflow,
     getReplicationLocationConfig,
     putBucketReplication,
 };