Skip to content

Commit 80ec73d

Browse files
bert-ebert-e
committed
Merge branch 'w/9.0/improvement/CLDSRV-670-test-linting' into tmp/octopus/w/9.1/improvement/CLDSRV-670-test-linting
2 parents 75188ef + 8a07c1d commit 80ec73d

File tree

4 files changed

+138
-137
lines changed

4 files changed

+138
-137
lines changed

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

Lines changed: 61 additions & 60 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
/* eslint-disable */
1+
/* eslint-disable no-console */
22
const { promisify } = require('util');
33
const { DummyRequestLogger } = require('../../unit/helpers');
44
const assert = require('assert');
@@ -34,28 +34,28 @@ describe('SSE KMS arnPrefix', () => {
3434
? bkt.kmsKeyInfo.masterKeyArn
3535
: bkt.kmsKeyInfo.masterKeyId;
3636
}
37-
void await helpers.s3.createBucket(({ Bucket: bkt.name })).promise();
38-
void await helpers.s3.createBucket(({ Bucket: bkt.vname })).promise();
37+
await helpers.s3.createBucket(({ Bucket: bkt.name })).promise();
38+
await helpers.s3.createBucket(({ Bucket: bkt.vname })).promise();
3939
if (bktConf.deleteSSE) {
4040
await scenarios.deleteBucketSSEBeforeEach(bkt.name, log);
4141
await scenarios.deleteBucketSSEBeforeEach(bkt.vname, log);
4242
}
4343
if (bktConf.algo) {
4444
// bucket encryption will be asserted in bucket test
45-
void await helpers.s3.putBucketEncryption({
45+
await helpers.s3.putBucketEncryption({
4646
Bucket: bkt.name,
4747
ServerSideEncryptionConfiguration: helpers.hydrateSSEConfig({
4848
algo: bktConf.algo, masterKeyId: bkt.kmsKey }),
4949
}).promise();
50-
void await helpers.s3.putBucketEncryption({
50+
await helpers.s3.putBucketEncryption({
5151
Bucket: bkt.vname,
5252
ServerSideEncryptionConfiguration: helpers.hydrateSSEConfig({
5353
algo: bktConf.algo, masterKeyId: bkt.kmsKey }),
5454
}).promise();
5555
}
5656

5757
// Put an object for each SSE conf in each bucket
58-
void await Promise.all(scenarios.testCases.map(async objConf => {
58+
await Promise.all(scenarios.testCases.map(async objConf => {
5959
const obj = {
6060
name: `for-copy-enc-obj-${objConf.name}`,
6161
kmsKeyInfo: null,
@@ -70,7 +70,7 @@ describe('SSE KMS arnPrefix', () => {
7070
: obj.kmsKeyInfo.masterKeyId;
7171
}
7272

73-
await helpers.putEncryptedObject(bkt.name, obj.name, objConf, obj.kmsKey, obj.body);
73+
return await helpers.putEncryptedObject(bkt.name, obj.name, objConf, obj.kmsKey, obj.body);
7474
}));
7575
};
7676

@@ -79,37 +79,37 @@ describe('SSE KMS arnPrefix', () => {
7979
{ profile: helpers.credsProfile, accessKeyId: helpers.s3.config.credentials.accessKeyId });
8080
const allBuckets = (await helpers.s3.listBuckets().promise()).Buckets.map(b => b.Name);
8181
console.log('List buckets:', allBuckets);
82-
void await helpers.MD.setup();
82+
await helpers.MD.setup();
8383
copyKmsKey = (await helpers.createKmsKey(log)).masterKeyArn;
8484
try {
8585
// 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);
86+
await helpers.cleanup(copyBkt);
87+
await helpers.cleanup(mpuCopyBkt);
88+
await Promise.all(Object.values(bkts).map(async bkt => {
89+
await helpers.cleanup(bkt.name);
90+
return await helpers.cleanup(bkt.vname);
9191
}));
9292
} catch (e) { void e; }
9393

9494
// 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({
95+
await helpers.s3.createBucket(({ Bucket: copyBkt })).promise();
96+
await helpers.s3.createBucket(({ Bucket: mpuCopyBkt })).promise();
97+
await helpers.s3.putBucketEncryption({
9898
Bucket: copyBkt,
9999
ServerSideEncryptionConfiguration: helpers.hydrateSSEConfig({ algo: 'aws:kms', masterKeyId: copyKmsKey }),
100100
}).promise();
101-
void await helpers.s3.putObject({ Bucket: copyBkt, Key: copyObj, Body: 'BODY(copy)' }).promise();
101+
await helpers.s3.putObject({ Bucket: copyBkt, Key: copyObj, Body: 'BODY(copy)' }).promise();
102102

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

107107
after(async () => {
108-
void await helpers.cleanup(copyBkt);
109-
void await helpers.cleanup(mpuCopyBkt);
108+
await helpers.cleanup(copyBkt);
109+
await helpers.cleanup(mpuCopyBkt);
110110
// Clean every bucket
111-
void await Promise.all(Object.values(bkts).map(async bkt => {
112-
void await helpers.cleanup(bkt.name);
111+
await Promise.all(Object.values(bkts).map(async bkt => {
112+
await helpers.cleanup(bkt.name);
113113
return await helpers.cleanup(bkt.vname);
114114
}));
115115
});
@@ -177,11 +177,11 @@ describe('SSE KMS arnPrefix', () => {
177177
[
178178
{ name: `${obj.name} into encrypted destination bucket`, forceBktSSE: true },
179179
{ name: `${obj.name} into same bucket with object SSE config` },
180-
{ name: `from encrypted source into ${obj.name} with object SSE config` }
180+
{ name: `from encrypted source into ${obj.name} with object SSE config` },
181181
].forEach(({ name, forceBktSSE }, index) =>
182-
it(`should CopyObject ${name}`, async () =>
182+
it(`should CopyObject ${name}`, async () =>
183183
await scenarios.tests.copyObjectAndSSE(
184-
{ copyBkt, objForCopy, copyObj},
184+
{ copyBkt, objForCopy, copyObj },
185185
{ objConf, obj },
186186
{ bktConf, bkt },
187187
{ index, forceBktSSE },
@@ -205,7 +205,7 @@ describe('SSE KMS arnPrefix', () => {
205205
}, mpu, objConf.algo || bktConf.algo, 'after');
206206
newParts.push(part);
207207
}
208-
void await scenarios.tests.mpuComplete(
208+
await scenarios.tests.mpuComplete(
209209
{ UploadId: mpu.UploadId, Bucket: bkt.name, Key: mpuKey },
210210
{ existingParts: [], newParts },
211211
mpu, objConf.algo || bktConf.algo, 'after');
@@ -214,7 +214,7 @@ describe('SSE KMS arnPrefix', () => {
214214
Key: mpuKey,
215215
Body: `${obj.body}-MPU1${obj.body}-MPU2`,
216216
};
217-
void await scenarios.assertObjectSSE(assertion, { objConf, obj }, { bktConf, bkt }, {}, 'after');
217+
await scenarios.assertObjectSSE(assertion, { objConf, obj }, { bktConf, bkt }, {}, 'after');
218218
});
219219

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

239-
void await scenarios.tests.mpuComplete(
239+
await scenarios.tests.mpuComplete(
240240
{ UploadId: mpu.UploadId, Bucket: bkt.name, Key: mpuKey },
241241
{ existingParts: [], newParts: [part1, part2] },
242242
mpu, objConf.algo || bktConf.algo, 'after');
@@ -245,7 +245,7 @@ describe('SSE KMS arnPrefix', () => {
245245
Key: mpuKey,
246246
Body: `BODY(copy)${obj.body}-MPU2`,
247247
};
248-
void await scenarios.assertObjectSSE(assertion, { objConf, obj }, { bktConf, bkt }, {}, 'after');
248+
await scenarios.assertObjectSSE(assertion, { objConf, obj }, { bktConf, bkt }, {}, 'after');
249249
});
250250

251251
it('should encrypt MPU and copy an encrypted range parts from encrypted bucket', async () => {
@@ -268,7 +268,7 @@ describe('SSE KMS arnPrefix', () => {
268268
newParts.push(part);
269269
}
270270

271-
void await scenarios.tests.mpuComplete(
271+
await scenarios.tests.mpuComplete(
272272
{ UploadId: mpu.UploadId, Bucket: bkt.name, Key: mpuKey },
273273
{ existingParts: [], newParts },
274274
mpu, objConf.algo || bktConf.algo, 'after');
@@ -277,26 +277,26 @@ describe('SSE KMS arnPrefix', () => {
277277
Key: mpuKey,
278278
Body: 'copyBODY',
279279
};
280-
void await scenarios.assertObjectSSE(assertion, { objConf, obj }, { bktConf, bkt }, {}, 'after');
280+
await scenarios.assertObjectSSE(assertion, { objConf, obj }, { bktConf, bkt }, {}, 'after');
281281
});
282282

283283
it(`should PutObject versioned with SSE ${obj.name}`, async () => {
284284
// ensure versioned bucket is empty
285-
void await helpers.bucketUtil.empty(bkt.vname);
285+
await helpers.bucketUtil.empty(bkt.vname);
286286
let { Versions } = await helpers.s3.listObjectVersions({ Bucket: bkt.vname }).promise();
287287
// regularly count versioned objects
288288
assert.strictEqual(Versions.length, 0);
289289

290290
const bodyBase = `BODY(${obj.name})-base`;
291-
void await helpers.putEncryptedObject(bkt.vname, obj.name, objConf, obj.kmsKey, bodyBase);
291+
await helpers.putEncryptedObject(bkt.vname, obj.name, objConf, obj.kmsKey, bodyBase);
292292
const baseAssertion = { Bucket: bkt.vname, Key: obj.name };
293-
void await scenarios.assertObjectSSE(
293+
await scenarios.assertObjectSSE(
294294
{ ...baseAssertion, Body: bodyBase },
295295
{ objConf, obj }, { bktConf, bkt }, {}, 'after');
296296
({ Versions } = await helpers.s3.listObjectVersions({ Bucket: bkt.vname }).promise());
297297
assert.strictEqual(Versions.length, 1);
298298

299-
void await helpers.s3.putBucketVersioning({ Bucket: bkt.vname,
299+
await helpers.s3.putBucketVersioning({ Bucket: bkt.vname,
300300
VersioningConfiguration: { Status: 'Enabled' },
301301
}).promise();
302302

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

315-
void await scenarios.assertObjectSSE(
315+
await scenarios.assertObjectSSE(
316316
{ ...baseAssertion, Body: bodyV2 }, { objConf, obj }, { bktConf, bkt },
317317
{}, 'after'); // v2
318-
void await scenarios.assertObjectSSE(
318+
await scenarios.assertObjectSSE(
319319
{ ...baseAssertion, VersionId: 'null', Body: bodyBase }, { objConf, obj }, { bktConf, bkt },
320320
{}, 'after');
321-
void await scenarios.assertObjectSSE(
321+
await scenarios.assertObjectSSE(
322322
{ ...baseAssertion, VersionId: v1.VersionId, Body: bodyV1 }, { objConf, obj }, { bktConf, bkt },
323323
{}, 'after');
324-
void await scenarios.assertObjectSSE(
324+
await scenarios.assertObjectSSE(
325325
{ ...baseAssertion, VersionId: v2.VersionId, Body: bodyV2 }, { objConf, obj }, { bktConf, bkt },
326326
{}, 'after');
327327
({ Versions } = await helpers.s3.listObjectVersions({ Bucket: bkt.vname }).promise());
328328
assert.strictEqual(Versions.length, 3);
329329

330-
void await helpers.s3.putBucketVersioning({ Bucket: bkt.vname,
330+
await helpers.s3.putBucketVersioning({ Bucket: bkt.vname,
331331
VersioningConfiguration: { Status: 'Suspended' },
332332
}).promise();
333333

334334
// should be fine after version suspension
335-
void await scenarios.assertObjectSSE(
335+
await scenarios.assertObjectSSE(
336336
{ ...baseAssertion, Body: bodyV2 }, { objConf, obj }, { bktConf, bkt },
337337
{}, 'after'); // v2
338-
void await scenarios.assertObjectSSE(
338+
await scenarios.assertObjectSSE(
339339
{ ...baseAssertion, VersionId: 'null', Body: bodyBase }, { objConf, obj }, { bktConf, bkt },
340340
{}, 'after');
341-
void await scenarios.assertObjectSSE(
341+
await scenarios.assertObjectSSE(
342342
{ ...baseAssertion, VersionId: v1.VersionId, Body: bodyV1 }, { objConf, obj }, { bktConf, bkt },
343343
{}, 'after');
344-
void await scenarios.assertObjectSSE(
344+
await scenarios.assertObjectSSE(
345345
{ ...baseAssertion, VersionId: v2.VersionId, Body: bodyV2 }, { objConf, obj }, { bktConf, bkt },
346346
{}, 'after');
347347
({ Versions } = await helpers.s3.listObjectVersions({ Bucket: bkt.vname }).promise());
348348
assert.strictEqual(Versions.length, 3);
349349

350350
// put a new null version
351351
const bodyFinal = `BODY(${obj.name})-final`;
352-
void await helpers.putEncryptedObject(bkt.vname, obj.name, objConf, obj.kmsKey, bodyFinal);
353-
void await scenarios.assertObjectSSE(
352+
await helpers.putEncryptedObject(bkt.vname, obj.name, objConf, obj.kmsKey, bodyFinal);
353+
await scenarios.assertObjectSSE(
354354
{ ...baseAssertion, Body: bodyFinal }, { objConf, obj }, { bktConf, bkt },
355355
{}, 'after'); // null
356-
void await scenarios.assertObjectSSE(
356+
await scenarios.assertObjectSSE(
357357
{ ...baseAssertion, Body: bodyFinal }, { objConf, obj }, { bktConf, bkt },
358358
'null', 'after');
359359
({ Versions } = await helpers.s3.listObjectVersions({ Bucket: bkt.vname }).promise());
@@ -363,7 +363,7 @@ describe('SSE KMS arnPrefix', () => {
363363
}));
364364

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

397397
const parts = await Promise.all(uploadPromises);
398398

399-
void await helpers.s3.completeMultipartUpload({
399+
await helpers.s3.completeMultipartUpload({
400400
UploadId: mpu.UploadId,
401401
Bucket: mpuCopyBkt,
402402
Key: mpuKey,
@@ -409,7 +409,7 @@ describe('SSE KMS arnPrefix', () => {
409409
Key: mpuKey,
410410
Body: parts.reduce((acc, part) => `${acc}${part.body}`, ''),
411411
};
412-
void await scenarios.assertObjectSSE(assertion, { objConf: {}, obj: {} },
412+
await scenarios.assertObjectSSE(assertion, { objConf: {}, obj: {} },
413413
{ bktConf: { algo: 'AES256' }, bkt: {} }, {}, 'after');
414414
});
415415
});
@@ -420,16 +420,16 @@ describe('ensure MPU use good SSE', () => {
420420

421421
before(async () => {
422422
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({
423+
await helpers.MD.setup();
424+
await helpers.s3.createBucket({ Bucket: mpuKmsBkt }).promise();
425+
await helpers.s3.putBucketEncryption({
426426
Bucket: mpuKmsBkt,
427427
ServerSideEncryptionConfiguration:
428428
helpers.hydrateSSEConfig({ algo: 'aws:kms', masterKeyId: kmsKeympuKmsBkt }) }).promise();
429429
});
430430

431431
after(async () => {
432-
void await helpers.cleanup(mpuKmsBkt);
432+
await helpers.cleanup(mpuKmsBkt);
433433
});
434434

435435
it('mpu upload part should fail with sse header', async () => {
@@ -493,9 +493,9 @@ describe('ensure MPU use good SSE', () => {
493493
const bktForAssert = {
494494
bktConf: { algo: 'aws:kms', masterKeyId: true },
495495
bkt: { kmsKey: kmsKeympuKmsBkt,
496-
kmsKeyInfo: { masterKeyId: kmsKeympuKmsBkt, masterKeyArn: kmsKeympuKmsBkt } }
496+
kmsKeyInfo: { masterKeyId: kmsKeympuKmsBkt, masterKeyArn: kmsKeympuKmsBkt } },
497497
};
498-
void await scenarios.assertObjectSSE(
498+
await scenarios.assertObjectSSE(
499499
assertion,
500500
objForAssert,
501501
bktForAssert,
@@ -504,6 +504,7 @@ describe('ensure MPU use good SSE', () => {
504504
);
505505
});
506506
});
507+
507508
describe('KMS error', () => {
508509
const sseConfig = { algo: 'aws:kms', masterKeyId: true };
509510
const Bucket = 'bkt-kms-err';
@@ -559,7 +560,7 @@ describe('KMS error', () => {
559560
}
560561

561562
before(async () => {
562-
void await helpers.s3.createBucket({ Bucket }).promise();
563+
await helpers.s3.createBucket({ Bucket }).promise();
563564

564565
await helpers.s3.putObject({
565566
...helpers.putObjParams(Bucket, 'plaintext', {}, null),
@@ -580,14 +581,14 @@ describe('KMS error', () => {
580581
helpers.putObjParams(Bucket, 'mpuEncrypted', sseConfig, masterKeyArn)).promise();
581582

582583
// make key unavailable
583-
void await helpers.destroyKmsKey(masterKeyArn, log);
584+
await helpers.destroyKmsKey(masterKeyArn, log);
584585
});
585586

586587
after(async () => {
587-
void await helpers.cleanup(Bucket);
588+
await helpers.cleanup(Bucket);
588589
if (masterKeyArn) {
589590
try {
590-
void await helpers.destroyKmsKey(masterKeyArn, log);
591+
await helpers.destroyKmsKey(masterKeyArn, log);
591592
} catch (e) { void e; }
592593
[masterKeyArn, masterKeyId] = [null, null];
593594
}

0 commit comments

Comments
 (0)