Merge pull request #8927 from shirady/nc-get-bucket-encryption

NC | NSFS | Fix the `get_bucket_encryption` to Return Object

Author: shirady

docs/dev_guide/run_coretest_locally.md

@@ -58,6 +58,13 @@ Another option, which is less recommended, is to connect to postgres container a
 Notes:
 * For running `psql` commands you would need to install it on your machine (better with the matching version of postgres).
 * In case you already run postgres on your machine (not the mentioned container) it might raise some issues, better remove it (in MacOs using the Activity Monitor and search for postgres).
+Example: you stopped the docker run, and you tried to connect to postgres, but got an error (probably password authentication failed). As it expected to see the following message when we don't have a postgres container:
+
+```
+psql: error: connection to server at "127.0.0.1", port 5432 failed: Connection refused
+	Is the server running on that host and accepting TCP/IP connections?
+```
+
 * In case a test failed with "error: database "coretest" already exists" it means that you probably forgot to drop the DB table, and you can stop (ctrl + c) and rerun the `docker run` command mentioned above and then run the test again.
 * If you want to run the test with higher debug level you can add the `NOOBAA_LOG_LEVEL=all`, for example: `NOOBAA_LOG_LEVEL=all ./node_modules/mocha/bin/mocha.js src/test/unit_tests/test_s3_bucket_policy.js` (notice that you can printings that are not only from `LOG`, `L0`, `WARN` and `ERROR`, for example: `L1`, `L2`, `L3`, etc.)
 

src/sdk/bucketspace_fs.js

@@ -594,7 +594,7 @@ class BucketSpaceFS extends BucketSpaceSimpleFS {
             const { name } = params;
             dbg.log0('BucketSpaceFS.get_bucket_encryption: Bucket name', name);
             const bucket = await this.config_fs.get_bucket_by_name(name);
-            return bucket.encryption;
+            return { encryption: bucket.encryption };
         } catch (err) {
             throw translate_error_codes(err, entity_enum.BUCKET);
         }

src/test/unit_tests/test_bucketspace_fs.js

@@ -722,6 +722,11 @@ mocha.describe('bucketspace_fs', function() {
     });
 
     mocha.describe('bucket encryption operations', function() {
+        mocha.it('get_bucket_encryption (return empty encryption)', async function() {
+            const param = { name: test_bucket };
+            const empty_encryption = await bucketspace_fs.get_bucket_encryption(param);
+            assert.ok(empty_encryption.encryption === undefined);
+        });
         mocha.it('put_bucket_encryption ', async function() {
             const encryption = {
                 algorithm: 'AES256',
@@ -731,19 +736,19 @@ mocha.describe('bucketspace_fs', function() {
             await bucketspace_fs.put_bucket_encryption(param);
 
             const output_encryption = await bucketspace_fs.get_bucket_encryption(param);
-            assert.deepEqual(output_encryption, encryption);
+            assert.deepEqual(output_encryption.encryption, encryption);
         });
-        mocha.it('delete_bucket_encryption ', async function() {
+        mocha.it('delete_bucket_encryption', async function() {
             const encryption = {
                 algorithm: 'AES256',
                 kms_key_id: 'kms-123'
             };
             const param = { name: test_bucket };
             const output_encryption = await bucketspace_fs.get_bucket_encryption(param);
-            assert.deepEqual(output_encryption, encryption);
+            assert.deepEqual(output_encryption.encryption, encryption);
             await bucketspace_fs.delete_bucket_encryption(param);
             const empty_encryption = await bucketspace_fs.get_bucket_encryption(param);
-            assert.ok(empty_encryption === undefined);
+            assert.ok(empty_encryption.encryption === undefined);
         });
     });
 

src/test/unit_tests/test_nsfs_integration.js

@@ -795,6 +795,14 @@ mocha.describe('bucket operations - namespace_fs', function() {
         const expected_payer = 'BucketOwner'; // this is the mock that we use
         assert.equal(res.Payer, expected_payer);
     });
+    mocha.it('get bucket encryption (before put bucket encryption) - throws an error', async function() {
+        try {
+            await s3_correct_uid_default_nsr.getBucketEncryption({ Bucket: bucket_name});
+            assert.fail('get bucket encryption when encryption not set should fail');
+        } catch (err) {
+            assert.strictEqual(err.Code, 'ServerSideEncryptionConfigurationNotFoundError');
+        }
+    });
 
     mocha.it('delete multiple non existing objects without failing', async function() {
         const keys_to_delete = [

src/test/unit_tests/test_s3_ops.js

@@ -116,6 +116,22 @@ mocha.describe('s3_ops', function() {
             const expected_payer = 'BucketOwner'; // this is the mock that we use
             assert.equal(res.Payer, expected_payer);
         });
+        mocha.it('should allow get_bucket_encryption (no put before the get)', async function() {
+            const res = await s3.getBucketEncryption({ Bucket: BKT1 });
+            const expected_response = {
+                ServerSideEncryptionConfiguration: {
+                    Rules: [{
+                        ApplyServerSideEncryptionByDefault: {
+                            SSEAlgorithm: 'AES256'
+                        },
+                        BucketKeyEnabled: false
+                    }]
+                }
+            };
+            assert.equal(res.$metadata.httpStatusCode, 200);
+            const res_without_metadata = _.omit(res, '$metadata');
+            assert.deepEqual(res_without_metadata, expected_response);
+        });
         mocha.it('should enable bucket logging', async function() {
             await s3.createBucket({ Bucket: BKT2 });
             await s3.putBucketLogging({