added more tests

Author: Imran

.vscode/launch.json

@@ -0,0 +1,21 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Run tests",
+      "type": "node",
+      "request": "launch",
+      "program": "${workspaceRoot}/node_modules/mocha/bin/_mocha",
+      "args": [
+        "test/**/*.js",
+        "-t",
+        "60000",
+        "--color"
+      ],
+      "env": {
+        "AWS_REGION": "eu-west-2"
+      },
+      "cwd": "${workspaceRoot}"
+    },
+  ]
+}

package-lock.json

@@ -4,7 +4,7 @@
   "description": "A Serverless v1.x plugin that will add a global table and replica region for all tables deployed in a serverless stack.",
   "main": "src/index.js",
   "scripts": {
-    "test": "mocha test"
+    "test": "mocha test -t 4000"
   },
   "repository": {
     "type": "git",
@@ -28,7 +28,10 @@
   "devDependencies": {
     "aws-sdk-mock": "^4.3.0",
     "chai": "^4.1.2",
+    "chai-as-promised": "^7.1.1",
     "eslint": "^5.6.0",
-    "mocha": "^5.2.0"
+    "mocha": "^5.2.0",
+    "sinon": "^7.2.2",
+    "sinon-chai": "^3.3.0"
   }
 }

package.json

@@ -2,90 +2,179 @@
 
 const CreateDynamoDBGlobalTables = require('../src/index.js');
 const AWSMock = require('aws-sdk-mock');
