tests utilities migration

Issue: CLDSRV-724

Author: benzekrimaha

tests/functional/aws-node-sdk/lib/utility/checkError.js

@@ -2,8 +2,12 @@ const assert = require('assert');
 
 function checkError(err, code, statusCode) {
     assert(err, 'Expected error but found none');
-    assert.strictEqual(err.code, code);
-    assert.strictEqual(err.statusCode, statusCode);
+    if (code) {
+        assert.strictEqual(err.name, code);
+    }
+    if (statusCode) {
+        assert.strictEqual(err.$metadata.httpStatusCode, statusCode);
+    }
 }
 
 module.exports = checkError;

tests/functional/aws-node-sdk/lib/utility/tagging.js

@@ -5,9 +5,11 @@ const taggingTests = [
         it: 'should return tags if value is an empty string' },
     { tag: { key: 'w'.repeat(129), value: 'foo' },
         error: 'InvalidTag',
+        code: 400,
         it: 'should return InvalidTag if key length is greater than 128' },
     { tag: { key: 'bar', value: 'f'.repeat(257) },
         error: 'InvalidTag',
+        code: 400,
         it: 'should return InvalidTag if key length is greater than 256',
     },
 ];

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

@@ -3,6 +3,11 @@ const async = require('async');
 const fs = require('fs');
 const path = require('path');
 const url = require('url');
+const { CreateBucketCommand,
+    DeleteBucketCommand, 
+    PutBucketWebsiteCommand,
+    DeleteObjectCommand, 
+    PutObjectCommand } = require('@aws-sdk/client-s3');
 
 const { makeRequest } = require('../../../raw-node/utils/makeRequest');
 
@@ -352,41 +357,31 @@ class WebsiteConfigTester {
     }
 
     static createPutBucketWebsite(s3, bucket, bucketACL, objects, done) {
-        s3.createBucket({ Bucket: bucket, ACL: bucketACL },
-        err => {
-            if (err) {
-                return done(err);
-            }
+        s3.send(new CreateBucketCommand({ Bucket: bucket, ACL: bucketACL })).then(() => { 
             const webConfig = new WebsiteConfigTester('index.html',
               'error.html');
-            return s3.putBucketWebsite({ Bucket: bucket,
-                WebsiteConfiguration: webConfig }, err => {
-                if (err) {
-                    return done(err);
-                }
-                return async.forEachOf(objects,
+            return s3.send(new PutBucketWebsiteCommand({ Bucket: bucket,
+                WebsiteConfiguration: webConfig })).then(() => async.forEachOf(objects,
                 (acl, object, next) => {
-                    s3.putObject({ Bucket: bucket,
+                    s3.send(new PutObjectCommand({ Bucket: bucket,
                         Key: `${object}.html`,
                         ACL: acl,
                         Body: fs.readFileSync(path.join(__dirname,
                             `/../../test/object/websiteFiles/${object}.html`)),
-                    },
-                        next);
-                }, done);
-            });
-        });
+                    })).then(() => next()).catch(next);
+                }, done));
+        }).catch(err => done(err));
     }
 
     static deleteObjectsThenBucket(s3, bucket, objects, done) {
         async.forEachOf(objects, (acl, object, next) => {
-            s3.deleteObject({ Bucket: bucket,
-                Key: `${object}.html` }, next);
+            s3.send(new DeleteObjectCommand({ Bucket: bucket,
+                Key: `${object}.html` })).then(() => next()).catch(next);
         }, err => {
             if (err) {
                 return done(err);
             }
-            return s3.deleteBucket({ Bucket: bucket }, done);
+            return s3.send(new DeleteBucketCommand({ Bucket: bucket })).then(() => done()).catch(done);
         });
     }
 }

tests/utilities/bucketTagging-util.js

@@ -5,11 +5,11 @@ 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.Code, 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  ' +
-            `${errors[expectedErr].code}, but got '${err.statusCode}'`);
+            `${errors[expectedErr].code}, but got '${err.$metadata.httpStatusCode}'`);
     }
 }