object tests updates post unused functions removal

This commit removes unused functions and updates object tests accordingly.
These changes help reduce the dependency on gcpService only used functions in
cloudserver tests, and also enables us to remove wrappers around GCP SDK calls,
making the tests more straightforward and easier to maintain.
Issue: CLDSRV-826

Author: benzekrimaha

tests/functional/raw-node/test/GCP/object/completeMpu.js

@@ -1,26 +1,27 @@
 const assert = require('assert');
 const async = require('async');
 const arsenal = require('arsenal');
+const { ListObjectsCommand } = require('@aws-sdk/client-s3');
 const { GCP, GcpUtils } = arsenal.storage.data.external.GCP;
 const {
-    gcpRequestRetry,
-    gcpClientRetry,
-    setBucketClass,
     gcpMpuSetup,
     genUniqID,
+    gcpRetry,
 } = require('../../../utils/gcpUtils');
 const { getRealAwsConfig } =
     require('../../../../aws-node-sdk/test/support/awsConfig');
+const {
+    CreateBucketCommand,
+    DeleteBucketCommand,
+} = require('@aws-sdk/client-s3');
 
 const credentialOne = 'gcpbackend';
 const bucketNames = {
     main: {
         Name: `somebucket-${genUniqID()}`,
-        Type: 'MULTI_REGIONAL',
     },
     mpu: {
         Name: `mpubucket-${genUniqID()}`,
-        Type: 'MULTI_REGIONAL',
     },
 };
 const numParts = 1024;
@@ -49,29 +50,28 @@ function listObjectsPaginated(gcpClient, bucketName, cb) {
             params.Marker = marker;
         }
 
-        return gcpClientRetry(gcpClient.listObjects.bind(gcpClient), params, (err, res) => {
-            if (err) {
-                return cb(err);
-            }
-
-            const contents = (res && res.Contents) || [];
-            objects.push(...contents);
+        const command = new ListObjectsCommand(params);
+        return gcpClient.send(command)
+            .then(res => {
+                const contents = (res && res.Contents) || [];
+                objects.push(...contents);
 
-            const isTruncated = Boolean(res && res.IsTruncated);
-            if (!isTruncated) {
-                return cb(null, objects);
-            }
+                const isTruncated = Boolean(res && res.IsTruncated);
+                if (!isTruncated) {
+                    return cb(null, objects);
+                }
 
-            // AWS listObjects(V1) pagination: prefer NextMarker, fallback to last key.
-            marker = (res && res.NextMarker) ||
-                (contents.length ? contents[contents.length - 1].Key : undefined);
+                // AWS listObjects(V1) pagination: prefer NextMarker, fallback to last key.
+                marker = (res && res.NextMarker) ||
+                    (contents.length ? contents[contents.length - 1].Key : undefined);
 
-            if (!marker) {
-                return cb(null, objects);
-            }
+                if (!marker) {
+                    return cb(null, objects);
+                }
 
-            return _list();
-        });
+                return _list();
+            })
+            .catch(err => cb(err));
     }
 
     return _list();
@@ -87,7 +87,7 @@ function emptyBucket(gcpClient, bucketName, cb) {
                 Bucket: bucketName,
                 Key: object.Key,
             };
-            return gcpClientRetry(gcpClient.deleteObject.bind(gcpClient), deleteParams, next);
+            return gcpClient.deleteObject(deleteParams, next);
         }, cb);
     });
 }