-require('chai').should();
+var chai = require('chai');
+var sinon = require('sinon');
+var sinonChai = require('sinon-chai');
+var chaiAsPromised = require('chai-as-promised');
+chai.should();
+chai.use(sinonChai);
+chai.use(chaiAsPromised);
 
 describe('Creating a global dynamodb tables', () => {
-  let serverless, options, plugin;
+  let serverless, plugin;
+  let createGlobalTables = sinon.stub().resolves();
+  let addReplicas = sinon.stub().resolves();
 
-  describe.only('when the stack does not contain any dynamodb tables', () => {
+  before(async () => {
+    AWSMock.mock('DynamoDB', 'createGlobalTable', createGlobalTables);
+    AWSMock.mock('DynamoDB', 'updateGlobalTable', addReplicas);
+  });
+
+  describe('when the stack does not contain any dynamodb tables', () => {
 
-    const createdGlobalTables = [];
-    const addedReplicas = [];
     before(async () => {
       serverless = given_a_serverless_stack_without_any_tables();
-      AWSMock.mock('DynamoDB', 'createGlobalTable', params => createdGlobalTables.push(params));
-      AWSMock.mock('DynamoDB', 'updateGlobalTable', params => addedReplicas.push(params));
       plugin = new CreateDynamoDBGlobalTables(serverless);
       await plugin.createGlobalTables();
     });
 
+    after(() => {
+      createGlobalTables.reset();
+      addReplicas.reset();
+    });
+
     it('does not create any global tables', () => {
-      createdGlobalTables.should.be.empty;
+      createGlobalTables.should.not.have.been.called;
     });
 
     it('does not add any replicas', () => {
-      addedReplicas.should.be.empty;
+      addReplicas.should.not.have.been.called;
     });
   });
 
-  describe('when the stack contains some dynamodb tables', () => {
+  describe('when the stack contains dynamodb tables that have not yet been deployed', () => {
 
-    before(() => {
+    before(async () => {
+      let createGlobalTables = sinon.stub().resolves();
+      let addReplicas = sinon.stub().resolves();
+      AWSMock.mock('DynamoDB', 'createGlobalTable', createGlobalTables);
+      AWSMock.mock('DynamoDB', 'updateGlobalTable', addReplicas);
       serverless = given_a_serverless_stack_with_some_tables();
-
       plugin = new CreateDynamoDBGlobalTables(serverless);
+      await plugin.createGlobalTables();
     });
 
-    it('enables them in the plugin', () => {
+    after(() => {
+      createGlobalTables.reset();
+      addReplicas.reset();
+    });
 
+    it('creates a global table for all table resource', () => {
+      createGlobalTables.should.have.been.calledTwice;
+    });
+
+    it('the first global table is created with a replication region', () => {
+      createGlobalTables.should.have.been.calledWith({
+        GlobalTableName: 'table-one',
+        ReplicationGroup: [{ RegionName: 'eu-west-2' }]
+      });
+    });
+
+    it('the second global table is created with a replication region', () => {
+      createGlobalTables.should.have.been.calledWith({
+        GlobalTableName: 'table-two',
+        ReplicationGroup: [{ RegionName: 'eu-west-2' }]
+      });
     });
   });
 
   describe('when the dynamodb global table already exists', () => {
 
-    before(() => {
+    before(async () => {
       serverless = given_a_serverless_stack_with_some_tables();
-      serverless.service.custom.apiGatewayCloudWatchSettings = { metricsEnabled: false };
-
+      createGlobalTables.rejects({ code: 'GlobalTableAlreadyExistsException' });
       plugin = new CreateDynamoDBGlobalTables(serverless);
+      await plugin.createGlobalTables();
+    });
+
+    after(() => {
+      createGlobalTables.reset();
+      addReplicas.reset();
+    });
+
+    it('adds a replica table for all table resource', () => {
+      addReplicas.should.have.been.calledTwice;
+    });
+
+    it('adds the first table replica to the existing global table', () => {
+      addReplicas.should.have.been.calledWith({
+        GlobalTableName: 'table-one',
+        ReplicaUpdates: [
+          { Create: { RegionName: 'eu-west-2' } }
+        ]
+      });
     });
 
-    it('disables them in the plugin', () => {
-      expect(plugin.metricsEnabled).to.be.false;
+    it('adds the second table replica to the existing global table', () => {
+      addReplicas.should.have.been.calledWith({
+        GlobalTableName: 'table-one',
+        ReplicaUpdates: [
+          { Create: { RegionName: 'eu-west-2' } }
+        ]
+      });
     });
   });
 
   describe('when the replication group already exists', () => {
 
-    before(() => {
+    before(async () => {
+      serverless = given_a_serverless_stack_with_some_tables();
+      addReplicas.rejects({ code: 'ReplicaAlreadyExistsException' });
+      plugin = new CreateDynamoDBGlobalTables(serverless);
+      await plugin.createGlobalTables();
+    });
+
+    after(() => {
+      createGlobalTables.reset();
+      addReplicas.reset();
+    });
+
+    it('attempts to add a replica table for all table resource', () => {
+      addReplicas.should.have.been.calledTwice;
+    });
+  });
 
+  describe('when an exception occurs creating the global table', () => {
+
+    before(async () => {
       serverless = given_a_serverless_stack_with_some_tables();
-      serverless.service.custom.apiGatewayCloudWatchSettings = { metricsEnabled: true };
-      options = { stage: 'test', region: 'us-east-1' };
+      createGlobalTables.rejects({ code: 'UnhandledException' });
+      plugin = new CreateDynamoDBGlobalTables(serverless);
+    });
 
-      plugin = new CreateDynamoDBGlobalTables(serverless, options);
+    after(() => {
+      createGlobalTables.reset();
+      addReplicas.reset();
     });
 
-    it('uses the stage option', () => {
-      expect(plugin.stage).to.equal(options.stage);
+    it('throws an exception', () => {
+      plugin.createGlobalTables().should.be.rejected;
     });
+  });
 
-    it('not use the provider stage', () => {
-      expect(plugin.stage).to.not.equal(serverless.service.provider.stage);
+  describe('when an exception occurs adding a replica table', () => {
+
+    before(async () => {
+      serverless = given_a_serverless_stack_with_some_tables();
+      addReplicas.rejects({ code: 'UnhandledException' });
+      plugin = new CreateDynamoDBGlobalTables(serverless);
     });
 
-    it('uses the region option', () => {
-      expect(plugin.region).to.equal(options.region);
+    after(() => {
+      createGlobalTables.reset();
+      addReplicas.reset();
     });
 
-    it('not use the provider region', () => {
-      expect(plugin.region).to.not.equal(serverless.service.provider.region);
+    it('throws an exception', () => {
+      plugin.createGlobalTables().should.be.rejected;
     });
   });
 });
 
+
 const given_a_serverless_stack_without_any_tables = () => ({
   getProvider: () => ({ getRegion: () => 'eu-west-2' }),
+  cli: { consoleLog: () => { } },
   service: {
     resources: {
       Resources: {
@@ -97,16 +186,21 @@ const given_a_serverless_stack_without_any_tables = () => ({
 
 const given_a_serverless_stack_with_some_tables = () => ({
   getProvider: () => ({ getRegion: () => 'eu-west-2' }),
+  cli: { consoleLog: () => { } },
   service: {
     resources: {
       Resources: {
         'table-one': {
-          TableName: 'table-one',
-          Type: 'AWS::DynamoDB::Table'
+          Type: 'AWS::DynamoDB::Table',
+          Properties: {
+            TableName: 'table-one'
+          }
         },
         'table-two': {
-          TableName: 'table-two',
-          Type: 'AWS::DynamoDB::Table'
+          Type: 'AWS::DynamoDB::Table',
+          Properties: {
+            TableName: 'table-two'
+          }
         }
       }
     }