Cloudserver adaptation post arsenal refacto

package.json

@@ -31,7 +31,7 @@
     "@azure/storage-blob": "^12.28.0",
     "@hapi/joi": "^17.1.1",
     "@smithy/node-http-handler": "^3.0.0",
-    "arsenal": "git+https://github.com/scality/Arsenal#8.3.0-preview.1",
+    "arsenal": "git+https://github.com/scality/Arsenal#aed443f02efebeb3f5c2e74786baadb5c19eaded",
     "async": "2.6.4",
     "bucketclient": "scality/bucketclient#8.2.7",
     "bufferutil": "^4.0.8",

tests/functional/raw-node/test/GCP/bucket/get.js

@@ -1,9 +1,15 @@
 const assert = require('assert');
 const async = require('async');
 const arsenal = require('arsenal');
+const {
+    ListObjectsCommand,
+    CreateBucketCommand,
+    DeleteBucketCommand,
+    PutObjectCommand,
+    DeleteObjectCommand,
+} = require('@aws-sdk/client-s3');
 const { GCP } = arsenal.storage.data.external.GCP;
-const { makeGcpRequest } = require('../../../utils/makeRequest');
-const { gcpRequestRetry, genUniqID } = require('../../../utils/gcpUtils');
+const { genUniqID } = require('../../../utils/gcpUtils');
 const { getRealAwsConfig } =
     require('../../../../aws-node-sdk/test/support/awsConfig');
 const { listingHardLimit } = require('../../../../../../constants');
@@ -15,75 +21,110 @@ const bigSize = listingHardLimit + 1;
 const config = getRealAwsConfig(credentialOne);
 const gcpClient = new GCP(config);
 
