getAzure.js

const assert = require('assert');
const { CreateBucketCommand,
    PutObjectCommand,
    GetObjectCommand } = require('@aws-sdk/client-s3');

const BucketUtility = require('../../../lib/utility/bucket-util');
const withV4 = require('../../support/withV4');

const {
    uniqName,
    getAzureClient,
    getAzureContainerName,
    getAzureKeys,
    azureLocation,
    describeSkipIfNotMultiple,
} = require('../utils');

const azureClient = getAzureClient();
const azureContainerName = getAzureContainerName(azureLocation);
const keys = getAzureKeys();
const keyObject = 'getazure';

const normalBody = Buffer.from('I am a body', 'utf8');

const azureTimeout = 10000;

describeSkipIfNotMultiple('Multiple backend get object from Azure',
function testSuite() {
    this.timeout(30000);
    withV4(sigCfg => {
        let bucketUtil;
        let s3;

        before(() => {
            process.stdout.write('Creating bucket');
            bucketUtil = new BucketUtility('default', sigCfg);
            s3 = bucketUtil.s3;
            return s3.send(new CreateBucketCommand({ Bucket: azureContainerName }))
            .catch(err => {
                process.stdout.write(`Error creating bucket: ${err}\n`);
                throw err;
            });
        });

        after(() => {
            process.stdout.write('Emptying bucket\n');
            return bucketUtil.empty(azureContainerName)
            .then(() => {
                process.stdout.write('Deleting bucket\n');
                return bucketUtil.deleteOne(azureContainerName);
            })
            .catch(err => {
                process.stdout.write('Error emptying/deleting bucket: ' +
                `${err}\n`);
                throw err;
            });
        });
        keys.forEach(key => {
            describe(`${key.describe} size`, () => {
                const testKey = `${key.name}-${Date.now()}`;
                before(done => {
                    setTimeout(() => {
                        s3.send(new PutObjectCommand({
                            Bucket: azureContainerName,
                            Key: testKey,
                            Body: key.body,
                            Metadata: {
                                'scal-location-constraint': azureLocation,
                            },
                        })).then(() => done())
                        .catch(err => {
                            done(err);
                        });
                    }, azureTimeout);
                });

                it(`should get an ${key.describe} object from Azure`, done => {
                    s3.send(new GetObjectCommand({ Bucket: azureContainerName, Key:
                      testKey })).then(res => {
                        assert.strictEqual(res.ETag, `"${key.MD5}"`);
                        done();
                    }).catch(err => {
                        assert.equal(err, null, 'Expected success ' +
                            `but got error ${err}`);
                        done(err);
                    });
                });
            });
        });

        describe('with range', () => {
            const azureObject = uniqName(keyObject);
            before(done => {
                s3.send(new PutObjectCommand({
                    Bucket: azureContainerName,
                    Key: azureObject,
                    Body: '0123456789',
                    Metadata: {
                        'scal-location-constraint': azureLocation,
                    },
                })).then(() => done())
                .catch(err => {
                    done(err);
                });
            });

            it('should get an object with body 012345 with "bytes=0-5"',
            done => {
                s3.send(new GetObjectCommand({
                    Bucket: azureContainerName,
                    Key: azureObject,
                    Range: 'bytes=0-5',
                })).then(async res => {
                    const body = await res.Body.transformToString();
                    assert.equal(res.ContentLength, 6);
                    assert.strictEqual(res.ContentRange, 'bytes 0-5/10');
                    assert.strictEqual(body, '012345');
                    done();
                }).catch(err => {
                    assert.equal(err, null, 'Expected success but got ' +
                      `error ${err}`);
                    done(err);
                });
            });
            it('should get an object with body 456789 with "bytes=4-"',
            done => {
                s3.send(new GetObjectCommand({
                    Bucket: azureContainerName,
                    Key: azureObject,
                    Range: 'bytes=4-',
                })).then(async res => {
                    const body = await res.Body.transformToString();
                    assert.equal(res.ContentLength, 6);
                    assert.strictEqual(res.ContentRange, 'bytes 4-9/10');
                    assert.strictEqual(body, '456789');
                    done();
                }).catch(err => {
                    assert.equal(err, null, 'Expected success but got ' +
                      `error ${err}`);
                    done(err);
                });
            });
        });

        describe('returning error', () => {
            const azureObject = uniqName(keyObject);
            before(done => {
                s3.send(new PutObjectCommand({
                    Bucket: azureContainerName,
                    Key: azureObject,
                    Body: normalBody,
                    Metadata: {
                        'scal-location-constraint': azureLocation,
                    },
                })).then(() => {
                    azureClient.getContainerClient(azureContainerName)
                        .deleteBlob(azureObject).then(done, err => {
                            assert.equal(err, null, 'Expected success but got ' +
                                `error ${err}`);
                            done(err);
                        });
                })
                .catch(err => {
                    assert.equal(err, null, 'Expected success but got ' +
                        `error ${err}`);
                    done(err);
                });
            });

            it('should return an error on get done to object deleted ' +
            'from Azure', done => {
                s3.send(new GetObjectCommand({
                    Bucket: azureContainerName,
                    Key: azureObject,
                })).then(() => {
                    done();
                }).catch(err => {
                    assert.strictEqual(err.name, 'LocationNotFound');
                    done(err);
                });
            });
        });
    });
});