before(() => {
awsMock.mock('SQS', 'receiveMessage', sqsMessages);
awsMock.mock('SQS', 'deleteMessage', { ResponseMetadata: { RequestId: 'e21774f2-6974-5d8b-adb2-3ba82afacdfc' } });
sqsClient = new AWS.SQS();
queue = new EmailQueue(sqsClient, { url: 'https://some_url.com' });
contextStub = sinon.stub(lambdaContext, 'getRemainingTimeInMillis').returns(100000);
awsMock.mock('Lambda', 'invoke', 'ok');
lambdaClient = new AWS.Lambda();
});
it('can get secret', (done) => {
AWS.mock('DynamoDB', 'query', mockQuery('credential-store'));
AWS.mock('KMS', 'decrypt', mockKMS);
var credstash = new Credstash();
return credstash.get('secret', (e, secret) => {
should.not.exist(e);
secret.should.equal('magic');
return done();
});
});
before(() => {
aws.mock('CloudWatchLogs', 'createLogGroup', (params, callback) => {
callback(null, mockResponse.createLogGroup)
})
aws.mock('CloudWatchLogs', 'putRetentionPolicy', (params, callback) => {
callback(null, mockResponse.putRetentionPolicy)
})
logs = new CloudWatchLogs(require('aws-sdk'))
})
it('can get N versions of a secret', (done) => {
AWS.mock('DynamoDB', 'query', mockQueryWithTake('credential-store'));
AWS.mock('KMS', 'decrypt', mockKMS);
var credstash = new Credstash();
return credstash.get('secret', { limit: 3 }, (e, secrets) => {
should.not.exist(e);
secrets[0].should.equal('magic');
secrets[1].should.equal('magic');
secrets[2].should.equal('magic');
return done();
});
});
it('can get secret from alternative table', (done) => {
AWS.mock('DynamoDB', 'query', mockQuery('another-table'));
AWS.mock('KMS', 'decrypt', mockKMS);
var credstash = new Credstash({
table: 'another-table'
});
return credstash.get('secret', (e, secret) => {
should.not.exist(e);
secret.should.equal('magic');
return done();
});
});
test.beforeEach(t => {
AWS.mock('DynamoDB.DocumentClient', 'put', (params, callback) => {
callback(null, stubPutMessage)
})
AWS.mock('DynamoDB.DocumentClient', 'update', (params, callback) => {
callback(null, stubPutMessage)
})
AWS.mock('DynamoDB.DocumentClient', 'query', (params, callback) => {
callback(null, stubQueryMessage)
})
AWS.mock('DynamoDB.DocumentClient', 'scan', (params, callback) => {
callback(null, stubQueryMessage)
})
})
before(() => {
AWS.mock('APIGateway', 'getRestApis', (params, callback) => {
callback(null, getRestApis);
});
AWS.mock('APIGateway', 'importRestApi', (params, callback) => {
callback(null, importRestApi);
});
AWS.mock('APIGateway', 'putRestApi', (params, callback) => {
callback(null, putRestApi);
});
AWS.mock('APIGateway', 'createDeployment', (params, callback) => {
callback(null, createDeployment);
});
});
tape('js dke', function(assert) {
AWS.mock('KMS', 'decrypt', function(params, callback) {
var encrypted = new Buffer(params.CiphertextBlob, 'base64').toString('utf8');
if (encrypted === 'EncryptedValue1')
return callback(null, { Plaintext: (new Buffer('DecryptedValue1')).toString('base64') });
if (encrypted === 'EncryptedValue2')
return callback(null, { Plaintext: (new Buffer('DecryptedValue2')).toString('base64') });
assert.fail('Unrecognized encrypted value ' + encrypted);
});
var env = {
AWS_DEFAULT_REGION: 'us-east-1',
SecureVarA: 'secure:' + (new Buffer('EncryptedValue1')).toString('base64'),
SecureVarB: 'secure:' + (new Buffer('EncryptedValue2')).toString('base64'),
NormalVarC: 'Hello World'
};
dke(env, function(err, output) {
assert.ifError(err, 'no error');
assert.deepEqual(env, {
AWS_DEFAULT_REGION: 'us-east-1',
SecureVarA: 'DecryptedValue1',
SecureVarB: 'DecryptedValue2',
NormalVarC: 'Hello World'
}, 'Sets decrypted values');
assert.deepEqual(output, {
SecureVarA: '************lue1',
SecureVarB: '************lue2',
}, 'Debug output');
assert.end();
});
});
beforeEach(() => {
AWS.mock('S3', 'getObject', (params, callback) => {
const json = JSON.stringify(UPDATED_1707);
const data = { Body: json };
callback(null, data);
});
AWS.mock('S3', 'putObject', (params, callback) => {
addData.push(params.Key);
callback(null, null);
});
AWS.mock('S3', 'deleteObjects', (params, callback) => {
deleteData.push(params);
callback(null, null);
});
clock = sinon.useFakeTimers(new Date('2017-08-20T00:00:00+09:00').getTime());
});
before(() => {
AWS.mock('IAM', 'getRole', (params, callback) => {
callback(getRoleError, getRole);
});
AWS.mock('IAM', 'createRole', (params, callback) => {
callback(null, createRole);
});
AWS.mock('IAM', 'updateAssumeRolePolicy', (params, callback) => {
callback(null, updateAssumeRolePolicy);
});
AWS.mock('IAM', 'attachRolePolicy', (params, callback) => {
callback(null, attachRolePolicy);
});
AWS.mock('IAM', 'listPolicies', (params, callback) => {
callback(null, listPolicies);
});
});
it('putItem', () => {
AWS.mock('DynamoDB', 'putItem', (params, callback) => {
callback(null, 'successfully put item in database');
});
return new Users('Table').putData().then((res) => {
res.should.equal('successfully put item in database');
});
})
before(() => {
awsMock.mock('S3', 'getObject', {
Body: `email address;first name;last name
em1@examplemail.com;firstName1;lastName1
em2@examplemail.com;firstName2;lastName2`,
Metadata: {
headers: '{"email address":"email", "first name":"name","last name":"surname", "some-header":"false", "other-header":false}'
}
});
sinon.stub(List, 'update').resolves('Ok');
sinon.stub(Recipient, 'saveAll').resolves('Ok');
awsMock.mock('Lambda', 'invoke', 'ok');
lambdaClient = new AWS.Lambda();
s3Client = new AWS.S3();
awsMock.mock('SNS', 'publish');
sns = new AWS.SNS();
process.env.UPDATE_IMPORT_STATUS_TOPIC_ARN = 'update-import-topic-arn';
});
before(() => {
awsMock.mock('SES', 'getSendQuota', cb => {
const error = {
message: 'The security token included in the request is invalid.',
code: 'InvalidClientTokenId',
statusCode: 403
};
return cb(error);
});
});
it('getItem', () => {
const input = '*****@*****.**';
AWS.mock('DynamoDB', 'getItem', (params, callback) => {
callback(null, { Item: { email: params.Key.email.S } });
});
return new Users('Table').getData(input).then((res) => {
res.Item.email.should.equal(input);
});
})
it('deleteItem', () => {
const input = '*****@*****.**';
AWS.mock('DynamoDB', 'deleteItem', (params, callback) => {
callback(null, 'successfully delete item in database');
});
return new Users('Table').deleteData(input).then((res) => {
res.should.equal('successfully delete item in database');
});
})
beforeEach(function() {
server.close();
server = makeServer(s);
util = new HttpTestUtils(server);
AWS.mock('KMS', 'decrypt', function(params, callback) {
callback(null, {
KeyId: 'arn:aws:kms:us-east-1:ACCOUNT:key/SOME-UUID',
PlainText: Buffer.from('this-is-a-secret', 'utf8').toString('base64')
});
});
});
const _mockSetting = () => {
awsMock.mock('CloudWatchEvents', 'putRule', (params, callback) => {
callback(null, {})
})
awsMock.mock('CloudWatchEvents', 'putTargets', (params, callback) => {
callback(null, {})
})
awsMock.mock('CloudWatchLogs', 'createLogGroup', (params, callback) => {
callback(null, {})
})
awsMock.mock('CloudWatchLogs', 'putRetentionPolicy', (params, callback) => {
callback(null, {})
})
awsMock.mock('S3', 'putBucketNotificationConfiguration', (params, callback) => {
callback(null, {})
})
awsMock.mock('S3', 'putObject', (params, callback) => {
callback(null, { 'test': 'putObject' })
})
Object.keys(lambdaMockSettings).forEach((method) => {
awsMock.mock('Lambda', method, (params, callback) => {
callback(null, lambdaMockSettings[method])
})
})
return require('aws-sdk')
}
beforeEach(function() {
aws.mock('APIGateway', 'createRestApi', function (params, callback){
let result = {
id: config.apiid,
name: config.apiname,
createdDate: Date.now()
}
callback(null, result);
})
apigw = new create.apigateway(config.region)
})
before(() => {
awsMock.mock('DynamoDB.DocumentClient', 'put', (params, cb) => {
if (params.hasOwnProperty('TableName')) {
cb(null, {});
} else {
cb('Invalid params');
}
});
awsMock.mock('DynamoDB.DocumentClient', 'batchWrite', (params, cb) => {
if (params.RequestItems.hasOwnProperty(validTable)) {
cb(null, {});
} else if (params.RequestItems.hasOwnProperty(retryableTable)) {
const result = { UnprocessedItems: {} };
result.UnprocessedItems[retryableTable] = [{ id: 'some-id' }];
cb(null, result);
} else {
cb('Invalid params');
}
});
db = new AWS.DynamoDB.DocumentClient();
sinon.stub(Model, '_db').returns(db);
});
before(() => {
awsMock.mock('SNS', 'publish', (params, cb) => {
if (params.hasOwnProperty('Message') && params.hasOwnProperty('TopicArn')) {
cb(null, { ReceiptHandle: 'STRING_VALUE' });
} else {
cb('Invalid params');
}
});
snsClient = new AWS.SNS();
service = new AttachRecipientsService(snsClient, campaignMessage);
sinon.stub(service, '_notifyAttachSegmentMembers').resolves(true);
sinon.stub(service, '_notifyToUpdateCampaignStatus').resolves(true);
sinon.stub(service, '_notifyToSendEmails').resolves(true);
sinon.stub(service, '_wait').resolves(true);
sinon.stub(service, '_notifyToSendSMS').resolves(true);
});
it('should return success when TA refresh is successful', function(done) {
AWS.mock('Support', 'refreshTrustedAdvisorCheck', function(
params,
callback
) {
callback(null, {
result: 'success',
});
});
let _taRefresh = new TARefresh();
_taRefresh.getTARefreshStatus(params, function(err, data) {
if (err) done('invalid failure for positive test: ', err);
else {
assert.equal(data.Result, 'TA refresh done');
done();
}
});
});
it('should return success logging which TA check failed', function(done) {
AWS.mock('Support', 'refreshTrustedAdvisorCheck', function(
params,
callback
) {
callback('error', null);
});
let _taRefresh = new TARefresh();
_taRefresh.getTARefreshStatus(params, function(err, data) {
if (err) {
//expect(err).to.equal('error');
done('invalid failure for negative test: ', err);
} else {
assert.equal(data.Result, 'TA refresh done');
done();
}
});
});
test.serial('getRowsByChatId with LastEvaluatedKey', async t => {
AWS.restore()
let i = 3
const stubObject = () => {
const obj = {
Items: ['dummy'],
LastEvaluatedKey: { d: 'ummy' }
}
if (i <= 0) { delete obj.LastEvaluatedKey }
i--
return obj
}
AWS.mock('DynamoDB.DocumentClient', 'query', (params, callback) => {
const obj = stubObject()
callback(null, obj)
})
const dynamodb = new DynamoDB()
const response = await dynamodb.getRowsByChatId({ chatId: 123 })
t.is(response[0], 'dummy')
})
tape('decrypt-kms-env: secure env vars', function(assert) {
AWS.mock('KMS', 'decrypt', function(params, callback) {
var encrypted = new Buffer(params.CiphertextBlob, 'base64').toString('utf8');
if (encrypted === 'EncryptedValue1')
return callback(null, { Plaintext: (new Buffer('DecryptedValue1')).toString('base64') });
if (encrypted === 'EncryptedValue2')
return callback(null, { Plaintext: (new Buffer('DecryptedValue2')).toString('base64') });
assert.fail('Unrecognized encrypted value ' + encrypted);
});
dke.sh({
AWS_DEFAULT_REGION: 'us-east-1',
SecureVarA: 'secure:' + (new Buffer('EncryptedValue1')).toString('base64'),
SecureVarB: 'secure:' + (new Buffer('EncryptedValue2')).toString('base64'),
NormalVarC: 'Hello World'
}, function(err, output) {
assert.ifError(err, 'no error');
assert.deepEqual(output, 'export SecureVarA=\'DecryptedValue1\'; echo \'Decrypted SecureVarA=************lue1\'; export SecureVarB=\'DecryptedValue2\'; echo \'Decrypted SecureVarB=************lue2\'; ', 'shell output');
assert.end();
});
});
it('bubbles errors up to the caller', function(done) {
AWS.restore();
AWS.mock('KMS', 'decrypt', function(params, callback) {
callback(new Error('Funky looking error message'), null);
});
util.testEndpointResponse(endpoint, 'POST', STATUS_CODES.BAD_REQUEST, JSON.stringify(body), requiredHeaders, (err, res) => {
if (err) {
return done(err);
}
res.body.should.eql({
error: {
message: 'Funky looking error message',
name: 'Error'
}
});
done();
});
});
before(function () {
AWS.mock("S3", "getObject", function (params, callback) {
callback(null, "dummy-data");
});
});
before(() => {
awsMock.mock('SNS', 'publish', {});
busClient = new AWS.SNS();
});
before(() => {
awsMock.mock('SNS', 'publish', {ReceiptHandle: 'STRING_VALUE'});
snsClient = new AWS.SNS();
});
before(() => {
awsMock.mock('SES', 'sendEmail', { MessageId: 'some_message_id' });
const sqsMessage = sqsMessages.Messages[0];
email = new EnqueuedEmail(JSON.parse(sqsMessage.Body), sqsMessage.ReceiptHandle);
});
before(() => {
senderService = new SendEmailService(queue, null, contextStub);
awsMock.mock('SES', 'sendEmail', { MessageId: 'some_message_id' });
});