154 lines
4 KiB
JavaScript
154 lines
4 KiB
JavaScript
const assert = require('assert');
|
|
const sinon = require('sinon');
|
|
const proxyquire = require('proxyquire').noCallThru();
|
|
|
|
function resolvedPromise(val) {
|
|
return {
|
|
promise: () => Promise.resolve(val)
|
|
};
|
|
}
|
|
|
|
function rejectedPromise(err) {
|
|
return {
|
|
promise: () => Promise.reject(err)
|
|
};
|
|
}
|
|
|
|
const s3Stub = {
|
|
headObject: sinon.stub(),
|
|
getObject: sinon.stub(),
|
|
upload: sinon.stub(),
|
|
deleteObject: sinon.stub()
|
|
};
|
|
|
|
const awsStub = {
|
|
S3: function() {
|
|
return s3Stub;
|
|
}
|
|
};
|
|
|
|
const S3Storage = proxyquire('../../server/storage/s3', {
|
|
'aws-sdk': awsStub
|
|
});
|
|
|
|
describe('S3Storage', function() {
|
|
it('uses config.s3_bucket', function() {
|
|
const s = new S3Storage({ s3_bucket: 'foo' });
|
|
assert.equal(s.bucket, 'foo');
|
|
});
|
|
|
|
describe('length', function() {
|
|
it('returns the ContentLength', async function() {
|
|
s3Stub.headObject = sinon
|
|
.stub()
|
|
.returns(resolvedPromise({ ContentLength: 123 }));
|
|
const s = new S3Storage({ s3_bucket: 'foo' });
|
|
const len = await s.length('x');
|
|
assert.equal(len, 123);
|
|
sinon.assert.calledWithMatch(s3Stub.headObject, {
|
|
Bucket: 'foo',
|
|
Key: 'x'
|
|
});
|
|
});
|
|
|
|
it('throws when id not found', async function() {
|
|
const err = new Error();
|
|
s3Stub.headObject = sinon.stub().returns(rejectedPromise(err));
|
|
const s = new S3Storage({ s3_bucket: 'foo' });
|
|
try {
|
|
await s.length('x');
|
|
assert.fail();
|
|
} catch (e) {
|
|
assert.equal(e, err);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('getStream', function() {
|
|
it('returns a Stream object', function() {
|
|
const stream = {};
|
|
s3Stub.getObject = sinon
|
|
.stub()
|
|
.returns({ createReadStream: () => stream });
|
|
const s = new S3Storage({ s3_bucket: 'foo' });
|
|
const result = s.getStream('x');
|
|
assert.equal(result, stream);
|
|
sinon.assert.calledWithMatch(s3Stub.getObject, {
|
|
Bucket: 'foo',
|
|
Key: 'x'
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('set', function() {
|
|
it('calls s3.upload', async function() {
|
|
const file = { on: sinon.stub() };
|
|
s3Stub.upload = sinon.stub().returns(resolvedPromise());
|
|
const s = new S3Storage({ s3_bucket: 'foo' });
|
|
await s.set('x', file);
|
|
sinon.assert.calledWithMatch(s3Stub.upload, {
|
|
Bucket: 'foo',
|
|
Key: 'x',
|
|
Body: file
|
|
});
|
|
});
|
|
|
|
it('aborts upload if limit is hit', async function() {
|
|
const file = {
|
|
on: (ev, fn) => fn()
|
|
};
|
|
const abort = sinon.stub();
|
|
const err = new Error();
|
|
s3Stub.upload = sinon.stub().returns({
|
|
promise: () => Promise.reject(err),
|
|
abort
|
|
});
|
|
const s = new S3Storage({ s3_bucket: 'foo' });
|
|
try {
|
|
await s.set('x', file);
|
|
assert.fail();
|
|
} catch (e) {
|
|
assert.equal(e.message, 'limit');
|
|
sinon.assert.calledOnce(abort);
|
|
}
|
|
});
|
|
|
|
it('throws when s3.upload fails', async function() {
|
|
const file = {
|
|
on: sinon.stub()
|
|
};
|
|
const err = new Error();
|
|
s3Stub.upload = sinon.stub().returns(rejectedPromise(err));
|
|
const s = new S3Storage({ s3_bucket: 'foo' });
|
|
try {
|
|
await s.set('x', file);
|
|
assert.fail();
|
|
} catch (e) {
|
|
assert.equal(e, err);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('del', function() {
|
|
it('calls s3.deleteObject', async function() {
|
|
s3Stub.deleteObject = sinon.stub().returns(resolvedPromise(true));
|
|
const s = new S3Storage({ s3_bucket: 'foo' });
|
|
const result = await s.del('x');
|
|
assert.equal(result, true);
|
|
sinon.assert.calledWithMatch(s3Stub.deleteObject, {
|
|
Bucket: 'foo',
|
|
Key: 'x'
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('ping', function() {
|
|
it('calls s3.headBucket', async function() {
|
|
s3Stub.headBucket = sinon.stub().returns(resolvedPromise(true));
|
|
const s = new S3Storage({ s3_bucket: 'foo' });
|
|
const result = await s.ping();
|
|
assert.equal(result, true);
|
|
sinon.assert.calledWithMatch(s3Stub.headBucket, { Bucket: 'foo' });
|
|
});
|
|
});
|
|
});
|