tests adding

Author: benzekrimaha

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

@@ -9,8 +9,9 @@ const {
 
 const withV4 = require('../support/withV4');
 const BucketUtility = require('../../lib/utility/bucket-util');
-const { fakeMetadataArchive, getMetadata, initMetadata } = require('../utils/init');
+const { fakeMetadataArchive, fakeMetadataTransition, getMetadata, initMetadata } = require('../utils/init');
 const fakeMetadataArchivePromise = promisify(fakeMetadataArchive);
+const fakeMetadataTransitionPromise = promisify(fakeMetadataTransition);
 const getMetadataPromise = promisify(getMetadata);
 const initMetadataPromise = promisify(initMetadata);
 
@@ -74,22 +75,54 @@ describe('Put object with same key as prior object', () => {
                 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,
-            });
+        [
+            {
+                name: 'transition in progress',
+                setup: () => fakeMetadataTransitionPromise(bucketName, objectName, undefined),
+            },
+            {
+                name: 'archived',
+                setup: () => fakeMetadataArchivePromise(bucketName, objectName, undefined, {
+                    archiveInfo: { archiveId: 'archive-1' },
+                    restoreRequestedAt: new Date(0).toISOString(),
+                    restoreRequestedDays: 5,
+                }),
+            },
+            {
+                name: 'restored (not expired)',
+                setup: () => fakeMetadataArchivePromise(bucketName, objectName, undefined, {
+                    archiveInfo: { archiveId: 'archive-restored' },
+                    restoreRequestedAt: new Date(0).toISOString(),
+                    restoreRequestedDays: 5,
+                    restoreCompletedAt: new Date(Date.now() - 60 * 60 * 1000).toISOString(),
+                    restoreWillExpireAt: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
+                }),
+            },
+            {
+                name: 'restored (expired)',
+                setup: () => fakeMetadataArchivePromise(bucketName, objectName, undefined, {
+                    archiveInfo: { archiveId: 'archive-expired' },
+                    restoreRequestedAt: new Date(0).toISOString(),
+                    restoreRequestedDays: 5,
+                    restoreCompletedAt: new Date(Date.now() - 48 * 60 * 60 * 1000).toISOString(),
+                    restoreWillExpireAt: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(),
+                }),
+            },
+        ].forEach(({ name, setup }) => {
+            it(`should replace object with cold-state metadata (${name}) in non-versioned bucket`, async () => {
+                await setup();
 
-            await s3.send(new PutObjectCommand({
-                Bucket: bucketName,
-                Key: objectName,
-                Body: 'overwrite archived data',
-                Metadata: secondPutMetadata,
-            }));
+                await s3.send(new PutObjectCommand({
+                    Bucket: bucketName,
+                    Key: objectName,
+                    Body: `overwrite cold state ${name}`,
+                    Metadata: secondPutMetadata,
+                }));
 
-            const currentMD = await getMetadataPromise(bucketName, objectName, undefined);
-            assert.strictEqual(currentMD.archive, undefined);
+                const currentMD = await getMetadataPromise(bucketName, objectName, undefined);
+                assert.strictEqual(currentMD.archive, undefined);
+                assert.strictEqual(currentMD['x-amz-scal-transition-in-progress'], undefined);
+            });
         });
 
         it('should create a new version when replacing archived current object in versioned bucket', async () => {
@@ -133,5 +166,46 @@ describe('Put object with same key as prior object', () => {
             assert.strictEqual(currentMD.archive, undefined);
         });
 
+        it('should replace archived current null version in version-suspended bucket', async () => {
+            await bucketUtil.empty(bucketName);
+
+            await s3.send(new PutBucketVersioningCommand({
+                Bucket: bucketName,
+                VersioningConfiguration: { Status: 'Enabled' },
+            }));
+            await s3.send(new PutObjectCommand({
+                Bucket: bucketName,
+                Key: objectName,
+                Body: 'enabled-version-payload',
+            }));
+            await s3.send(new PutBucketVersioningCommand({
+                Bucket: bucketName,
+                VersioningConfiguration: { Status: 'Suspended' },
+            }));
+
+            await s3.send(new PutObjectCommand({
+                Bucket: bucketName,
+                Key: objectName,
+                Body: 'null-current-before-archive',
+            }));
+
+            await fakeMetadataArchivePromise(bucketName, objectName, undefined, {
+                archiveInfo: { archiveId: 'archive-null-current' },
+                restoreRequestedAt: new Date(0).toISOString(),
+                restoreRequestedDays: 5,
+            });
+
+            await s3.send(new PutObjectCommand({
+                Bucket: bucketName,
+                Key: objectName,
+                Body: 'replace archived null current',
+                Metadata: secondPutMetadata,
+            }));
+
+            const currentMD = await getMetadataPromise(bucketName, objectName, undefined);
+            assert.strictEqual(currentMD.archive, undefined);
+            assert.deepStrictEqual(currentMD['x-amz-meta-secondput'], secondPutMetadata.secondput);
+        });
+
     });
 });

tests/unit/api/createAndStoreObject.js

@@ -303,6 +303,7 @@ describe('createAndStoreObject', () => {
                     assert.ifError(err);
                     // Verify archive info was updated
                     const storedObjMD = getStoredObjectData();
+                    const options = getStoredOptions();
                     assert(storedObjMD.archive.restoreCompletedAt, 'restoreCompletedAt should be set');
                     assert(storedObjMD.archive.restoreWillExpireAt, 'restoreWillExpireAt should be set');
                     assert.strictEqual(storedObjMD.archive.restoreRequestedDays, 7);
@@ -313,6 +314,9 @@ describe('createAndStoreObject', () => {
 
                     // Verify originOp set correctly
                     assert.strictEqual(storedObjMD.originOp, 's3:ObjectRestore:Completed');
+                    // PutObjectVersion must not use archived-overwrite oplog path.
+                    assert.strictEqual(options.needOplogUpdate, undefined);
+                    assert.strictEqual(options.originOp, undefined);
 
                     done();
                 });