add supportsVersioning unit tests

Author: alexanderchan-scality

tests/locationConfig/locationConfigLegacy.json

@@ -126,5 +126,27 @@
             "bucketMatch": true,
             "credentialsProfile": "google"
         }
+    },
+    "withversioning": {
+        "type": "aws_s3",
+        "legacyAwsBehavior": true,
+        "details": {
+            "awsEndpoint": "s3.amazonaws.com",
+            "bucketName": "multitester555",
+            "bucketMatch": true,
+            "credentialsProfile": "default",
+            "supportsVersioning": true
+        }
+    },
+    "withoutversioning": {
+        "type": "aws_s3",
+        "legacyAwsBehavior": true,
+        "details": {
+            "awsEndpoint": "s3.amazonaws.com",
+            "bucketName": "multitester555",
+            "bucketMatch": true,
+            "credentialsProfile": "default",
+            "supportsVersioning": false
+        }
     }
 }

tests/locationConfig/locationConfigTests.json

@@ -163,5 +163,27 @@
             "bucketMatch": false,
             "credentialsProfile": "google"
         }
+    },
+    "withversioning": {
+        "type": "aws_s3",
+        "legacyAwsBehavior": true,
+        "details": {
+            "awsEndpoint": "s3.amazonaws.com",
+            "bucketName": "multitester555",
+            "bucketMatch": true,
+            "credentialsProfile": "default",
+            "supportsVersioning": true
+        }
+    },
+    "withoutversioning": {
+        "type": "aws_s3",
+        "legacyAwsBehavior": true,
+        "details": {
+            "awsEndpoint": "s3.amazonaws.com",
+            "bucketName": "multitester555",
+            "bucketMatch": true,
+            "credentialsProfile": "default",
+            "supportsVersioning": false
+        }
     }
 }

tests/unit/DummyService.js

