add functional restore via objectOverwite tests

Author: benzekrimaha

tests/functional/aws-node-sdk/test/object/objectOverwrite.js

@@ -1,12 +1,19 @@
 const assert = require('assert');
+const { promisify } = require('util');
 const {
     PutObjectCommand,
+    PutBucketVersioningCommand,
     HeadObjectCommand,
     GetObjectCommand,
+    ListObjectVersionsCommand,
 } = require('@aws-sdk/client-s3');
 
 const withV4 = require('../support/withV4');
 const BucketUtility = require('../../lib/utility/bucket-util');
+const { fakeMetadataArchive, getMetadata, initMetadata } = require('../utils/init');
+const fakeMetadataArchivePromise = promisify(fakeMetadataArchive);
+const getMetadataPromise = promisify(getMetadata);
+const initMetadataPromise = promisify(initMetadata);
 
 const objectName = 'someObject';
 const firstPutMetadata = {
@@ -30,6 +37,7 @@ describe('Put object with same key as prior object', () => {
             bucketUtil = new BucketUtility('default', sigCfg);
             s3 = bucketUtil.s3;
             bucketName = await bucketUtil.createRandom(1);
+            await initMetadataPromise();
         });
 
         beforeEach(async () => {
@@ -66,5 +74,66 @@ describe('Put object with same key as prior object', () => {
                 const bodyText = await res.Body.transformToString();
                 assert.deepStrictEqual(bodyText, 'Much different');
             });
+
+        it('should replace archived object in non-versioned bucket', async () => {
+            await fakeMetadataArchivePromise(bucketName, objectName, undefined, {
+                archiveInfo: { archiveId: 'archive-1' },
+                restoreRequestedAt: new Date(0).toISOString(),
+                restoreRequestedDays: 5,
+            });
+
+            await s3.send(new PutObjectCommand({
+                Bucket: bucketName,
+                Key: objectName,
+                Body: 'overwrite archived data',
+                Metadata: secondPutMetadata,
+            }));
+
+            const currentMD = await getMetadataPromise(bucketName, objectName, undefined);
+            assert.strictEqual(currentMD.archive, undefined);
+        });
+
+        it('should preserve archived previous version in versioned bucket', async () => {
+            await s3.send(new PutBucketVersioningCommand({
+                Bucket: bucketName,
+                VersioningConfiguration: { Status: 'Enabled' },
+            }));
+
+            const firstPutRes = await s3.send(new PutObjectCommand({
+                Bucket: bucketName,
+                Key: objectName,
+                Body: 'versioned first payload',
+                Metadata: firstPutMetadata,
+            }));
+
+            await fakeMetadataArchivePromise(bucketName, objectName, firstPutRes.VersionId, {
+                archiveInfo: { archiveId: 'archive-versioned-1' },
+                restoreRequestedAt: new Date(0).toISOString(),
+                restoreRequestedDays: 5,
+            });
+
+            const secondPutRes = await s3.send(new PutObjectCommand({
+                Bucket: bucketName,
+                Key: objectName,
+                Body: 'versioned second payload',
+                Metadata: secondPutMetadata,
+            }));
+
+            const archivedVersionMD = await getMetadataPromise(
+                bucketName, objectName, firstPutRes.VersionId);
+            assert(archivedVersionMD.archive);
+            assert(archivedVersionMD.archive.archiveInfo);
+
+            const currentVersionMD = await getMetadataPromise(
+                bucketName, objectName, secondPutRes.VersionId);
+            assert.strictEqual(currentVersionMD.archive, undefined);
+
+            const listed = await s3.send(new ListObjectVersionsCommand({
+                Bucket: bucketName,
+                Prefix: objectName,
+            }));
+            const objectVersions = (listed.Versions || []).filter(v => v.Key === objectName);
+            assert(objectVersions.length >= 2);
+        });
     });
 });