|
1 | 1 | const assert = require('assert'); |
2 | 2 | const async = require('async'); |
| 3 | +const { |
| 4 | + CreateBucketCommand, |
| 5 | + PutObjectCommand, |
| 6 | + PutBucketVersioningCommand, |
| 7 | + DeleteObjectCommand, |
| 8 | + DeleteBucketCommand, |
| 9 | +} = require('@aws-sdk/client-s3'); |
3 | 10 | const BucketUtility = require('../aws-node-sdk/lib/utility/bucket-util'); |
4 | 11 | const { removeAllVersions } = require('../aws-node-sdk/lib/utility/versioning-util'); |
5 | 12 | const { makeBackbeatRequest } = require('./utils'); |
@@ -50,58 +57,81 @@ function checkContents(contents, expectedKeyVersions) { |
50 | 57 | let date; |
51 | 58 | const expectedKeyVersions = {}; |
52 | 59 |
|
53 | | - before(done => async.series([ |
54 | | - next => s3.createBucket({ Bucket: testBucket }, next), |
55 | | - next => s3.createBucket({ Bucket: emptyBucket }, next), |
| 60 | + before(done => { |
| 61 | + bucketUtil = new BucketUtility('account1', { signatureVersion: 'v4' }); |
| 62 | + s3 = bucketUtil.s3; |
| 63 | + |
| 64 | + return async.series([ |
| 65 | + next => s3.send(new CreateBucketCommand({ Bucket: testBucket })) |
| 66 | + .then(() => next()) |
| 67 | + .catch(next), |
| 68 | + next => s3.send(new CreateBucketCommand({ Bucket: emptyBucket })) |
| 69 | + .then(() => next()) |
| 70 | + .catch(next), |
56 | 71 | next => { |
57 | 72 | if (versioning !== 'Enabled') { |
58 | 73 | return process.nextTick(next); |
59 | 74 | } |
60 | | - return s3.putBucketVersioning({ |
| 75 | + return s3.send(new PutBucketVersioningCommand({ |
61 | 76 | Bucket: testBucket, |
62 | 77 | VersioningConfiguration: { Status: 'Enabled' }, |
63 | | - }, next); |
| 78 | + })) |
| 79 | + .then(() => next()) |
| 80 | + .catch(next); |
64 | 81 | }, |
65 | 82 | next => { |
66 | 83 | if (versioning !== 'Enabled') { |
67 | 84 | return process.nextTick(next); |
68 | 85 | } |
69 | | - return s3.putBucketVersioning({ |
| 86 | + return s3.send(new PutBucketVersioningCommand({ |
70 | 87 | Bucket: emptyBucket, |
71 | 88 | VersioningConfiguration: { Status: 'Enabled' }, |
72 | | - }, next); |
| 89 | + })) |
| 90 | + .then(() => next()) |
| 91 | + .catch(next); |
73 | 92 | }, |
74 | 93 | next => async.times(3, (n, cb) => { |
75 | 94 | const keyName = `oldkey${n}`; |
76 | | - s3.putObject({ Bucket: testBucket, Key: keyName, Body: '123', Tagging: 'mykey=myvalue' }, |
77 | | - (err, data) => { |
78 | | - if (err) { |
79 | | - cb(err); |
80 | | - } |
81 | | - expectedKeyVersions[keyName] = data.VersionId; |
82 | | - return cb(); |
83 | | - }); |
| 95 | + s3.send(new PutObjectCommand({ |
| 96 | + Bucket: testBucket, |
| 97 | + Key: keyName, |
| 98 | + Body: '123', |
| 99 | + Tagging: 'mykey=myvalue', |
| 100 | + })) |
| 101 | + .then(data => { |
| 102 | + expectedKeyVersions[keyName] = data.VersionId; |
| 103 | + cb(); |
| 104 | + }) |
| 105 | + .catch(cb); |
84 | 106 | }, next), |
85 | 107 | next => { |
86 | 108 | date = new Date(Date.now()).toISOString(); |
87 | 109 | return async.times(5, (n, cb) => { |
88 | 110 | const keyName = `key${n}`; |
89 | | - s3.putObject({ Bucket: testBucket, Key: keyName, Body: '123', Tagging: 'mykey=myvalue' }, |
90 | | - (err, data) => { |
91 | | - if (err) { |
92 | | - cb(err); |
93 | | - } |
94 | | - expectedKeyVersions[keyName] = data.VersionId; |
95 | | - return cb(); |
96 | | - }); |
| 111 | + s3.send(new PutObjectCommand({ |
| 112 | + Bucket: testBucket, |
| 113 | + Key: keyName, |
| 114 | + Body: '123', |
| 115 | + Tagging: 'mykey=myvalue', |
| 116 | + })) |
| 117 | + .then(data => { |
| 118 | + expectedKeyVersions[keyName] = data.VersionId; |
| 119 | + cb(); |
| 120 | + }) |
| 121 | + .catch(cb); |
97 | 122 | }, next); |
98 | 123 | }, |
99 | | - ], done)); |
| 124 | + ], done); |
| 125 | + }); |
100 | 126 |
|
101 | 127 | after(done => async.series([ |
102 | 128 | next => removeAllVersions({ Bucket: testBucket }, next), |
103 | | - next => s3.deleteBucket({ Bucket: testBucket }, next), |
104 | | - next => s3.deleteBucket({ Bucket: emptyBucket }, next), |
| 129 | + next => s3.send(new DeleteBucketCommand({ Bucket: testBucket })) |
| 130 | + .then(() => next()) |
| 131 | + .catch(next), |
| 132 | + next => s3.send(new DeleteBucketCommand({ Bucket: emptyBucket })) |
| 133 | + .then(() => next()) |
| 134 | + .catch(next), |
105 | 135 | ], done)); |
106 | 136 |
|
107 | 137 | it('should return empty list of current versions if bucket is empty', done => { |
@@ -410,50 +440,70 @@ describe('listLifecycleCurrents with bucket versioning enabled and maxKeys', () |
410 | 440 | const testBucket = 'bucket-for-list-lifecycle-current-tests-truncated'; |
411 | 441 | const expectedKeyVersions = {}; |
412 | 442 |
|
413 | | - before(done => async.series([ |
414 | | - next => s3.createBucket({ Bucket: testBucket }, next), |
415 | | - next => s3.putBucketVersioning({ |
| 443 | + before(done => { |
| 444 | + bucketUtil = new BucketUtility('account1', { signatureVersion: 'v4' }); |
| 445 | + s3 = bucketUtil.s3; |
| 446 | + |
| 447 | + return async.series([ |
| 448 | + next => s3.send(new CreateBucketCommand({ Bucket: testBucket })) |
| 449 | + .then(() => next()) |
| 450 | + .catch(next), |
| 451 | + next => s3.send(new PutBucketVersioningCommand({ |
416 | 452 | Bucket: testBucket, |
417 | 453 | VersioningConfiguration: { Status: 'Enabled' }, |
418 | | - }, next), |
| 454 | + })) |
| 455 | + .then(() => next()) |
| 456 | + .catch(next), |
419 | 457 | next => async.times(3, (n, cb) => { |
420 | 458 | const keyName = 'key0'; |
421 | | - s3.putObject({ Bucket: testBucket, Key: keyName, Body: '123', Tagging: 'mykey=myvalue' }, |
422 | | - (err, data) => { |
423 | | - if (err) { |
424 | | - cb(err); |
425 | | - } |
426 | | - expectedKeyVersions[keyName] = data.VersionId; |
427 | | - return cb(); |
428 | | - }); |
| 459 | + s3.send(new PutObjectCommand({ |
| 460 | + Bucket: testBucket, |
| 461 | + Key: keyName, |
| 462 | + Body: '123', |
| 463 | + Tagging: 'mykey=myvalue', |
| 464 | + })) |
| 465 | + .then(data => { |
| 466 | + expectedKeyVersions[keyName] = data.VersionId; |
| 467 | + cb(); |
| 468 | + }) |
| 469 | + .catch(err => cb(err)); |
429 | 470 | }, next), |
430 | 471 | next => async.times(5, (n, cb) => { |
431 | 472 | const keyName = 'key1'; |
432 | | - s3.putObject({ Bucket: testBucket, Key: keyName, Body: '123', Tagging: 'mykey=myvalue' }, |
433 | | - (err, data) => { |
434 | | - if (err) { |
435 | | - cb(err); |
436 | | - } |
437 | | - expectedKeyVersions[keyName] = data.VersionId; |
438 | | - return cb(); |
439 | | - }); |
| 473 | + s3.send(new PutObjectCommand({ |
| 474 | + Bucket: testBucket, |
| 475 | + Key: keyName, |
| 476 | + Body: '123', |
| 477 | + Tagging: 'mykey=myvalue', |
| 478 | + })) |
| 479 | + .then(data => { |
| 480 | + expectedKeyVersions[keyName] = data.VersionId; |
| 481 | + cb(); |
| 482 | + }) |
| 483 | + .catch(err => cb(err)); |
440 | 484 | }, next), |
441 | 485 | next => async.times(3, (n, cb) => { |
442 | 486 | const keyName = 'key2'; |
443 | | - s3.putObject({ Bucket: testBucket, Key: keyName, Body: '123', Tagging: 'mykey=myvalue' }, |
444 | | - (err, data) => { |
445 | | - if (err) { |
446 | | - cb(err); |
447 | | - } |
448 | | - expectedKeyVersions[keyName] = data.VersionId; |
449 | | - return cb(); |
450 | | - }); |
| 487 | + s3.send(new PutObjectCommand({ |
| 488 | + Bucket: testBucket, |
| 489 | + Key: keyName, |
| 490 | + Body: '123', |
| 491 | + Tagging: 'mykey=myvalue', |
| 492 | + })) |
| 493 | + .then(data => { |
| 494 | + expectedKeyVersions[keyName] = data.VersionId; |
| 495 | + cb(); |
| 496 | + }) |
| 497 | + .catch(err => cb(err)); |
451 | 498 | }, next), |
452 | | - ], done)); |
| 499 | + ], done) |
| 500 | + }); |
453 | 501 |
|
454 | 502 | after(done => async.series([ |
455 | 503 | next => removeAllVersions({ Bucket: testBucket }, next), |
456 | | - next => s3.deleteBucket({ Bucket: testBucket }, next), |
| 504 | + next => s3.send(new DeleteBucketCommand({ Bucket: testBucket })) |
| 505 | + .then(() => next()) |
| 506 | + .catch(next), |
457 | 507 | ], done)); |
458 | 508 |
|
459 | 509 | it('should return truncated lists - part 1', done => { |
@@ -542,52 +592,82 @@ describe('listLifecycleCurrents with bucket versioning enabled and maxKeys', () |
542 | 592 | }); |
543 | 593 | }); |
544 | 594 |
|
545 | | - |
546 | 595 | describe('listLifecycleCurrents with bucket versioning enabled and delete object', () => { |
547 | 596 | const testBucket = 'bucket-for-list-lifecycle-current-tests-truncated'; |
548 | 597 | const keyName0 = 'key0'; |
549 | 598 | const keyName1 = 'key1'; |
550 | 599 | const keyName2 = 'key2'; |
551 | 600 | const expectedKeyVersions = {}; |
552 | 601 |
|
553 | | - before(done => async.series([ |
554 | | - next => s3.createBucket({ Bucket: testBucket }, next), |
555 | | - next => s3.putBucketVersioning({ |
| 602 | + before(done => { |
| 603 | + bucketUtil = new BucketUtility('account1', { signatureVersion: 'v4' }); |
| 604 | + s3 = bucketUtil.s3; |
| 605 | + |
| 606 | + return async.series([ |
| 607 | + next => s3.send(new CreateBucketCommand({ Bucket: testBucket })) |
| 608 | + .then(() => next()) |
| 609 | + .catch(next), |
| 610 | + next => s3.send(new PutBucketVersioningCommand({ |
556 | 611 | Bucket: testBucket, |
557 | 612 | VersioningConfiguration: { Status: 'Enabled' }, |
558 | | - }, next), |
559 | | - next => { |
560 | | - s3.putObject({ Bucket: testBucket, Key: keyName0, Body: '123', Tagging: 'mykey=myvalue' }, |
561 | | - (err, data) => { |
562 | | - if (err) { |
563 | | - next(err); |
564 | | - } |
| 613 | + })) |
| 614 | + .then(() => next()) |
| 615 | + .catch(next), |
| 616 | + next => s3.send(new PutObjectCommand({ |
| 617 | + Bucket: testBucket, |
| 618 | + Key: keyName0, |
| 619 | + Body: '123', |
| 620 | + Tagging: 'mykey=myvalue', |
| 621 | + })) |
| 622 | + .then(data => { |
565 | 623 | expectedKeyVersions[keyName0] = data.VersionId; |
566 | | - return next(); |
567 | | - }); |
568 | | - }, |
569 | | - next => s3.putObject({ Bucket: testBucket, Key: keyName1, Body: '123', Tagging: 'mykey=myvalue' }, next), |
570 | | - next => s3.deleteObject({ Bucket: testBucket, Key: keyName1 }, next), |
571 | | - next => s3.putObject({ Bucket: testBucket, Key: keyName2, Body: '123', Tagging: 'mykey=myvalue' }, |
572 | | - (err, data) => { |
573 | | - if (err) { |
574 | | - next(err); |
575 | | - } |
| 624 | + next(); |
| 625 | + }) |
| 626 | + .catch(next), |
| 627 | + next => s3.send(new PutObjectCommand({ |
| 628 | + Bucket: testBucket, |
| 629 | + Key: keyName1, |
| 630 | + Body: '123', |
| 631 | + Tagging: 'mykey=myvalue', |
| 632 | + })) |
| 633 | + .then(() => next()) |
| 634 | + .catch(next), |
| 635 | + next => s3.send(new DeleteObjectCommand({ Bucket: testBucket, Key: keyName1 })) |
| 636 | + .then(() => next()) |
| 637 | + .catch(next), |
| 638 | + next => s3.send(new PutObjectCommand({ |
| 639 | + Bucket: testBucket, |
| 640 | + Key: keyName2, |
| 641 | + Body: '123', |
| 642 | + Tagging: 'mykey=myvalue', |
| 643 | + })) |
| 644 | + .then(data => { |
576 | 645 | expectedKeyVersions[keyName2] = data.VersionId; |
577 | | - return next(); |
578 | | - }), |
579 | | - next => s3.putObject({ Bucket: testBucket, Key: keyName2, Body: '123', Tagging: 'mykey=myvalue' }, |
580 | | - (err, data) => { |
581 | | - if (err) { |
582 | | - return next(err); |
583 | | - } |
584 | | - return s3.deleteObject({ Bucket: testBucket, Key: keyName2, VersionId: data.VersionId }, next); |
585 | | - }), |
586 | | - ], done)); |
| 646 | + next(); |
| 647 | + }) |
| 648 | + .catch(next), |
| 649 | + next => s3.send(new PutObjectCommand({ |
| 650 | + Bucket: testBucket, |
| 651 | + Key: keyName2, |
| 652 | + Body: '123', |
| 653 | + Tagging: 'mykey=myvalue', |
| 654 | + })) |
| 655 | + .then(data => s3.send(new DeleteObjectCommand({ |
| 656 | + Bucket: testBucket, |
| 657 | + Key: keyName2, |
| 658 | + VersionId: data.VersionId, |
| 659 | + })) |
| 660 | + .then(() => next()) |
| 661 | + .catch(next)) |
| 662 | + .catch(next), |
| 663 | + ], done); |
| 664 | + }); |
587 | 665 |
|
588 | 666 | after(done => async.series([ |
589 | 667 | next => removeAllVersions({ Bucket: testBucket }, next), |
590 | | - next => s3.deleteBucket({ Bucket: testBucket }, next), |
| 668 | + next => s3.send(new DeleteBucketCommand({ Bucket: testBucket })) |
| 669 | + .then(() => next()) |
| 670 | + .catch(next), |
591 | 671 | ], done)); |
592 | 672 |
|
593 | 673 | it('should return truncated lists - part 1', done => { |
|
0 commit comments