Merge branch 'v1' into add-host-option

Author: rehrumesh

.travis.yml

@@ -4,8 +4,43 @@ node_js:
 
 sudo: false
 
+before_install:
+  - cd test
+  - mkdir sample-template
+  - cd sample-template
+  - npm init --yes
+
 install:
+  - npm install --save-dev serverless-offline 
+  - npm install -g [email protected]
+  - npm install aws-sdk
+  - npm install --save dynamodb-doc-client-wrapper
+  - serverless create --template aws-nodejs
+  - cd ..
+  - cd ..
+  - npm link
+  - cd test/sample-template/node_modules
+  - npm link serverless-dynamodb-local
+  - cd ..
+  - sed -i '18 a plugins:' serverless.yml
+  - sed -i '19 a - serverless-offline' serverless.yml
+  - sed -i '20 a - serverless-dynamodb-local' serverless.yml
+  - cd ..
+  - cd ..
+  - npm install --save-dev mocha
+  - npm install --save-dev should
+  - npm install --save expect
+  - npm install --save request
+  - npm install --save chai
   - travis_retry npm install
+  - cd test/sample-template
 
+before_script:
+  - sls dynamodb install
+  - sls dynamodb start -p 3000 & 
+  - cd .. 
+  - cd ..
+  - npm run test
+  
 script:
-  - npm test
+  - npm test

README.md

@@ -65,6 +65,8 @@ custom:
       inMemory: true
       migrate: true
       seed: true
+    # Uncomment only if you already have a DynamoDB running locally
+    # noStart: true
 ```
 
 ##  Migrations: sls dynamodb migrate

index.js

@@ -66,6 +66,11 @@ class ServerlessDynamodbLocal {
                             }
                         }
                     },
+                    noStart: {
+                      shortcut: "n",
+                      default: false,
+                      usage: "Do not start DynamoDB local (in case it is already running)",
+                    },
                     remove: {
                         lifecycleEvents: ["removeHandler"],
                         usage: "Removes local DynamoDB"
@@ -157,30 +162,60 @@ class ServerlessDynamodbLocal {
             config && config.start,
             this.options
         );
-
-        dynamodbLocal.start(options);
+        if (!options.noStart) {
+          dynamodbLocal.start(options);
+        }
         return BbPromise.resolve()
         .then(() => options.migrate && this.migrateHandler())
         .then(() => options.seed && this.seedHandler());
     }
 
     endHandler() {
-        this.serverlessLog('DynamoDB - stopping local database');
-        dynamodbLocal.stop(this.port);
+        if (!this.options.noStart) {
+            this.serverlessLog("DynamoDB - stopping local database");
+            dynamodbLocal.stop(this.port);
+        }
     }
 
-    /**
-     * Gets the table definitions
-     */
-    get tables() {
-        const resources = this.service.resources.Resources;
+    getDefaultStack() {
+        return _.get(this.service, "resources");
+    }
+
+    getAdditionalStacks() {
+        return _.values(_.get(this.service, "custom.additionalStacks", {}));
+    }
+
+    hasAdditionalStacksPlugin() {
+        return _.get(this.service, "plugins", []).includes("serverless-plugin-additional-stacks");
+    }
+
+    getTableDefinitionsFromStack(stack) {
+        const resources = _.get(stack, "Resources", []);
         return Object.keys(resources).map((key) => {
             if (resources[key].Type === "AWS::DynamoDB::Table") {
                 return resources[key].Properties;
             }
         }).filter((n) => n);
     }
 
+    /**
+     * Gets the table definitions
+     */
+    get tables() {
+        let stacks = [];
+
+        const defaultStack = this.getDefaultStack();
+        if (defaultStack) {
+            stacks.push(defaultStack);
+        }
+
+        if (this.hasAdditionalStacksPlugin()) {
+            stacks = stacks.concat(this.getAdditionalStacks());
+        }
+
+        return stacks.map((stack) => this.getTableDefinitionsFromStack(stack)).reduce((tables, tablesInStack) => tables.concat(tablesInStack), []);
+    }
+
     /**
      * Gets the seeding sources
      */

package.json

@@ -1,6 +1,6 @@
 {
     "name": "serverless-dynamodb-local",
-    "version": "0.2.22",
+    "version": "0.2.24",
     "engines": {
         "node": ">=4.0"
     },
@@ -12,29 +12,34 @@
         "url": "https://github.com/99xt/serverless-dynamodb-local"
     },
     "keywords": [
-    "serverless framework plugin",
-    "serverless applications",
-    "serverless plugins",
-    "api gateway",
-    "lambda",
-    "dynamodb",
-    "dynamodb local",
-    "aws",
-    "aws lambda",
-    "aws dynamodb",
-    "amazon",
-    "amazon web services",
-    "serverless.com"
-  ],
+        "serverless framework plugin",
+        "serverless applications",
+        "serverless plugins",
+        "api gateway",
+        "lambda",
+        "dynamodb",
+        "dynamodb local",
+        "aws",
+        "aws lambda",
+        "aws dynamodb",
+        "amazon",
+        "amazon web services",
+        "serverless.com"
+    ],
     "main": "index.js",
     "bin": {},
     "scripts": {
-        "test": "echo \"Warning: no test specified\" && exit 0"
+        "test": "mocha ./test"
     },
     "dependencies": {
         "aws-sdk": "^2.7.0",
         "bluebird": "^3.4.6",
         "dynamodb-localhost": "^0.0.5",
         "lodash": "^4.17.0"
+    },
+    "devDependencies": {
+        "chai": "^4.1.1",
+        "mocha": "^3.5.0",
+        "should": "^11.2.1"
     }
 }

test/indexTest.js

@@ -0,0 +1,68 @@
+"use strict";
+//Define the modules required to mocha testing
+const assert = require("chai").assert;
+const http = require ("http");
+const expect = require("chai").expect;
+const should = require("should");
+const aws = require ("aws-sdk");
+const seeder = require("../src/seeder.js");
+const dataApp = require("../index.js");
+
+describe("Port function",function(){
+  it("Port should return number",function(){
+    let myport = dataApp.prototype.port;
+    assert(typeof myport, "number");
+  });
+
+  it("Port value should be >= 0 and < 65536",function () {
+  http.get(`http://localhost:${dataApp.prototype.port}`, function (response) {
+    assert.equal(response.statusCode, 200);
+    });
+  });
+});
+
+describe("Check the dynamodb function",function(){
+  it("Endpoint should listen to the port",function () {
+     let server;
+     before(function () {
+      server = dynamodbOptions.listen(port);
+     });
+     after(function () {
+      assert.ok;
+     });
+    });
+
+  it("Should be an object",function(){
+    let dynamoOptions = dataApp.prototype.dynamodbOptions;
+    let raw = new aws.DynamoDB(dynamoOptions);
+    raw.should.be.type("object");
+  });
+  
+  it("Should be an object",function(){
+    let dynamoOptions =  dataApp.prototype.dynamodbOptions;
+    let doc = new aws.DynamoDB(dynamoOptions);
+    doc.should.be.type("object");
+  });
+});
+
+describe ("Start handler function",function(){
+  it ("Should not  be null",function(){
+    let handler = dataApp.prototype.startHandler;
+    assert(handler =! null);
+  });
+});
+
+
+describe ("createTable functon",function(){
+  it ("Should check as a function",function(){
+    const tbl = dataApp.prototype.createTable;
+    assert.equal(typeof tbl, "function");
+  });
+}); 
+
+describe ("Check the Seeder file",function(){
+  it("Table name shoud be a string",function(){
+    let tblName = seeder.writeSeeds.name;
+    expect(tblName).to.be.a("string");
+  });
+});