@@ -100,39 +100,47 @@ describe('GCP: Complete MPU', function testSuite() {
     before(done => {
         config = getRealAwsConfig(credentialOne);
         gcpClient = new GCP(config);
-        async.eachSeries(bucketNames,
-            (bucket, next) => gcpRequestRetry({
-                method: 'PUT',
-                bucket: bucket.Name,
-                authCredentials: config.credentials,
-                requestBody: setBucketClass(bucket.Type),
-            }, 0, err => {
-                if (err) {
-                    process.stdout.write(`err in creating bucket ${err}\n`);
-                }
-                return next(err);
-            }),
-        done);
+        const buckets = Object.values(bucketNames);
+        async.eachSeries(
+            buckets,
+            (bucket, next) => gcpRetry(
+                gcpClient,
+                () => new CreateBucketCommand({ Bucket: bucket.Name }),
+                null,
+                err => {
+                    if (err) {
+                        process.stdout.write(
+                            `err in creating bucket ${err}\n`);
+                    }
+                    return next(err);
+                },
+            ),
+            done,
+        );
     });
 
     after(done => {
-        async.eachSeries(bucketNames,
+        const buckets = Object.values(bucketNames);
+        async.eachSeries(
+            buckets,
             (bucket, next) => emptyBucket(gcpClient, bucket.Name, err => {
                 assert.equal(err, null,
                     `Expected success, but got error ${err}`);
-                gcpRequestRetry({
-                    method: 'DELETE',
-                    bucket: bucket.Name,
-                    authCredentials: config.credentials,
-                }, 0, err => {
-                    if (err) {
-                        process.stdout.write(
-                            `err in deleting bucket ${err}\n`);
-                    }
-                    return next(err);
-                });
+                gcpRetry(
+                    gcpClient,
+                    () => new DeleteBucketCommand({ Bucket: bucket.Name }),
+                    null,
+                    error => {
+                        if (error) {
+                            process.stdout.write(
+                                `err in deleting bucket ${error}\n`);
+                        }
+                        return next(error);
+                    },
+                );
             }),
-        done);
+            done,
+        );
     });
 
     describe('when MPU has 0 parts', () => {

tests/functional/raw-node/test/GCP/object/copy.js

@@ -2,10 +2,14 @@ const assert = require('assert');
 const async = require('async');
 const arsenal = require('arsenal');
 const { GCP } = arsenal.storage.data.external.GCP;
-const { makeGcpRequest } = require('../../../utils/makeRequest');
-const { gcpRequestRetry, genUniqID } = require('../../../utils/gcpUtils');
+const { genUniqID, gcpRetry } = require('../../../utils/gcpUtils');
 const { getRealAwsConfig } =
     require('../../../../aws-node-sdk/test/support/awsConfig');
+const {
+    CreateBucketCommand,
+    DeleteBucketCommand,
+    PutObjectCommand,
+} = require('@aws-sdk/client-s3');
 
 const credentialOne = 'gcpbackend';
 const bucketName = `somebucket-${genUniqID()}`;
@@ -15,30 +19,25 @@ describe('GCP: COPY Object', function testSuite() {
     const config = getRealAwsConfig(credentialOne);
     const gcpClient = new GCP(config);
 
-    before(done => {
-        gcpRequestRetry({
-            method: 'PUT',
-            bucket: bucketName,
-            authCredentials: config.credentials,
-        }, 0, err => {
-            if (err) {
-                process.stdout.write(`err in creating bucket ${err}\n`);
-            }
-            return done(err);
-        });
+    before(async () => {
+        await gcpRetry(
+            gcpClient,
+            () => new CreateBucketCommand({ Bucket: bucketName }),
+        );
     });
 
     after(done => {
-        gcpRequestRetry({
-            method: 'DELETE',
-            bucket: bucketName,
-            authCredentials: config.credentials,
-        }, 0, err => {
-            if (err) {
-                process.stdout.write(`err in creating bucket ${err}\n`);
-            }
-            return done(err);
-        });
+        gcpRetry(
+            gcpClient,
+            () => new DeleteBucketCommand({ Bucket: bucketName }),
+            null,
+            err => {
+                if (err) {
+                    process.stdout.write(`err in deleting bucket ${err}\n`);
+                }
+                return done(err);
+            },
+        );
     });
 
     describe('without existing object in bucket', () => {
@@ -63,41 +62,38 @@ describe('GCP: COPY Object', function testSuite() {
             this.currentTest.key = `somekey-${genUniqID()}`;
             this.currentTest.copyKey = `copykey-${genUniqID()}`;
             this.currentTest.initValue = `${genUniqID()}`;
-            makeGcpRequest({
-                method: 'PUT',
-                bucket: bucketName,
-                objectKey: this.currentTest.copyKey,
-                headers: {
-                    'x-goog-meta-value': this.currentTest.initValue,
+            const cmd = new PutObjectCommand({
+                Bucket: bucketName,
+                Key: this.currentTest.copyKey,
+                Metadata: {
+                    value: this.currentTest.initValue,
                 },
-                authCredentials: config.credentials,
-            }, (err, res) => {
-                if (err) {
-                    process.stdout.write(`err in creating object ${err}\n`);
-                }
-                this.currentTest.contentHash = res.headers['x-goog-hash'];
-                return done(err);
             });
+            gcpClient.send(cmd)
+                .then(res => {
+                    this.currentTest.ETag = res.ETag;
+                    return done();
+                })
+                .catch(err => {
+                    process.stdout.write(`err in creating object ${err}\n`);
+                    return done(err);
+                });
         });
 
         afterEach(function afterFn(done) {
             async.parallel([
-                next => makeGcpRequest({
-                    method: 'DELETE',
-                    bucket: bucketName,
-                    objectKey: this.currentTest.key,
-                    authCredentials: config.credentials,
+                next => gcpClient.deleteObject({
+                    Bucket: bucketName,
+                    Key: this.currentTest.key,
                 }, err => {
                     if (err) {
                         process.stdout.write(`err in deleting object ${err}\n`);
                     }
                     return next(err);
                 }),
-                next => makeGcpRequest({
-                    method: 'DELETE',
-                    bucket: bucketName,
-                    objectKey: this.currentTest.copyKey,
-                    authCredentials: config.credentials,
+                next => gcpClient.deleteObject({
+                    Bucket: bucketName,
+                    Key: this.currentTest.copyKey,
                 }, err => {
                     if (err) {
                         process.stdout
@@ -125,20 +121,17 @@ describe('GCP: COPY Object', function testSuite() {
                         `Expected success, but got error ${err}`);
                     return next();
                 }),
-                next => makeGcpRequest({
-                    method: 'HEAD',
-                    bucket: bucketName,
-                    objectKey: this.test.key,
-                    authCredentials: config.credentials,
+                next => gcpClient.headObject({
+                    Bucket: bucketName,
+                    Key: this.test.key,
                 }, (err, res) => {
                     if (err) {
                         process.stdout
                             .write(`err in retrieving object ${err}\n`);
                         return next(err);
                     }
-                    assert.strictEqual(this.test.contentHash,
-                        res.headers['x-goog-hash']);
-                    assert.notStrictEqual(res.headers['x-goog-meta-value'],
+                    assert.strictEqual(res.ETag, this.test.ETag);
+                    assert.notStrictEqual(res.Metadata.value,
                         this.test.initValue);
                     return next();
                 }),
@@ -158,20 +151,17 @@ describe('GCP: COPY Object', function testSuite() {
                         `Expected success, but got error ${err}`);
                     return next();
                 }),
-                next => makeGcpRequest({
-                    method: 'HEAD',
-                    bucket: bucketName,
-                    objectKey: this.test.key,
-                    authCredentials: config.credentials,
+                next => gcpClient.headObject({
+                    Bucket: bucketName,
+                    Key: this.test.key,
                 }, (err, res) => {
                     if (err) {
                         process.stdout
                             .write(`err in retrieving object ${err}\n`);
                         return next(err);
                     }
-                    assert.strictEqual(this.test.contentHash,
-                        res.headers['x-goog-hash']);
-                    assert.strictEqual(res.headers['x-goog-meta-value'],
+                    assert.strictEqual(res.ETag, this.test.ETag);
+                    assert.strictEqual(res.Metadata.value,
                         this.test.initValue);
                     return next();
                 }),