add eslint, implement set, get, del,reset, extend unit test

Author: disjunction

.eslintrc

@@ -0,0 +1,44 @@
+{
+    "globals": {
+    },
+    "env": {
+        "node": true,
+        "es6": true
+    },
+
+    "extends": "eslint:recommended",
+
+    "rules": {
+        "no-cond-assign": 0,
+        "no-constant-condition": 0,
+        "no-empty": 0,
+        "no-fallthrough": 0,
+        "no-unused-vars": 1,
+        "no-console": 1,
+
+        "semi": 2,
+        "curly": 2,
+        "consistent-this": [2, "self"],
+        "indent": [ 2, 4, { "SwitchCase": 1 } ],
+        "linebreak-style": [2, "unix"],
+        "no-nested-ternary": 2,
+
+        "new-parens": 2,
+        "no-dupe-class-members": 2,
+        "require-yield": 2,
+        "arrow-spacing": 1,
+        "no-var": 2,
+
+        "no-multi-spaces": 1,
+        "space-return-throw-case": 1,
+        "space-infix-ops": [1, {"int32Hint": false}],
+        "brace-style": 1,
+        "space-before-blocks": 1,
+        "operator-linebreak": [1, "before"],
+        "no-unneeded-ternary": 1,
+        "no-lonely-if": 1,
+        "key-spacing": 1,
+        "quotes": [1, "double", "avoid-escape"],
+        "no-trailing-spaces": [1, { "skipBlankLines": true }]
+    }
+}

Makefile

@@ -3,4 +3,6 @@
 default: test
 
 test:
-	./node_modules/.bin/mocha
+	./node_modules/.bin/mocha
+lint:
+	node_modules/eslint/bin/eslint.js .

package.json

@@ -11,6 +11,7 @@
   "devDependencies": {
     "cache-manager": "^1.4.0",
     "chai": "^3.5.0",
+    "eslint": "^1.10.3",
     "mocha": "^2.4.5",
     "mongoose-mock": "^0.4.0",
     "proxyquire": "^1.7.4",

src/index.js

@@ -1,33 +1,21 @@
 "use strict";
 
-const mongoose = require("mongoose");
-
-
-const schemaTemplate = {
-    obj: {
-        _id: String,
-        val: mongoose.Schema.Types.Mixed,
-        exp: Number
-    }, 
-    options: {
-        collection: "cacheman",
-        versionKey: false
-    }
-};
-
-const EMPTY = {};
-
-class MongooseStoreError extends Error {};
+class MongooseStoreError extends Error {}
 
 class MongooseStore {
     constructor(args) {
+        if (!args) {
+            args = {};
+        }
+        this.mongoose = args.mongoose || require("mongoose");
+
         if (args.model) {
             switch (typeof args.model) {
                 case "object":
                     this.model = args.model;
                     break;
                 case "string":
-                    this.model = mongoose.model(args.model);
+                    this.model = this.mongoose.model(args.model);
                     break;
                 default:
                     throw new MongooseStoreError("unexpected type of args.model in constructor");
@@ -39,12 +27,26 @@ class MongooseStore {
     }
 
     makeModel(args) {
+        const schemaTemplate = {
+            obj: {
+                _id: String,
+                val: this.mongoose.Schema.Types.Mixed,
+                exp: Number
+            },
+            options: {
+                collection: "cacheman",
+                versionKey: false
+            }
+        };
+
         const options = Object.assign({}, schemaTemplate.options, args.modelOptions);
-        const schema = new mongoose.Schema(
+        const schema = new this.mongoose.Schema(
             schemaTemplate.obj,
             options
         );
-        return mongoose.model(args.model, schema);
+
+        let model = this.mongoose.model(args.model || "MongooseCache", schema);
+        return model;
     }
 
     result(fn, error, result) {
@@ -54,7 +56,24 @@ class MongooseStore {
     }
 
     get(key, options, fn) {
-        return this.model.findOne({_id: key})
+        try {
+            return this.model.findOne(
+                {_id: key}
+            )
+            .then(record => {
+                if (!record) {
+                    return this.result(fn);
+                }
+                if (record.exp < Date.now()) {
+                    return this.del(key, null, fn);
+                } else {
+                    return this.result(fn, null, record.val);
+                }
+            })
+            .catch(e => this.result(fn, e));
+        } catch (e) {
+            this.result(fn, e);
+        }
     }
 
     set(key, val, options, fn) {
@@ -69,26 +88,40 @@ class MongooseStore {
                     exp: Date.now() + ttl * 1000
                 },
                 {upsert: true}
-            ).then(() => {
-                this.result(fn);
-            }).catch(e => {
-                this.result(fn, e)
-            });
+            )
+            .then(() => this.result(fn))
+            .catch(e => this.result(fn, e));
         } catch (e) {
-            this.result(fn, e)
+            this.result(fn, e);
         }
     }
 
     del(key, options, fn) {
-
+        try {
+            return this.model.remove(
+                {_id: key}
+            )
+            .then(() => this.result(fn));
+        } catch (e) {
+            this.result(fn, e);
+        }
     }
 
     reset(key, fn) {
+        try {
+            if ("function" === typeof key) {
+                fn = key;
+                key = null;
+            }
+            return this.model.remove({}).then(() => fn());
+        } catch (e) {
+            this.result(fn, e);
+        }
     }
 }
 
 module.exports = {
-  create : function (args) {
-    return new MongooseStore(args);
-  }
+    create: function (args) {
+        return new MongooseStore(args);
+    }
 };

test/indexSpec.js

@@ -1,3 +1,4 @@
+/* eslint-env mocha */
 "use strict";
 
 let mongoose = require("mongoose-mock"),
@@ -40,15 +41,51 @@ describe("cache-manager-mongoose", function() {
         expect(cache.store.model).not.to.be.undefined;
     });
 
-    it("set saves key, value, expires record", sinon.test(function(done) {
+    it("set calls update", sinon.test(function(done) {
         let cache = cm.caching({
             store: cmm,
             model: modelStub
         });
-        cache.set("someKey", "someValue", null, function (err, result) {
+        let spy = this.stub(modelStub, "update");
+        cache.set("someKey", "someValue", null, function () {
+            sinon.assert.calledOnce(spy);
+            done();
+        });
+    }));
+
+    it("get calls findOne", sinon.test(function(done) {
+        let cache = cm.caching({
+            store: cmm,
+            model: modelStub
+        });
+        let spy = this.stub(modelStub, "findOne");
+        cache.get("someKey", null, function () {
+            sinon.assert.calledOnce(spy);
+            done();
+        });
+    }));
+
+    it("del calls remove", sinon.test(function(done) {
+        let cache = cm.caching({
+            store: cmm,
+            model: modelStub
+        });
+        let spy = this.stub(modelStub, "remove");
+        cache.del("someKey", null, function () {
+            sinon.assert.calledOnce(spy);
+            done();
+        });
+    }));
+
+    it("reset calls remove", sinon.test(function(done) {
+        let cache = cm.caching({
+            store: cmm,
+            model: modelStub
+        });
+        let spy = this.stub(modelStub, "remove");
+        cache.reset(function () {
+            sinon.assert.calledOnce(spy);
             done();
         });
-        let updateSpy = sinon.stub(modelStub, "update");
-        sinon.assert.calledOnce(updateSpy);
     }));
 });