Improvement/cldsrv 724 multiple backend tests

tests/functional/aws-node-sdk/lib/utility/versioning-util.js

@@ -1,10 +1,16 @@
 const async = require('async');
 const assert = require('assert');
-const { S3 } = require('aws-sdk');
+const { S3Client, 
+    ListObjectVersionsCommand, 
+    GetObjectCommand,
+    DeleteObjectsCommand,
+    PutBucketVersioningCommand,
+    PutObjectCommand,
+    DeleteObjectCommand } = require('@aws-sdk/client-s3');
 
 const getConfig = require('../../test/support/config');
-const config = getConfig('default', { signatureVersion: 'v4' });
-const s3 = new S3(config);
+const config = getConfig('default');
+const s3Client = new S3Client(config);
 
 const versioningEnabled = { Status: 'Enabled' };
 const versioningSuspended = { Status: 'Suspended' };
@@ -19,28 +25,25 @@ function _deleteVersionList(versionList, bucket, callback) {
             Key: version.Key, VersionId: version.VersionId });
     });
 
-    return s3.deleteObjects(params, callback);
+    return s3Client.send(new DeleteObjectsCommand(params)).then(() => callback()).catch(err => callback(err));
 }
 
 function checkOneVersion(s3, bucket, versionId, callback) {
-    return s3.listObjectVersions({ Bucket: bucket },
-        (err, data) => {
-            if (err) {
-                callback(err);
-            }
+    return s3Client.send(new ListObjectVersionsCommand({ Bucket: bucket })).then(data => {
             assert.strictEqual(data.Versions.length, 1);
             if (versionId) {
                 assert.strictEqual(data.Versions[0].VersionId, versionId);
             }
             assert.strictEqual(data.DeleteMarkers.length, 0);
             callback();
-        });
+        }).catch(err => callback(err));
 }
 
 function removeAllVersions(params, callback) {
     const bucket = params.Bucket;
     async.waterfall([
-        cb => s3.listObjectVersions(params, cb),
+        cb => s3Client.send(new ListObjectVersionsCommand(params)).then(data =>
+            cb(null, data)).catch(err => cb(err)),
         (data, cb) => _deleteVersionList(data.DeleteMarkers, bucket,
             err => cb(err, data)),
         (data, cb) => _deleteVersionList(data.Versions, bucket,
@@ -60,25 +63,26 @@ function removeAllVersions(params, callback) {
 }
 
 function suspendVersioning(bucket, callback) {
-    s3.putBucketVersioning({
+    s3Client.send(new PutBucketVersioningCommand({
         Bucket: bucket,
         VersioningConfiguration: versioningSuspended,
-    }, callback);
+    })).then(() => callback()).catch(err => callback(err));
 }
 
 function enableVersioning(bucket, callback) {
-    s3.putBucketVersioning({
+    s3Client.send(new PutBucketVersioningCommand({
         Bucket: bucket,
         VersioningConfiguration: versioningEnabled,
-    }, callback);
+    })).then(() => callback()).catch(err => callback(err));
 }
 
 function enableVersioningThenPutObject(bucket, object, callback) {
     enableVersioning(bucket, err => {
         if (err) {
             callback(err);
         }
-        s3.putObject({ Bucket: bucket, Key: object }, callback);
+        s3Client.send(new PutObjectCommand({ Bucket: bucket, Key: object })).then(() => 
+            callback()).catch(err => callback(err));
     });
 }
 
@@ -102,33 +106,35 @@ function enableVersioningThenPutObject(bucket, object, callback) {
 function createDualNullVersion(s3, bucketName, keyName, cb) {
     async.waterfall([
         // put null version
-        next => s3.putObject({ Bucket: bucketName, Key: keyName },
-            err => next(err)),
+        next => s3Client.send(new PutObjectCommand({ Bucket: bucketName, Key: keyName, Body: null })).then(() => 
+            next()).catch(err => next(err)),
         next => enableVersioning(bucketName, err => next(err)),
         // should store null version as separate version before
         // putting new version
-        next => s3.putObject({ Bucket: bucketName, Key: keyName },
-            (err, data) => {
-                assert.strictEqual(err, null,
-                    'Unexpected err putting new version');
-                assert(data.VersionId);
-                next(null, data.VersionId);
-            }),
+        next => s3Client.send(new PutObjectCommand({ Bucket: bucketName, Key: keyName })).then(data => {
+            assert(data.VersionId);
+            next(null, data.VersionId);
+        }).catch(err => {
+            assert.strictEqual(err, null,
+                'Unexpected err putting new version');
+            next(err);
+        }),
         // delete version we just created, master version should be updated
         // with value of next most recent version: null version previously put
-        (versionId, next) => s3.deleteObject({
+        (versionId, next) => s3Client.send(new DeleteObjectCommand({
             Bucket: bucketName,
             Key: keyName,
             VersionId: versionId,
-        }, err => next(err)),
+        })).then(() => next()).catch(err => next(err)),
         // getting object should return null version now
-        next => s3.getObject({ Bucket: bucketName, Key: keyName },
-            (err, data) => {
-                assert.strictEqual(err, null,
-                    'Unexpected err getting latest version');
-                assert.strictEqual(data.VersionId, 'null');
-                next();
-            }),
+        next => s3Client.send(new GetObjectCommand({ Bucket: bucketName, Key: keyName })).then(data => {
+            assert.strictEqual(data.VersionId, 'null');
+            next();
+        }).catch(err => {
+            assert.strictEqual(err, null,
+                'Unexpected err getting latest version');
+            next(err);
+        }),
     ], err => cb(err));
 }
 

tests/functional/aws-node-sdk/test/multipleBackend/acl/aclAwsVersioning.js

@@ -1,5 +1,12 @@
 const assert = require('assert');
 const async = require('async');
+const {
+    CreateBucketCommand,
+    PutObjectCommand,
+    GetObjectAclCommand,
+    PutObjectAclCommand,
+} = require('@aws-sdk/client-s3');
+
 const withV4 = require('../../support/withV4');
 const BucketUtility = require('../../../lib/utility/bucket-util');
 const constants = require('../../../../../../constants');
@@ -56,27 +63,47 @@ const testAcp = new _AccessControlPolicy(ownerParams);
 testAcp.addGrantee('Group', constants.publicId, 'READ');
 
 function putObjectAcl(s3, key, versionId, acp, cb) {
-    s3.putObjectAcl({ Bucket: bucket, Key: key, AccessControlPolicy: acp,
-        VersionId: versionId }, err => {
-        assert.strictEqual(err, null, 'Expected success ' +
-            `putting object acl, got error ${err}`);
-        cb();
-    });
+    const params = {
+        Bucket: bucket,
+        Key: key,
+        AccessControlPolicy: acp,
+    };
+    if (versionId) {
+        params.VersionId = versionId;
+    }
+
+    const command = new PutObjectAclCommand(params);
+    s3.send(command)
+        .then(() => {
+            cb();
+        })
+        .catch(err => {
+            assert.strictEqual(err, null, 'Expected success ' +
+                `putting object acl, got error ${err}`);
+        });
 }
 
 function putObjectAndAcl(s3, key, body, acp, cb) {
-    s3.putObject({ Bucket: bucket, Key: key, Body: body },
-    (err, putData) => {
-        assert.strictEqual(err, null, 'Expected success ' +
-            `putting object, got error ${err}`);
-        putObjectAcl(s3, key, putData.VersionId, acp, () =>
-            cb(null, putData.VersionId));
+    const command = new PutObjectCommand({
+        Bucket: bucket,
+        Key: key,
+        Body: body,
     });
+
+    s3.send(command)
+        .then(putData => {
+            putObjectAcl(s3, key, putData.VersionId, acp, () =>
+                cb(null, putData.VersionId));
+        })
+        .catch(err => {
+            assert.strictEqual(err, null, 'Expected success ' +
+                `putting object, got error ${err}`);
+        });
 }
 
 /** putVersionsWithAclToAws - enable versioning and put multiple versions
  * followed by putting object acl
- * @param {AWS.S3} s3 - aws node sdk s3 instance
+ * @param {S3Client} s3 - aws sdk v3 s3 client instance
  * @param {string} key - string
  * @param {(string[]|Buffer[])} data - array of data to put as objects
  * @param {_AccessControlPolicy[]} acps - array of _AccessControlPolicy instance
@@ -103,19 +130,30 @@ function getObjectAndAssertAcl(s3, params, cb) {
         = params;
     getAndAssertResult(s3, { bucket, key, versionId, expectedVersionId, body },
         () => {
-            s3.getObjectAcl({ Bucket: bucket, Key: key, VersionId: versionId },
-                (err, data) => {
-                    assert.strictEqual(err, null, 'Expected success ' +
-                        `getting object acl, got error ${err}`);
+            const aclParams = {
+                Bucket: bucket,
+                Key: key,
+            };
+            if (versionId) {
+                aclParams.VersionId = versionId;
+            }
+
+            const command = new GetObjectAclCommand(aclParams);
+            s3.send(command)
+                .then(data => {
                     assert.deepEqual(data, expectedResult);
                     cb();
+                })
+                .catch(err => {
+                    assert.strictEqual(err, null, 'Expected success ' +
+                        `getting object acl, got error ${err}`);
                 });
         });
 }
 
 /** getObjectsAndAssertAcls - enable versioning and put multiple versions
  * followed by putting object acl
- * @param {AWS.S3} s3 - aws node sdk s3 instance
+ * @param {S3Client} s3 - aws sdk v3 s3 client instance
  * @param {string} key - string
  * @param {string[]} versionIds - array of versionIds to use to get objs & acl
  * @param {(string[]|Buffer[])} expectedData - array of data expected from gets
@@ -150,15 +188,19 @@ function testSuite() {
             process.stdout.write('Creating bucket');
             bucketUtil = new BucketUtility('default', sigCfg);
             s3 = bucketUtil.s3;
-            return s3.createBucket({ Bucket: bucket,
+
+            const command = new CreateBucketCommand({
+                Bucket: bucket,
                 CreateBucketConfiguration: {
                     LocationConstraint: awsLocation,
                 },
-            }).promise()
-            .catch(err => {
-                process.stdout.write(`Error creating bucket: ${err}\n`);
-                throw err;
             });
+
+            return s3.send(command)
+                .catch(err => {
+                    process.stdout.write(`Error creating bucket: ${err}\n`);
+                    throw err;
+                });
         });
 
         afterEach(() => {