-function populateBucket(createdObjects, callback) {
-    process.stdout.write(
-        `Putting ${createdObjects.length} objects into bucket\n`);
-    async.mapLimit(createdObjects, 10,
-    (object, moveOn) => {
-        makeGcpRequest({
-            method: 'PUT',
-            bucket: bucketName,
-            objectKey: object,
-            authCredentials: config.credentials,
-        }, err => {
-            moveOn(err);
+gcpClient.listObjects = (params, callback) => {
+    const command = new ListObjectsCommand(params);
+    return gcpClient.send(command)
+        .then(data => callback(null, data))
+        .catch(err => {
+            if (err.statusCode === undefined) {
+                // eslint-disable-next-line no-param-reassign
+                err.statusCode = err.$metadata.httpStatusCode;
+            }
+            return callback(err);
         });
-    }, err => {
+};
+
+gcpClient.getBucket = (params, callback) =>
+    gcpClient.headBucket(params, (err, res) => {
         if (err) {
-            process.stdout
-                .write(`err putting objects ${err.code}\n`);
+            if (err.statusCode === undefined) {
+                // eslint-disable-next-line no-param-reassign
+                err.statusCode = err.$metadata.httpStatusCode;
+            }
+            if (err.$metadata && err.$metadata.httpStatusCode === 404) {
+                // eslint-disable-next-line no-param-reassign
+                err.name = 'NoSuchBucket';
+            }
+            return callback(err);
         }
-        return callback(err);
+        return callback(null, res);
     });
+
+function populateBucket(createdObjects, callback) {
+    process.stdout.write(
+        `Putting ${createdObjects.length} objects into bucket\n`);
+    async.mapLimit(
+        createdObjects,
+        10,
+        (object, moveOn) => {
+            const command = new PutObjectCommand({
+                Bucket: bucketName,
+                Key: object,
+            });
+            gcpClient.send(command)
+                .then(() => moveOn())
+                .catch(err => moveOn(err));
+        },
+        err => {
+            if (err) {
+                process.stdout
+                    .write(`err putting objects ${err}\n`);
+            }
+            return callback(err);
+        }
+    );
 }
 
 function removeObjects(createdObjects, callback) {
     process.stdout.write(
         `Deleting ${createdObjects.length} objects from bucket\n`);
-    async.mapLimit(createdObjects, 10,
-    (object, moveOn) => {
-        makeGcpRequest({
-            method: 'DELETE',
-            bucket: bucketName,
-            objectKey: object,
-            authCredentials: config.credentials,
-        }, err => moveOn(err));
-    }, err => {
-        if (err) {
-            process.stdout
-                .write(`err deleting objects ${err.code}\n`);
+    async.mapLimit(
+        createdObjects,
+        10,
+        (object, moveOn) => {
+            const command = new DeleteObjectCommand({
+                Bucket: bucketName,
+                Key: object,
+            });
+            gcpClient.send(command)
+                .then(() => moveOn())
+                .catch(err => moveOn(err));
+        },
+        err => {
+            if (err) {
+                process.stdout
+                    .write(`err deleting objects ${err}\n`);
+            }
+            return callback(err);
         }
-        return callback(err);
-    });
+    );
 }
 
 describe('GCP: GET Bucket', function testSuite() {
     this.timeout(180000);
 
     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);
+        const command = new CreateBucketCommand({
+            Bucket: bucketName,
         });
+        gcpClient.send(command)
+            .then(() => done())
+            .catch(err => {
+                process.stdout.write(`err in creating bucket ${err}\n`);
+                return done(err);
+            });
     });
 
     after(done => {
-        gcpRequestRetry({
-            method: 'DELETE',
-            bucket: bucketName,
-            authCredentials: config.credentials,
-        }, 0, err => {
-            if (err) {
-                process.stdout.write(`err in deleting bucket ${err}\n`);
-            }
-            return done(err);
+        const command = new DeleteBucketCommand({
+            Bucket: bucketName,
         });
+        gcpClient.send(command)
+            .then(() => done())
+            .catch(err => {
+                process.stdout.write(`err in deleting bucket ${err}\n`);
+                return done(err);
+            });
     });
 
     describe('without existing bucket', () => {

tests/functional/raw-node/test/GCP/bucket/getVersioning.js

@@ -1,106 +1,105 @@
 const assert = require('assert');
 const async = require('async');
 const arsenal = require('arsenal');
+const {
+    PutBucketVersioningCommand,
+    GetBucketVersioningCommand,
+    CreateBucketCommand,
+    DeleteBucketCommand,
+} = require('@aws-sdk/client-s3');
 const { GCP } = arsenal.storage.data.external.GCP;
-const { makeGcpRequest } = require('../../../utils/makeRequest');
-const { gcpRequestRetry, genUniqID } = require('../../../utils/gcpUtils');
+const { genUniqID } = require('../../../utils/gcpUtils');
 const { getRealAwsConfig } =
     require('../../../../aws-node-sdk/test/support/awsConfig');
 
 const credentialOne = 'gcpbackend';
 const verEnabledObj = 'Enabled';
 const verDisabledObj = 'Suspended';
-const xmlEnable =
-    '<?xml version="1.0" encoding="UTF-8"?>' +
-    '<VersioningConfiguration>' +
-    '<Status>Enabled</Status>' +
-    '</VersioningConfiguration>';
-const xmlDisable =
-    '<?xml version="1.0" encoding="UTF-8"?>' +
-    '<VersioningConfiguration>' +
-    '<Status>Suspended</Status>' +
-    '</VersioningConfiguration>';
 
 describe('GCP: GET Bucket Versioning', () => {
     const config = getRealAwsConfig(credentialOne);
     const gcpClient = new GCP(config);
 
     beforeEach(function beforeFn(done) {
         this.currentTest.bucketName = `somebucket-${genUniqID()}`;
-        gcpRequestRetry({
-            method: 'PUT',
-            bucket: this.currentTest.bucketName,
-            authCredentials: config.credentials,
-        }, 0, err => {
-            if (err) {
-                process.stdout.write(`err in creating bucket ${err.code}\n`);
-            }
-            return done(err);
+        const cmd = new CreateBucketCommand({
+            Bucket: this.currentTest.bucketName,
         });
+        gcpClient.send(cmd)
+            .then(() => done())
+            .catch(err => {
+                process.stdout
+                    .write(`err in creating bucket ${err.code}\n`);
+                return done(err);
+            });
     });
 
     afterEach(function afterFn(done) {
-        gcpRequestRetry({
-            method: 'DELETE',
-            bucket: this.currentTest.bucketName,
-            authCredentials: config.credentials,
-        }, 0, err => {
-            if (err) {
-                process.stdout.write(`err in deleting bucket ${err.code}\n`);
-            }
-            return done(err);
+        const cmd = new DeleteBucketCommand({
+            Bucket: this.currentTest.bucketName,
         });
+        gcpClient.send(cmd)
+            .then(() => done())
+            .catch(err => {
+                if (err) {
+                    process.stdout
+                        .write(`err in deleting bucket ${err.code}\n`);
+                }
+                return done(err);
+            });
     });
 
     it('should verify bucket versioning is enabled', function testFn(done) {
         return async.waterfall([
-            next => makeGcpRequest({
-                method: 'PUT',
-                bucket: this.test.bucketName,
-                authCredentials: config.credentials,
-                queryObj: { versioning: '' },
-                requestBody: xmlEnable,
-            }, err => {
-                if (err) {
-                    process.stdout.write(`err in setting versioning ${err.code}`);
-                }
-                return next(err);
-            }),
+            // Enable versioning using the official SDK client
             next => {
-                gcpClient.getBucketVersioning({
+                const command = new PutBucketVersioningCommand({
                     Bucket: this.test.bucketName,
-                }, (err, res) => {
-                    assert.equal(err, null,
-                        `Expected success, but got err ${err}`);
-                    assert.deepStrictEqual(res.Status, verEnabledObj);
-                    return next();
+                    VersioningConfiguration: { Status: 'Enabled' },
                 });
+                return gcpClient.send(command)
+                    .then(() => next())
+                    .catch(err => next(err));
+            },
+            // Verify using GetBucketVersioningCommand
+            next => {
+                const command = new GetBucketVersioningCommand({
+                    Bucket: this.test.bucketName,
+                });
+                return gcpClient.send(command)
+                    .then(res => {
+                        assert.deepStrictEqual(res.Status, verEnabledObj);
+                        return next();
+                    })
+                    .catch(err => next(err));
             },
         ], err => done(err));
     });
 
     it('should verify bucket versioning is disabled', function testFn(done) {
         return async.waterfall([
-            next => makeGcpRequest({
-                method: 'PUT',
-                bucket: this.test.bucketName,
-                authCredentials: config.credentials,
-                queryObj: { versioning: '' },
-                requestBody: xmlDisable,
-            }, err => {
-                if (err) {
-                    process.stdout.write(`err in setting versioning ${err}`);
-                }
-                return next(err);
-            }),
-            next => gcpClient.getBucketVersioning({
-                Bucket: this.test.bucketName,
-            }, (err, res) => {
-                assert.equal(err, null,
-                    `Expected success, but got err ${err}`);
-                assert.deepStrictEqual(res.Status, verDisabledObj);
-                return next();
-            }),
+            // Disable versioning using the official SDK client
+            next => {
+                const command = new PutBucketVersioningCommand({
+                    Bucket: this.test.bucketName,
+                    VersioningConfiguration: { Status: 'Suspended' },
+                });
+                return gcpClient.send(command)
+                    .then(() => next())
+                    .catch(err => next(err));
+            },
+            // Verify using GetBucketVersioningCommand
+            next => {
+                const command = new GetBucketVersioningCommand({
+                    Bucket: this.test.bucketName,
+                });
+                return gcpClient.send(command)
+                    .then(res => {
+                        assert.deepStrictEqual(res.Status, verDisabledObj);
+                        return next();
+                    })
+                    .catch(err => next(err));
+            },
         ], err => done(err));
     });
 });