@@ -1,6 +1,18 @@
 const uuid = require('uuid/v4');
 
 class DummyService {
+    constructor(config = {}) {
+        this.versioning = config.versioning;
+    }
+    headBucket(params, callback) {
+        return callback();
+    }
+    getBucketVersioning(params, callback) {
+        if (this.versioning) {
+            return callback(null, { Status: 'Enabled' });
+        }
+        return callback(null, {});
+    }
     headObject(params, callback) {
         const retObj = {
             ContentLength: `${1024 * 1024 * 1024}`,
@@ -11,10 +23,37 @@ class DummyService {
         const retObj = {
             Bucket: params.Bucket,
             Key: params.Key,
-            VersionId: uuid().replace(/-/g, ''),
             ETag: `"${uuid().replace(/-/g, '')}"`,
             ContentLength: `${1024 * 1024 * 1024}`,
         };
+        if (this.versioning) {
+            retObj.VersionId = uuid().replace(/-/g, '');
+        }
+        return callback(null, retObj);
+    }
+    upload(params, callback) {
+        this.putObject(params, callback);
+    }
+    putObject(params, callback) {
+        const retObj = {
+            ETag: `"${uuid().replace(/-/g, '')}"`,
+        };
+        if (this.versioning) {
+            retObj.VersionId = uuid().replace(/-/g, '');
+        }
+        return callback(null, retObj);
+    }
+    copyObject(params, callback) {
+        const retObj = {
+            CopyObjectResult: {
+                ETag: `"${uuid().replace(/-/g, '')}"`,
+                LastModified: new Date().toISOString(),
+            },
+            VersionId: null,
+        };
+        if (this.versioning) {
+            retObj.VersionId = uuid().replace(/-/g, '');
+        }
         return callback(null, retObj);
     }
     // To-Do: add tests for other methods

tests/unit/api/bucketPutVersioning.js

@@ -0,0 +1,132 @@
+const assert = require('assert');
+
+const { errors } = require('arsenal');
+const { bucketPut } = require('../../../lib/api/bucketPut');
+const bucketPutVersioning = require('../../../lib/api/bucketPutVersioning');
+
+const { cleanup,
+    DummyRequestLogger,
+    makeAuthInfo } = require('../helpers');
+const metadata = require('../../../lib/metadata/wrapper');
+
+const xmlEnableVersioning =
+'<VersioningConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">' +
+'<Status>Enabled</Status>' +
+'</VersioningConfiguration>';
+
+const xmlSuspendVersioning =
+'<VersioningConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">' +
+'<Status>Suspended</Status>' +
+'</VersioningConfiguration>';
+
+const locConstraintVersioned =
+'<CreateBucketConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">' +
+'<LocationConstraint>withversioning</LocationConstraint>' +
+'</CreateBucketConfiguration>';
+
+const locConstraintNonVersioned =
+'<CreateBucketConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">' +
+'<LocationConstraint>withoutversioning</LocationConstraint>' +
+'</CreateBucketConfiguration>';
+
+const externalVersioningErrorMessage = 'We do not currently support putting ' +
+'a versioned object to a location-constraint of type Azure or GCP.';
+
+const log = new DummyRequestLogger();
+const bucketName = 'bucketname';
+const authInfo = makeAuthInfo('accessKey1');
+
+function _getPutBucketRequest(xml) {
+    const request = {
+        bucketName,
+        headers: { host: `${bucketName}.s3.amazonaws.com` },
+        url: '/',
+    };
+    request.post = xml;
+    return request;
+}
+
+function _putVersioningRequest(xml) {
+    const request = {
+        bucketName,
+        headers: { host: `${bucketName}.s3.amazonaws.com` },
+        url: '/?versioning',
+        query: { versioning: '' },
+    };
+    request.post = xml;
+    return request;
+}
+
+describe('bucketPutVersioning API', () => {
+    before(() => cleanup());
+    afterEach(() => cleanup());
+
+    describe('with version enabled location constraint', () => {
+        beforeEach(done => {
+            const request = _getPutBucketRequest(locConstraintVersioned);
+            bucketPut(authInfo, request, log, done);
+        });
+
+        const tests = [
+            {
+                msg: 'should successfully enable versioning on location ' +
+                'constraint with supportsVersioning set to true',
+                input: xmlEnableVersioning,
+                output: { Status: 'Enabled' },
+            },
+            {
+                msg: 'should successfully suspend versioning on location ' +
+                'constraint with supportsVersioning set to true',
+                input: xmlSuspendVersioning,
+                output: { Status: 'Suspended' },
+            },
+        ];
+        tests.forEach(test => it(test.msg, done => {
+            const request = _putVersioningRequest(test.input);
+            bucketPutVersioning(authInfo, request, log, err => {
+                assert.ifError(err,
+                    `Expected success, but got err: ${err}`);
+                metadata.getBucket(bucketName, log, (err, bucket) => {
+                    assert.ifError(err,
+                        `Expected success, but got err: ${err}`);
+                    assert.deepStrictEqual(bucket._versioningConfiguration,
+                        test.output);
+                    done();
+                });
+            });
+        }));
+    });
+
+    describe('with version disabled location constraint', () => {
+        beforeEach(done => {
+            const request = _getPutBucketRequest(locConstraintNonVersioned);
+            bucketPut(authInfo, request, log, done);
+        });
+
+        const tests = [
+            {
+                msg: 'should return error if enabling versioning on location ' +
+                'constraint with supportsVersioning set to false',
+                input: xmlEnableVersioning,
+                output: { error: errors.NotImplemented.customizeDescription(
+                    externalVersioningErrorMessage) },
+            },
+            {
+                msg: 'should return error if suspending versioning on ' +
+                ' location constraint with supportsVersioning set to false',
+                input: xmlSuspendVersioning,
+                output: { error: errors.NotImplemented.customizeDescription(
+                    externalVersioningErrorMessage) },
+            },
+        ];
+        tests.forEach(test => it(test.msg, done => {
+            const putBucketVersioningRequest =
+                _putVersioningRequest(test.input);
+            bucketPutVersioning(authInfo, putBucketVersioningRequest, log,
+            err => {
+                assert.deepStrictEqual(err, test.output.error);
+                done();
+            });
+        }));
+    });
+});

tests/unit/multipleBackend/ExternalBackendClient.js

@@ -1,4 +1,5 @@
 const assert = require('assert');
+
 const AwsClient = require('../../../lib/data/external/AwsClient');
 const GcpClient = require('../../../lib/data/external/GcpClient');
 const DummyService = require('../DummyService');
@@ -28,13 +29,14 @@ const backendClients = [
         },
     },
 ];
+const log = new DummyRequestLogger();
 
 backendClients.forEach(backend => {
     let testClient;
 
     before(() => {
         testClient = new backend.Class(backend.config);
-        testClient._client = new DummyService(backend.config);
+        testClient._client = new DummyService({ versioning: true });
     });
 
     describe(`${backend.name} completeMPU:`, () => {
@@ -58,8 +60,6 @@ backendClients.forEach(backend => {
             const key = 'externalBackendTestKey';
             const bucketName = 'externalBackendTestBucket';
             const uploadId = 'externalBackendTestUploadId';
-            const log = new DummyRequestLogger();
-
             testClient.completeMPU(jsonList, null, key, uploadId, bucketName,
             log, (err, res) => {
                 assert.strictEqual(typeof res.key, 'string');