test/testItems.js

@@ -0,0 +1,120 @@
+"use strict";
+const assert = require("chai").assert;
+const http = require ("http");
+const expect = require("chai").expect;
+const should = require("should");
+const aws = require ("aws-sdk");
+
+aws.config.update({ accessKeyId: "localAccessKey", secretAccessKey: "localSecretAccessKey", region: "localRegion"});
+var db = new aws.DynamoDB({ endpoint: "http://localhost:8000" });
+var dbClient = new aws.DynamoDB.DocumentClient({ endpoint: "http://localhost:8000"});
+
+describe("#Add Items", function() {
+  this.timeout(50000);
+  it("should add item to table", function(done) {
+    {
+      var params = {
+        TableName:"MyMovie",
+        Item:{
+            "year": 2017,
+            "title": "Big Movie",
+            "info":{
+                "plot": "Nothing happens at all.",
+                "rating": 0
+            }            
+        }
+      };
+      dbClient.put(params, function(err, data) {
+        if (err) {
+          should.not.exist(data); 
+        } else {
+          assert.isNotNull(data.Attributes);
+          assert.isOk(true, "This will pass");
+        }
+        done();
+      });
+    };
+  });
+});
+
+describe("#Update Items", function(){
+  this.timeout(50000);
+  it("should update the items", function(done){
+    var params = {
+      TableName:"MyMovie",
+      Key:{
+          "year": 2017,
+          "title": "Big Movie"
+      },
+      UpdateExpression: "set info.rating = :r, info.plot=:p, info.actors=:a",
+      ExpressionAttributeValues:{
+        ":r":5.4,
+        ":p":"Everything happens all at once.",
+        ":a":["Steve", "Jonson", "Cethie"]
+      },
+      ReturnValues:"UPDATED_NEW"
+    };
+    dbClient.update(params, function(err,data){
+      if(err){
+        should.exist(err);
+      } else {
+      assert.isNotNull(data.Attributes);
+      assert.isOk(true, "This will pass");
+      }
+      done();
+    });  
+  });
+});
+
+describe("#Delete Items", function(){
+  this.timeout(50000);
+  it("should delete the items", function(done){
+    var params = {
+      TableName:"Movies10",
+      Key:{
+        "year":2017,
+        "title":"Big Movie"
+      },
+      ConditionExpression:"info.rating <= :val",
+      ExpressionAttributeValues: {
+        ":val": 5.0
+      }
+    };
+    dbClient.delete(params, function(err, data) {
+      if (err) {
+        should.exist(err); 
+      } else {
+        should.not.exist(data); 
+      }
+      done();
+    });
+  });
+});
+
+describe("#Retrieving from database",function(){
+  this.timeout(50000);
+  var params = {
+    TableName : "Movies10",
+    KeyConditionExpression: "#yr = :yyyy",
+    ExpressionAttributeNames:{
+      "#yr": "year"
+    },
+    ExpressionAttributeValues: {
+      ":yyyy":2017
+    }
+  };
+  
+  it ("Getting data from the table", function(done){
+    this.timeout(50000);
+    dbClient.query(params, function(err, data) {
+      if (err) {
+        should.exist(err); 
+      } else {
+        data.Items.forEach(function(item) {
+          assert.equal(item.year + ": " + item.title, "2017: Big Movie", "==Matching the values.");
+        });
+      }
+      done();
+    });
+  });
+});