delete operation related bucket tests migration

Issue: CLDSRV-724

Author: benzekrimaha

tests/functional/aws-node-sdk/test/bucket/deleteBucketLifecycle.js

@@ -1,9 +1,13 @@
 const assert = require('assert');
 const { errors } = require('arsenal');
-const { S3 } = require('aws-sdk');
+const { S3Client,
+    CreateBucketCommand,
+    DeleteBucketCommand,
+    DeleteBucketLifecycleCommand,
+    PutBucketLifecycleConfigurationCommand,
+    GetBucketLifecycleConfigurationCommand } = require('@aws-sdk/client-s3');
 
 const getConfig = require('../support/config');
-const BucketUtility = require('../../lib/utility/bucket-util');
 
 const bucket = 'lifecycledeletetestbucket';
 const basicRule = {
@@ -16,17 +20,16 @@ const basicRule = {
 };
 
 // Check for the expected error response code and status code.
-function assertError(err, expectedErr, cb) {
+function assertError(err, expectedErr) {
     if (expectedErr === null) {
         assert.strictEqual(err, null, `expected no error but got '${err}'`);
     } else {
-        assert.strictEqual(err.code, expectedErr, 'incorrect error response ' +
-            `code: should be '${expectedErr}' but got '${err.code}'`);
-        assert.strictEqual(err.statusCode, errors[expectedErr].code,
+        assert.strictEqual(err.name, expectedErr, 'incorrect error response ' +
+            `code: should be '${expectedErr}' but got '${err.Code}'`);
+        assert.strictEqual(err.$metadata.httpStatusCode, errors[expectedErr].code,
             'incorrect error status code: should be 400 but got ' +
-            `'${err.statusCode}'`);
+            `'${err.$metadata.httpStatusCode}'`);
     }
-    cb();
 }
 
 describe('aws-sdk test delete bucket lifecycle', () => {
@@ -35,43 +38,51 @@ describe('aws-sdk test delete bucket lifecycle', () => {
 
     before(done => {
         const config = getConfig('default', { signatureVersion: 'v4' });
-        s3 = new S3(config);
-        otherAccountS3 = new BucketUtility('lisa', {}).s3;
+        s3 = new S3Client(config);
+        const otherAccountConfig = getConfig('lisa', {});
+        otherAccountS3 = new S3Client(otherAccountConfig);
         return done();
     });
 
-    it('should return NoSuchBucket error if bucket does not exist', done => {
-        s3.deleteBucketLifecycle({ Bucket: bucket }, err =>
-            assertError(err, 'NoSuchBucket', done));
+    it('should return NoSuchBucket error if bucket does not exist', async () => {
+        try {
+            await s3.send(new DeleteBucketLifecycleCommand({ Bucket: bucket }));
+            // Should not reach here
+            throw new Error('Expected NoSuchBucket error');
+        } catch (err) {
+            assertError(err, 'NoSuchBucket');
+        }
     });
 
     describe('config rules', () => {
-        beforeEach(done => s3.createBucket({ Bucket: bucket }, done));
+        beforeEach(() => s3.send(new CreateBucketCommand({ Bucket: bucket })));
 
-        afterEach(done => s3.deleteBucket({ Bucket: bucket }, done));
+        afterEach(() => s3.send(new DeleteBucketCommand({ Bucket: bucket })));
 
-        it('should return AccessDenied if user is not bucket owner', done => {
-            otherAccountS3.deleteBucketLifecycle({ Bucket: bucket },
-            err => assertError(err, 'AccessDenied', done));
+        it('should return AccessDenied if user is not bucket owner', async () => {
+            try {
+                await otherAccountS3.send(new DeleteBucketLifecycleCommand({ Bucket: bucket }));
+                // Should not reach here
+                throw new Error('Expected AccessDenied error');
+            } catch (err) {
+                assertError(err, 'AccessDenied');
+            }
         });
 
-        it('should return no error if no lifecycle config on bucket', done => {
-            s3.deleteBucketLifecycle({ Bucket: bucket }, err =>
-                assertError(err, null, done));
-        });
+        it('should return no error if no lifecycle config on bucket', () => s3.send(new
+            DeleteBucketLifecycleCommand({ Bucket: bucket })));
 
-        it('should delete lifecycle configuration from bucket', done => {
+        it('should delete lifecycle configuration from bucket', async () => {
             const params = { Bucket: bucket,
                 LifecycleConfiguration: { Rules: [basicRule] } };
-            s3.putBucketLifecycleConfiguration(params, err => {
-                assert.equal(err, null);
-                s3.deleteBucketLifecycle({ Bucket: bucket }, err => {
-                    assert.equal(err, null);
-                    s3.getBucketLifecycleConfiguration({ Bucket: bucket },
-                    err =>
-                        assertError(err, 'NoSuchLifecycleConfiguration', done));
-                });
-            });
+            await s3.send(new PutBucketLifecycleConfigurationCommand(params));
+            await s3.send(new DeleteBucketLifecycleCommand({ Bucket: bucket }));
+            try {
+                await s3.send(new GetBucketLifecycleConfigurationCommand({ Bucket: bucket }));
+                throw new Error('Expected NoSuchLifecycleConfiguration error');
+            } catch (err) {
+                assertError(err, 'NoSuchLifecycleConfiguration');
+            }
         });
     });
 });

tests/functional/aws-node-sdk/test/bucket/deleteBucketPolicy.js

@@ -1,6 +1,11 @@
 const assert = require('assert');
 const { errors } = require('arsenal');
-const { S3 } = require('aws-sdk');
+const { S3Client,
+    CreateBucketCommand,
+    DeleteBucketCommand,
+    DeleteBucketPolicyCommand,
+    PutBucketPolicyCommand,
+    GetBucketPolicyCommand } = require('@aws-sdk/client-s3');
 
 const getConfig = require('../support/config');
 const BucketUtility = require('../../lib/utility/bucket-util');
@@ -18,17 +23,16 @@ const bucketPolicy = {
 };
 
 // Check for the expected error response code and status code.
-function assertError(err, expectedErr, cb) {
+function assertError(err, expectedErr) {
     if (expectedErr === null) {
         assert.strictEqual(err, null, `expected no error but got '${err}'`);
     } else {
-        assert.strictEqual(err.code, expectedErr, 'incorrect error response ' +
-            `code: should be '${expectedErr}' but got '${err.code}'`);
-        assert.strictEqual(err.statusCode, errors[expectedErr].code,
+        assert.strictEqual(err.name, expectedErr, 'incorrect error response ' +
+            `code: should be '${expectedErr}' but got '${err.name}'`);
+        assert.strictEqual(err.$metadata.httpStatusCode, errors[expectedErr].code,
             'incorrect error status code: should be 400 but got ' +
-            `'${err.statusCode}'`);
+            `'${err.$metadata.httpStatusCode}'`);
     }
-    cb();
 }
 
 describe('aws-sdk test delete bucket policy', () => {
@@ -37,42 +41,48 @@ describe('aws-sdk test delete bucket policy', () => {
 
     before(done => {
         const config = getConfig('default', { signatureVersion: 'v4' });
-        s3 = new S3(config);
+        s3 = new S3Client(config);
         otherAccountS3 = new BucketUtility('lisa', {}).s3;
         return done();
     });
 
-    it('should return NoSuchBucket error if bucket does not exist', done => {
-        s3.deleteBucketPolicy({ Bucket: bucket }, err =>
-            assertError(err, 'NoSuchBucket', done));
+    it('should return NoSuchBucket error if bucket does not exist', async () => {
+        try {
+            await s3.send(new DeleteBucketPolicyCommand({ Bucket: bucket }));
+            throw new Error('Expected NoSuchBucket error');
+        } catch (err) {
+            assertError(err, 'NoSuchBucket');
+        }
     });
 
     describe('policy rules', () => {
-        beforeEach(done => s3.createBucket({ Bucket: bucket }, done));
+        beforeEach(() => s3.send(new CreateBucketCommand({ Bucket: bucket })));
 
-        afterEach(done => s3.deleteBucket({ Bucket: bucket }, done));
+        afterEach(() => s3.send(new DeleteBucketCommand({ Bucket: bucket })));
 
-        it('should return MethodNotAllowed if user is not bucket owner', done => {
-            otherAccountS3.deleteBucketPolicy({ Bucket: bucket },
-            err => assertError(err, 'MethodNotAllowed', done));
+        it('should return MethodNotAllowed if user is not bucket owner', async () => {
+            try {
+                await otherAccountS3.send(new DeleteBucketPolicyCommand({ Bucket: bucket }));
+                throw new Error('Expected MethodNotAllowed error');
+            } catch (err) {
+                assertError(err, 'MethodNotAllowed');
+            }
         });
 
-        it('should return no error if no policy on bucket', done => {
-            s3.deleteBucketPolicy({ Bucket: bucket }, err =>
-                assertError(err, null, done));
+        it('should return no error if no policy on bucket', () => {
+            s3.send(new DeleteBucketPolicyCommand({ Bucket: bucket }));
         });
 
-        it('should delete policy from bucket', done => {
+        it('should delete policy from bucket', async () => {
             const params = { Bucket: bucket, Policy: JSON.stringify(bucketPolicy) };
-            s3.putBucketPolicy(params, err => {
-                assert.equal(err, null);
-                s3.deleteBucketPolicy({ Bucket: bucket }, err => {
-                    assert.equal(err, null);
-                    s3.getBucketPolicy({ Bucket: bucket },
-                    err =>
-                        assertError(err, 'NoSuchBucketPolicy', done));
-                });
-            });
+            await s3.send(new PutBucketPolicyCommand(params));
+            await s3.send(new DeleteBucketPolicyCommand({ Bucket: bucket }));
+            try {
+                await s3.send(new GetBucketPolicyCommand({ Bucket: bucket }));
+                throw new Error('Expected NoSuchBucketPolicy error');
+            } catch (err) {
+                assertError(err, 'NoSuchBucketPolicy');
+            }
         });
     });
 });

tests/functional/aws-node-sdk/test/bucket/deleteBucketQuota.js

@@ -1,5 +1,6 @@
-const AWS = require('aws-sdk');
-const S3 = AWS.S3;
+const { S3Client,
+    CreateBucketCommand,
+    DeleteBucketCommand } = require('@aws-sdk/client-s3');
 const assert = require('assert');
 const getConfig = require('../support/config');
 const sendRequest = require('../quota/tooling').sendRequest;
@@ -12,20 +13,18 @@ describe('Test delete bucket quota', () => {
 
     before(() => {
         const config = getConfig('default', { signatureVersion: 'v4' });
-        s3 = new S3(config);
-        AWS.config.update(config);
+        s3 = new S3Client(config);
     });
 
-    beforeEach(done => s3.createBucket({ Bucket: bucket }, done));
+    beforeEach(() => s3.send(new CreateBucketCommand({ Bucket: bucket })));
 
-    afterEach(done => s3.deleteBucket({ Bucket: bucket }, done));
+    afterEach(() => s3.send(new DeleteBucketCommand({ Bucket: bucket })));
 
     it('should delete the bucket quota', async () => {
         try {
             await sendRequest('DELETE', '127.0.0.1:8000', `/${bucket}/?quota=true`);
-            assert.ok(true);
         } catch (err) {
-            assert.fail(`Expected no error, but got ${err}`);
+            assert.fail(`Unexpected error: ${err}`);
         }
     });
 

tests/functional/aws-node-sdk/test/bucket/deleteBucketReplication.js

@@ -1,6 +1,11 @@
 const assert = require('assert');
-const { S3 } = require('aws-sdk');
-const { series } = require('async');
+const { S3Client,
+    CreateBucketCommand,
+    DeleteBucketCommand,
+    PutBucketVersioningCommand,
+    PutBucketReplicationCommand,
+    DeleteBucketReplicationCommand,
+    GetBucketReplicationCommand } = require('@aws-sdk/client-s3');
 const { errorInstances } = require('arsenal');
 
 const getConfig = require('../support/config');
@@ -25,72 +30,69 @@ describe('aws-node-sdk test deleteBucketReplication', () => {
     let otherAccountS3;
     const config = getConfig('default', { signatureVersion: 'v4' });
 
-    function putVersioningOnBucket(bucket, cb) {
-        return s3.putBucketVersioning({
+    function putVersioningOnBucket(bucket) {
+        return s3.send(new PutBucketVersioningCommand({
             Bucket: bucket,
             VersioningConfiguration: { Status: 'Enabled' },
-        }, cb);
+        }));
     }
 
-    function putReplicationOnBucket(bucket, cb) {
-        return s3.putBucketReplication({
+    function putReplicationOnBucket(bucket) {
+        return s3.send(new PutBucketReplicationCommand({
             Bucket: bucket,
             ReplicationConfiguration: replicationConfig,
-        }, cb);
+        }));
     }
 
-    function deleteReplicationAndCheckResponse(bucket, cb) {
-        return s3.deleteBucketReplication({ Bucket: bucket }, (err, data) => {
-            assert.strictEqual(err, null);
-            assert.deepStrictEqual(data, {});
-            return cb();
-        });
+    function deleteReplicationAndCheckResponse(bucket) {
+        return s3.send(new DeleteBucketReplicationCommand({ Bucket: bucket }))
+            .then(data => {
+                assert.deepStrictEqual(data.$metadata.httpStatusCode, 204);
+            });
     }
 
-    beforeEach(done => {
-        s3 = new S3(config);
+    beforeEach(() => {
+        s3 = new S3Client(config);
         otherAccountS3 = new BucketUtility('lisa', {}).s3;
-        return s3.createBucket({ Bucket: bucket }, done);
+        return s3.send(new CreateBucketCommand({ Bucket: bucket }));
     });
 
-    afterEach(done => s3.deleteBucket({ Bucket: bucket }, done));
+    afterEach(() => s3.send(new DeleteBucketCommand({ Bucket: bucket })));
 
-    it('should return empty object if bucket has no replication config', done =>
-        deleteReplicationAndCheckResponse(bucket, done));
+    it('should return empty object if bucket has no replication config', 
+        () => deleteReplicationAndCheckResponse(bucket));
 
-    it('should delete a bucket replication config when it has one', done =>
-        series([
-            next => putVersioningOnBucket(bucket, next),
-            next => putReplicationOnBucket(bucket, next),
-            next => deleteReplicationAndCheckResponse(bucket, next),
-        ], done));
+    it('should delete a bucket replication config when it has one', async () => {
+        await putVersioningOnBucket(bucket);
+        await putReplicationOnBucket(bucket);
+        await deleteReplicationAndCheckResponse(bucket);
+    });
 
     it('should return ReplicationConfigurationNotFoundError if getting ' +
-    'replication config after it has been deleted', done =>
-        series([
-            next => putVersioningOnBucket(bucket, next),
-            next => putReplicationOnBucket(bucket, next),
-            next => s3.getBucketReplication({ Bucket: bucket }, (err, data) => {
-                if (err) {
-                    return next(err);
-                }
-                assert.deepStrictEqual(data, {
-                    ReplicationConfiguration: replicationConfig,
-                });
-                return next();
-            }),
-            next => deleteReplicationAndCheckResponse(bucket, next),
-            next => s3.getBucketReplication({ Bucket: bucket }, err => {
-                assert(errorInstances.ReplicationConfigurationNotFoundError.is[err.code]);
-                return next();
-            }),
-        ], done));
+    'replication config after it has been deleted', async () => {
+        await putVersioningOnBucket(bucket);
+        await putReplicationOnBucket(bucket);
+        
+        const data = await s3.send(new GetBucketReplicationCommand({ Bucket: bucket }));
+        assert.deepStrictEqual(data.ReplicationConfiguration, replicationConfig);
 
-    it('should return AccessDenied if user is not bucket owner', done =>
-        otherAccountS3.deleteBucketReplication({ Bucket: bucket }, err => {
-            assert(err);
-            assert.strictEqual(err.code, 'AccessDenied');
-            assert.strictEqual(err.statusCode, 403);
-            return done();
-        }));
+        await deleteReplicationAndCheckResponse(bucket);
+        
+        try {
+            await s3.send(new GetBucketReplicationCommand({ Bucket: bucket }));
+            assert.fail('Expected ReplicationConfigurationNotFoundError');
+        } catch (err) {
+            assert(errorInstances.ReplicationConfigurationNotFoundError.is[err.name]);
+        }
+    });
+
+    it('should return AccessDenied if user is not bucket owner', async () => {
+        try {
+            await otherAccountS3.send(new DeleteBucketReplicationCommand({ Bucket: bucket }));
+            assert.fail('Expected AccessDenied error');
+        } catch (err) {
+            assert.strictEqual(err.name, 'AccessDenied');
+            assert.strictEqual(err.$metadata.httpStatusCode, 403);
+        }
+    });
 });