Skip to content

Commit 104ff7a

Browse files
BourgoisMickaelBourgoisMickael
committed
Merge remote-tracking branch 'origin/improvement/CLDSRV-670-test-linting' into w/8.8/improvement/CLDSRV-670-test-linting
2 parents 236fb84 + 14a7779 commit 104ff7a

File tree

4 files changed

+143
-138
lines changed

4 files changed

+143
-138
lines changed

‎tests/functional/sse-kms-migration/arnPrefix.js‎

Lines changed: 63 additions & 61 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
1-
/* eslint-disable */
1+
/* eslint-disable no-console */
2+
/* eslint-disable no-unused-expressions */
23
const { promisify } = require('util');
34
const { DummyRequestLogger } = require('../../unit/helpers');
45
const assert = require('assert');
@@ -34,28 +35,28 @@ describe('SSE KMS arnPrefix', () => {
3435
? bkt.kmsKeyInfo.masterKeyArn
3536
: bkt.kmsKeyInfo.masterKeyId;
3637
}
37-
void await helpers.s3.createBucket(({ Bucket: bkt.name })).promise();
38-
void await helpers.s3.createBucket(({ Bucket: bkt.vname })).promise();
38+
await helpers.s3.createBucket(({ Bucket: bkt.name })).promise();
39+
await helpers.s3.createBucket(({ Bucket: bkt.vname })).promise();
3940
if (bktConf.deleteSSE) {
4041
await scenarios.deleteBucketSSEBeforeEach(bkt.name, log);
4142
await scenarios.deleteBucketSSEBeforeEach(bkt.vname, log);
4243
}
4344
if (bktConf.algo) {
4445
// bucket encryption will be asserted in bucket test
45-
void await helpers.s3.putBucketEncryption({
46+
await helpers.s3.putBucketEncryption({
4647
Bucket: bkt.name,
4748
ServerSideEncryptionConfiguration: helpers.hydrateSSEConfig({
4849
algo: bktConf.algo, masterKeyId: bkt.kmsKey }),
4950
}).promise();
50-
void await helpers.s3.putBucketEncryption({
51+
await helpers.s3.putBucketEncryption({
5152
Bucket: bkt.vname,
5253
ServerSideEncryptionConfiguration: helpers.hydrateSSEConfig({
5354
algo: bktConf.algo, masterKeyId: bkt.kmsKey }),
5455
}).promise();
5556
}
5657

5758
// Put an object for each SSE conf in each bucket
58-
void await Promise.all(scenarios.testCases.map(async objConf => {
59+
await Promise.all(scenarios.testCases.map(async objConf => {
5960
const obj = {
6061
name: `for-copy-enc-obj-${objConf.name}`,
6162
kmsKeyInfo: null,
@@ -70,7 +71,7 @@ describe('SSE KMS arnPrefix', () => {
7071
: obj.kmsKeyInfo.masterKeyId;
7172
}
7273

73-
await helpers.putEncryptedObject(bkt.name, obj.name, objConf, obj.kmsKey, obj.body);
74+
return await helpers.putEncryptedObject(bkt.name, obj.name, objConf, obj.kmsKey, obj.body);
7475
}));
7576
};
7677

@@ -79,37 +80,37 @@ describe('SSE KMS arnPrefix', () => {
7980
{ profile: helpers.credsProfile, accessKeyId: helpers.s3.config.credentials.accessKeyId });
8081
const allBuckets = (await helpers.s3.listBuckets().promise()).Buckets.map(b => b.Name);
8182
console.log('List buckets:', allBuckets);
82-
void await helpers.MD.setup();
83+
await helpers.MD.setup();
8384
copyKmsKey = (await helpers.createKmsKey(log)).masterKeyArn;
8485
try {
8586
// pre cleanup
86-
void await cleanup(copyBkt);
87-
void await cleanup(mpuCopyBkt);
88-
void await Promise.all(Object.values(bkts).map(async bkt => {
89-
void await cleanup(bkt.name);
90-
return await cleanup(bkt.vname);
87+
await helpers.cleanup(copyBkt);
88+
await helpers.cleanup(mpuCopyBkt);
89+
await Promise.all(Object.values(bkts).map(async bkt => {
90+
await helpers.cleanup(bkt.name);
91+
return await helpers.cleanup(bkt.vname);
9192
}));
9293
} catch (e) { void e; }
9394

9495
// init copy bucket
95-
void await helpers.s3.createBucket(({ Bucket: copyBkt })).promise();
96-
void await helpers.s3.createBucket(({ Bucket: mpuCopyBkt })).promise();
97-
void await helpers.s3.putBucketEncryption({
96+
await helpers.s3.createBucket(({ Bucket: copyBkt })).promise();
97+
await helpers.s3.createBucket(({ Bucket: mpuCopyBkt })).promise();
98+
await helpers.s3.putBucketEncryption({
9899
Bucket: copyBkt,
99100
ServerSideEncryptionConfiguration: helpers.hydrateSSEConfig({ algo: 'aws:kms', masterKeyId: copyKmsKey }),
100101
}).promise();
101-
void await helpers.s3.putObject({ Bucket: copyBkt, Key: copyObj, Body: 'BODY(copy)' }).promise();
102+
await helpers.s3.putObject({ Bucket: copyBkt, Key: copyObj, Body: 'BODY(copy)' }).promise();
102103

103104
// Prepare every buckets with 1 object (for copy)
104-
void await Promise.all(scenarios.testCases.map(async bktConf => this.initBucket(bktConf)));
105+
await Promise.all(scenarios.testCases.map(async bktConf => this.initBucket(bktConf)));
105106
});
106107

107108
after(async () => {
108-
void await helpers.cleanup(copyBkt);
109-
void await helpers.cleanup(mpuCopyBkt);
109+
await helpers.cleanup(copyBkt);
110+
await helpers.cleanup(mpuCopyBkt);
110111
// Clean every bucket
111-
void await Promise.all(Object.values(bkts).map(async bkt => {
112-
void await helpers.cleanup(bkt.name);
112+
await Promise.all(Object.values(bkts).map(async bkt => {
113+
await helpers.cleanup(bkt.name);
113114
return await helpers.cleanup(bkt.vname);
114115
}));
115116
});
@@ -177,11 +178,11 @@ describe('SSE KMS arnPrefix', () => {
177178
[
178179
{ name: `${obj.name} into encrypted destination bucket`, forceBktSSE: true },
179180
{ name: `${obj.name} into same bucket with object SSE config` },
180-
{ name: `from encrypted source into ${obj.name} with object SSE config` }
181+
{ name: `from encrypted source into ${obj.name} with object SSE config` },
181182
].forEach(({ name, forceBktSSE }, index) =>
182-
it(`should CopyObject ${name}`, async () =>
183+
it(`should CopyObject ${name}`, async () =>
183184
await scenarios.tests.copyObjectAndSSE(
184-
{ copyBkt, objForCopy, copyObj},
185+
{ copyBkt, objForCopy, copyObj },
185186
{ objConf, obj },
186187
{ bktConf, bkt },
187188
{ index, forceBktSSE },
@@ -205,7 +206,7 @@ describe('SSE KMS arnPrefix', () => {
205206
}, mpu, objConf.algo || bktConf.algo, 'after');
206207
newParts.push(part);
207208
}
208-
void await scenarios.tests.mpuComplete(
209+
await scenarios.tests.mpuComplete(
209210
{ UploadId: mpu.UploadId, Bucket: bkt.name, Key: mpuKey },
210211
{ existingParts: [], newParts },
211212
mpu, objConf.algo || bktConf.algo, 'after');
@@ -214,7 +215,7 @@ describe('SSE KMS arnPrefix', () => {
214215
Key: mpuKey,
215216
Body: `${obj.body}-MPU1${obj.body}-MPU2`,
216217
};
217-
void await scenarios.assertObjectSSE(assertion, { objConf, obj }, { bktConf, bkt }, {}, 'after');
218+
await scenarios.assertObjectSSE(assertion, { objConf, obj }, { bktConf, bkt }, {}, 'after');
218219
});
219220

220221
it('should encrypt MPU and copy an encrypted parts from encrypted bucket', async () => {
@@ -236,7 +237,7 @@ describe('SSE KMS arnPrefix', () => {
236237
PartNumber: 2,
237238
}, mpu, objConf.algo || bktConf.algo, 'after');
238239

239-
void await scenarios.tests.mpuComplete(
240+
await scenarios.tests.mpuComplete(
240241
{ UploadId: mpu.UploadId, Bucket: bkt.name, Key: mpuKey },
241242
{ existingParts: [], newParts: [part1, part2] },
242243
mpu, objConf.algo || bktConf.algo, 'after');
@@ -245,7 +246,7 @@ describe('SSE KMS arnPrefix', () => {
245246
Key: mpuKey,
246247
Body: `BODY(copy)${obj.body}-MPU2`,
247248
};
248-
void await scenarios.assertObjectSSE(assertion, { objConf, obj }, { bktConf, bkt }, {}, 'after');
249+
await scenarios.assertObjectSSE(assertion, { objConf, obj }, { bktConf, bkt }, {}, 'after');
249250
});
250251

251252
it('should encrypt MPU and copy an encrypted range parts from encrypted bucket', async () => {
@@ -268,7 +269,7 @@ describe('SSE KMS arnPrefix', () => {
268269
newParts.push(part);
269270
}
270271

271-
void await scenarios.tests.mpuComplete(
272+
await scenarios.tests.mpuComplete(
272273
{ UploadId: mpu.UploadId, Bucket: bkt.name, Key: mpuKey },
273274
{ existingParts: [], newParts },
274275
mpu, objConf.algo || bktConf.algo, 'after');
@@ -277,26 +278,26 @@ describe('SSE KMS arnPrefix', () => {
277278
Key: mpuKey,
278279
Body: 'copyBODY',
279280
};
280-
void await scenarios.assertObjectSSE(assertion, { objConf, obj }, { bktConf, bkt }, {}, 'after');
281+
await scenarios.assertObjectSSE(assertion, { objConf, obj }, { bktConf, bkt }, {}, 'after');
281282
});
282283

283284
it(`should PutObject versioned with SSE ${obj.name}`, async () => {
284285
// ensure versioned bucket is empty
285-
void await helpers.bucketUtil.empty(bkt.vname);
286+
await helpers.bucketUtil.empty(bkt.vname);
286287
let { Versions } = await helpers.s3.listObjectVersions({ Bucket: bkt.vname }).promise();
287288
// regularly count versioned objects
288289
assert.strictEqual(Versions.length, 0);
289290

290291
const bodyBase = `BODY(${obj.name})-base`;
291-
void await helpers.putEncryptedObject(bkt.vname, obj.name, objConf, obj.kmsKey, bodyBase);
292+
await helpers.putEncryptedObject(bkt.vname, obj.name, objConf, obj.kmsKey, bodyBase);
292293
const baseAssertion = { Bucket: bkt.vname, Key: obj.name };
293-
void await scenarios.assertObjectSSE(
294+
await scenarios.assertObjectSSE(
294295
{ ...baseAssertion, Body: bodyBase },
295296
{ objConf, obj }, { bktConf, bkt }, {}, 'after');
296297
({ Versions } = await helpers.s3.listObjectVersions({ Bucket: bkt.vname }).promise());
297298
assert.strictEqual(Versions.length, 1);
298299

299-
void await helpers.s3.putBucketVersioning({ Bucket: bkt.vname,
300+
await helpers.s3.putBucketVersioning({ Bucket: bkt.vname,
300301
VersioningConfiguration: { Status: 'Enabled' },
301302
}).promise();
302303

@@ -312,48 +313,48 @@ describe('SSE KMS arnPrefix', () => {
312313
({ Versions } = await helpers.s3.listObjectVersions({ Bucket: bkt.vname }).promise());
313314
assert.strictEqual(Versions.length, 3);
314315

315-
void await scenarios.assertObjectSSE(
316+
await scenarios.assertObjectSSE(
316317
{ ...baseAssertion, Body: bodyV2 }, { objConf, obj }, { bktConf, bkt },
317318
{}, 'after'); // v2
318-
void await scenarios.assertObjectSSE(
319+
await scenarios.assertObjectSSE(
319320
{ ...baseAssertion, VersionId: 'null', Body: bodyBase }, { objConf, obj }, { bktConf, bkt },
320321
{}, 'after');
321-
void await scenarios.assertObjectSSE(
322+
await scenarios.assertObjectSSE(
322323
{ ...baseAssertion, VersionId: v1.VersionId, Body: bodyV1 }, { objConf, obj }, { bktConf, bkt },
323324
{}, 'after');
324-
void await scenarios.assertObjectSSE(
325+
await scenarios.assertObjectSSE(
325326
{ ...baseAssertion, VersionId: v2.VersionId, Body: bodyV2 }, { objConf, obj }, { bktConf, bkt },
326327
{}, 'after');
327328
({ Versions } = await helpers.s3.listObjectVersions({ Bucket: bkt.vname }).promise());
328329
assert.strictEqual(Versions.length, 3);
329330

330-
void await helpers.s3.putBucketVersioning({ Bucket: bkt.vname,
331+
await helpers.s3.putBucketVersioning({ Bucket: bkt.vname,
331332
VersioningConfiguration: { Status: 'Suspended' },
332333
}).promise();
333334

334335
// should be fine after version suspension
335-
void await scenarios.assertObjectSSE(
336+
await scenarios.assertObjectSSE(
336337
{ ...baseAssertion, Body: bodyV2 }, { objConf, obj }, { bktConf, bkt },
337338
{}, 'after'); // v2
338-
void await scenarios.assertObjectSSE(
339+
await scenarios.assertObjectSSE(
339340
{ ...baseAssertion, VersionId: 'null', Body: bodyBase }, { objConf, obj }, { bktConf, bkt },
340341
{}, 'after');
341-
void await scenarios.assertObjectSSE(
342+
await scenarios.assertObjectSSE(
342343
{ ...baseAssertion, VersionId: v1.VersionId, Body: bodyV1 }, { objConf, obj }, { bktConf, bkt },
343344
{}, 'after');
344-
void await scenarios.assertObjectSSE(
345+
await scenarios.assertObjectSSE(
345346
{ ...baseAssertion, VersionId: v2.VersionId, Body: bodyV2 }, { objConf, obj }, { bktConf, bkt },
346347
{}, 'after');
347348
({ Versions } = await helpers.s3.listObjectVersions({ Bucket: bkt.vname }).promise());
348349
assert.strictEqual(Versions.length, 3);
349350

350351
// put a new null version
351352
const bodyFinal = `BODY(${obj.name})-final`;
352-
void await helpers.putEncryptedObject(bkt.vname, obj.name, objConf, obj.kmsKey, bodyFinal);
353-
void await scenarios.assertObjectSSE(
353+
await helpers.putEncryptedObject(bkt.vname, obj.name, objConf, obj.kmsKey, bodyFinal);
354+
await scenarios.assertObjectSSE(
354355
{ ...baseAssertion, Body: bodyFinal }, { objConf, obj }, { bktConf, bkt },
355356
{}, 'after'); // null
356-
void await scenarios.assertObjectSSE(
357+
await scenarios.assertObjectSSE(
357358
{ ...baseAssertion, Body: bodyFinal }, { objConf, obj }, { bktConf, bkt },
358359
'null', 'after');
359360
({ Versions } = await helpers.s3.listObjectVersions({ Bucket: bkt.vname }).promise());
@@ -363,7 +364,7 @@ describe('SSE KMS arnPrefix', () => {
363364
}));
364365

365366
it('should encrypt MPU and copy parts from every buckets and objects matrice', async () => {
366-
void await helpers.s3.putBucketEncryption({
367+
await helpers.s3.putBucketEncryption({
367368
Bucket: mpuCopyBkt,
368369
// AES256 because input key is broken for now
369370
ServerSideEncryptionConfiguration: helpers.hydrateSSEConfig({ algo: 'AES256' }),
@@ -396,7 +397,7 @@ describe('SSE KMS arnPrefix', () => {
396397

397398
const parts = await Promise.all(uploadPromises);
398399

399-
void await helpers.s3.completeMultipartUpload({
400+
await helpers.s3.completeMultipartUpload({
400401
UploadId: mpu.UploadId,
401402
Bucket: mpuCopyBkt,
402403
Key: mpuKey,
@@ -409,7 +410,7 @@ describe('SSE KMS arnPrefix', () => {
409410
Key: mpuKey,
410411
Body: parts.reduce((acc, part) => `${acc}${part.body}`, ''),
411412
};
412-
void await scenarios.assertObjectSSE(assertion, { objConf: {}, obj: {} },
413+
await scenarios.assertObjectSSE(assertion, { objConf: {}, obj: {} },
413414
{ bktConf: { algo: 'AES256' }, bkt: {} }, {}, 'after');
414415
});
415416
});
@@ -420,23 +421,23 @@ describe('ensure MPU use good SSE', () => {
420421

421422
before(async () => {
422423
kmsKeympuKmsBkt = (await helpers.createKmsKey(log)).masterKeyArn;
423-
void await helpers.MD.setup();
424-
void await helpers.s3.createBucket({ Bucket: mpuKmsBkt }).promise();
425-
void await helpers.s3.putBucketEncryption({
424+
await helpers.MD.setup();
425+
await helpers.s3.createBucket({ Bucket: mpuKmsBkt }).promise();
426+
await helpers.s3.putBucketEncryption({
426427
Bucket: mpuKmsBkt,
427428
ServerSideEncryptionConfiguration:
428429
helpers.hydrateSSEConfig({ algo: 'aws:kms', masterKeyId: kmsKeympuKmsBkt }) }).promise();
429430
});
430431

431432
after(async () => {
432-
void await helpers.cleanup(mpuKmsBkt);
433+
await helpers.cleanup(mpuKmsBkt);
433434
});
434435

435436
it('mpu upload part should fail with sse header', async () => {
436437
const key = 'mpuKeyBadUpload';
437438
const mpu = await helpers.s3.createMultipartUpload({
438439
Bucket: mpuKmsBkt, Key: key }).promise();
439-
void await assert.rejects(promisify(makeRequest)({
440+
await assert.rejects(promisify(makeRequest)({
440441
method: 'PUT',
441442
hostname: helpers.s3.endpoint.hostname,
442443
port: helpers.s3.endpoint.port,
@@ -494,9 +495,9 @@ describe('ensure MPU use good SSE', () => {
494495
const bktForAssert = {
495496
bktConf: { algo: 'aws:kms', masterKeyId: true },
496497
bkt: { kmsKey: kmsKeympuKmsBkt,
497-
kmsKeyInfo: { masterKeyId: kmsKeympuKmsBkt, masterKeyArn: kmsKeympuKmsBkt } }
498+
kmsKeyInfo: { masterKeyId: kmsKeympuKmsBkt, masterKeyArn: kmsKeympuKmsBkt } },
498499
};
499-
void await scenarios.assertObjectSSE(
500+
await scenarios.assertObjectSSE(
500501
assertion,
501502
objForAssert,
502503
bktForAssert,
@@ -505,6 +506,7 @@ describe('ensure MPU use good SSE', () => {
505506
);
506507
});
507508
});
509+
508510
describe('KMS error', () => {
509511
const sseConfig = { algo: 'aws:kms', masterKeyId: true };
510512
const Bucket = 'bkt-kms-err';
@@ -560,7 +562,7 @@ describe('KMS error', () => {
560562
}
561563

562564
before(async () => {
563-
void await helpers.s3.createBucket({ Bucket }).promise();
565+
await helpers.s3.createBucket({ Bucket }).promise();
564566

565567
await helpers.s3.putObject({
566568
...helpers.putObjParams(Bucket, 'plaintext', {}, null),
@@ -581,14 +583,14 @@ describe('KMS error', () => {
581583
helpers.putObjParams(Bucket, 'mpuEncrypted', sseConfig, masterKeyArn)).promise();
582584

583585
// make key unavailable
584-
void await helpers.destroyKmsKey(masterKeyArn, log);
586+
await helpers.destroyKmsKey(masterKeyArn, log);
585587
});
586588

587589
after(async () => {
588-
void await helpers.cleanup(Bucket);
590+
await helpers.cleanup(Bucket);
589591
if (masterKeyArn) {
590592
try {
591-
void await helpers.destroyKmsKey(masterKeyArn, log);
593+
await helpers.destroyKmsKey(masterKeyArn, log);
592594
} catch (e) { void e; }
593595
[masterKeyArn, masterKeyId] = [null, null];
594596
}

0 commit comments

Comments
 (0)