updated package.json

node_modules/nconf/test/stores/argv-test.js

@@ -0,0 +1,22 @@
+/*
+ * argv-test.js: Tests for the nconf argv store.
+ *
+ * (C) 2011, Nodejitsu Inc.
+ *
+ */
+
+var vows = require('vows'),
+    assert = require('assert'),
+    helpers = require('../helpers'),
+    nconf = require('../../lib/nconf');
+
+vows.describe('nconf/stores/argv').addBatch({
+  "An instance of nconf.Argv": {
+    topic: new nconf.Argv(),
+    "should have the correct methods defined": function (argv) {
+      assert.isFunction(argv.loadSync);
+      assert.isFunction(argv.loadArgv);
+      assert.isFalse(argv.options);
+    }
+  }
+}).export(module);

node_modules/nconf/test/stores/env-test.js

@@ -0,0 +1,24 @@
+/*
+ * env-test.js: Tests for the nconf env store.
+ *
+ * (C) 2011, Nodejitsu Inc.
+ *
+ */
+
+var vows = require('vows'),
+    assert = require('assert'),
+    helpers = require('../helpers'),
+    nconf = require('../../lib/nconf');
+
+vows.describe('nconf/stores/env').addBatch({
+  "An instance of nconf.Env": {
+    topic: new nconf.Env(),
+    "should have the correct methods defined": function (env) {
+      assert.isFunction(env.loadSync);
+      assert.isFunction(env.loadEnv);
+      assert.isArray(env.whitelist);
+      assert.lengthOf(env.whitelist, 0);
+      assert.equal(env.separator, '');
+    }
+  }
+}).export(module);

node_modules/nconf/test/stores/file-store-test.js

@@ -0,0 +1,226 @@
+/*
+ * file-store-test.js: Tests for the nconf File store.
+ *
+ * (C) 2011, Nodejitsu Inc.
+ *
+ */
+
+var fs = require('fs'),
+    path = require('path'),
+    vows = require('vows'),
+    assert = require('assert'),
+    nconf = require('../../lib/nconf'),
+    data = require('../fixtures/data').data,
+    store;
+
+vows.describe('nconf/stores/file').addBatch({
+  "When using the nconf file store": {
+    "with a valid JSON file": {
+      topic: function () {
+        var filePath = path.join(__dirname, '..', 'fixtures', 'store.json');
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+        this.store = store = new nconf.File({ file: filePath });
+        return null;
+      },
+      "the load() method": {
+        topic: function () {
+          this.store.load(this.callback);
+        },
+        "should load the data correctly": function (err, data) {
+          assert.isNull(err);
+          assert.deepEqual(data, this.store.store);
+        }
+      }
+    },
+    "with a malformed JSON file": {
+      topic: function () {
+        var filePath = path.join(__dirname, '..', 'fixtures', 'malformed.json');
+        this.store = new nconf.File({ file: filePath });
+        return null;
+      },
+      "the load() method with a malformed JSON config file": {
+        topic: function () {
+          this.store.load(this.callback.bind(null, null));
+        },
+        "should respond with an error and indicate file name": function (_, err) {
+          assert.isTrue(!!err);
+          assert.match(err, /malformed\.json/);
+        }
+      }
+    },
+    "with a valid UTF8 JSON file that contains a BOM": {
+      topic: function () {
+        var filePath = path.join(__dirname, '..', 'fixtures', 'bom.json');
+        this.store = store = new nconf.File({ file: filePath });
+        return null;
+      },
+      "the load() method": {
+        topic: function () {
+          this.store.load(this.callback);
+        },
+        "should load the data correctly": function (err, data) {
+          assert.isNull(err);
+		      assert.deepEqual(data, this.store.store);
+        }
+      },
+      "the loadSync() method": {
+        topic: function () {
+          var data = this.store.loadSync();
+          return data;
+        },
+        "should load the data correctly": function (result) {
+          assert.deepEqual(result, this.store.store);
+        }
+      }
+    },
+    "with a valid UTF8 JSON file that contains no BOM": {
+      topic: function () {
+        var filePath = path.join(__dirname, '..', 'fixtures', 'no-bom.json');
+        this.store = store = new nconf.File({ file: filePath });
+        return null;
+      },
+      "the load() method": {
+        topic: function () {
+          this.store.load(this.callback);
+        },
+        "should load the data correctly": function (err, data) {
+          assert.isNull(err);
+          assert.deepEqual(data, this.store.store);
+        }
+      },
+      "the loadSync() method": {
+        topic: function () {
+          var data = this.store.loadSync();
+          return data;
+        },
+        "should load the data correctly": function (result) {
+          assert.deepEqual(result, this.store.store);
+        }
+      }
+    }
+  }
+}).addBatch({
+  "When using the nconf file store": {
+    topic: function () {
+      var tmpPath = path.join(__dirname, '..', 'fixtures', 'tmp.json'),
+          tmpStore = new nconf.File({ file: tmpPath });
+      return tmpStore;
+    },
+    "the save() method": {
+      topic: function (tmpStore) {
+        var that = this;
+        
+        Object.keys(data).forEach(function (key) {
+          tmpStore.set(key, data[key]);
+        });        
+        
+        tmpStore.save(function () {
+          fs.readFile(tmpStore.file, function (err, d) {
+            fs.unlinkSync(tmpStore.file);
+
+            return err
+              ? that.callback(err)
+              : that.callback(err, JSON.parse(d.toString()));
+          });
+        });
+      },
+      "should save the data correctly": function (err, read) {
+        assert.isNull(err);
+        assert.deepEqual(read, data);
+      }
+    }
+  }
+}).addBatch({
+  "When using the nconf file store": {
+    topic: function () {
+      var tmpPath = path.join(__dirname, '..', 'fixtures', 'tmp.json'),
+          tmpStore = new nconf.File({ file: tmpPath });
+      return tmpStore;
+    },
+    "the saveSync() method": {
+      topic: function (tmpStore) {
+        var that = this;
+
+        Object.keys(data).forEach(function (key) {
+          tmpStore.set(key, data[key]);
+        });
+
+        var saved = tmpStore.saveSync();
+
+        fs.readFile(tmpStore.file, function (err, d) {
+          fs.unlinkSync(tmpStore.file);
+
+          return err
+            ? that.callback(err)
+            : that.callback(err, JSON.parse(d.toString()), saved);
+        });
+      },
+      "should save the data correctly": function (err, read, saved) {
+        assert.isNull(err);
+        assert.deepEqual(read, data);
+        assert.deepEqual(read, saved);
+      }
+    }
+  }
+}).addBatch({
+  "When using the nconf file store": {
+    "the set() method": {
+      "should respond with true": function () {
+        assert.isTrue(store.set('foo:bar:bazz', 'buzz'));
+        assert.isTrue(store.set('falsy:number', 0));
+        assert.isTrue(store.set('falsy:string', ''));
+        assert.isTrue(store.set('falsy:boolean', false));
+        assert.isTrue(store.set('falsy:object', null));
+      }
+    },
+    "the get() method": {
+      "should respond with the correct value": function () {
+        assert.equal(store.get('foo:bar:bazz'), 'buzz');
+        assert.equal(store.get('falsy:number'), 0);
+        assert.equal(store.get('falsy:string'), '');
+        assert.equal(store.get('falsy:boolean'), false);
+        assert.equal(store.get('falsy:object'), null);
+      }
+    },
+    "the clear() method": {
+      "should respond with the true": function () {
+        assert.equal(store.get('foo:bar:bazz'), 'buzz');
+        assert.isTrue(store.clear('foo:bar:bazz'));
+        assert.isTrue(typeof store.get('foo:bar:bazz') === 'undefined');
+      }
+    }
+  }
+}).addBatch({
+  "When using the nconf file store": {
+    "the search() method": {
+      "when the target file exists higher in the directory tree": {
+        topic: function () {
+          var filePath = this.filePath = path.join(process.env.HOME, '.nconf');
+          fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+          return new (nconf.File)({
+            file: '.nconf'
+          })
+        },
+        "should update the file appropriately": function (store) {
+          store.search();
+          assert.equal(store.file, this.filePath);
+          fs.unlinkSync(this.filePath);
+        }
+      },
+      "when the target file doesn't exist higher in the directory tree": {
+        topic: function () {
+          var filePath = this.filePath = path.join(__dirname, '..', 'fixtures', 'search-store.json');
+          return new (nconf.File)({
+            dir: path.dirname(filePath),
+            file: 'search-store.json'
+          })
+        },
+        "should update the file appropriately": function (store) {
+          store.search();
+          assert.equal(store.file, this.filePath);
+        }
+      }
+    }
+  }
+}).export(module);
+

node_modules/nconf/test/stores/literal-test.js

@@ -0,0 +1,31 @@
+/*
+ * literal-test.js: Tests for the nconf literal store.
+ *
+ * (C) 2011, Nodejitsu Inc.
+ *
+ */
+
+var vows = require('vows'),
+    assert = require('assert'),
+    helpers = require('../helpers'),
+    nconf = require('../../lib/nconf');
+
+vows.describe('nconf/stores/literal').addBatch({
+  "An instance of nconf.Literal": {
+    topic: new nconf.Literal({
+      foo: 'bar',
+      one: 2
+    }),
+    "should have the correct methods defined": function (literal) {
+      assert.equal(literal.type, 'literal');
+      assert.isFunction(literal.get);
+      assert.isFunction(literal.set);
+      assert.isFunction(literal.merge);
+      assert.isFunction(literal.loadSync);
+    },
+    "should have the correct values in the store": function (literal) {
+      assert.equal(literal.store.foo, 'bar');
+      assert.equal(literal.store.one, 2);
+    }
+  }
+}).export(module);

node_modules/nconf/test/stores/memory-store-test.js

@@ -0,0 +1,108 @@
+/*
+ * memory-store-test.js: Tests for the nconf Memory store.
+ *
+ * (C) 2011, Nodejitsu Inc.
+ *
+ */
+
+var vows = require('vows'),
+    assert = require('assert'),
+    nconf = require('../../lib/nconf'),
+    merge = require('../fixtures/data').merge;
+
+vows.describe('nconf/stores/memory').addBatch({
+  "When using the nconf memory store": {
+    topic: new nconf.Memory(),
+    "the set() method": {
+      "should respond with true": function (store) {
+        assert.isTrue(store.set('foo:bar:bazz', 'buzz'));
+        assert.isTrue(store.set('falsy:number', 0));
+        assert.isTrue(store.set('falsy:string:empty', ''));
+        assert.isTrue(store.set('falsy:string:value', 'value'));
+        assert.isTrue(store.set('falsy:boolean', false));
+        assert.isTrue(store.set('falsy:object', null));
+      }
+    },
+    "the get() method": {
+      "should respond with the correct value": function (store) {
+        assert.equal(store.get('foo:bar:bazz'), 'buzz');
+        assert.equal(store.get('falsy:number'), 0);
+        assert.equal(store.get('falsy:string:empty'), '');
+        assert.equal(store.get('falsy:string:value'), 'value');
+        assert.equal(store.get('falsy:boolean'), false);
+        assert.equal(store.get('falsy:object'), null);
+      },
+      "should not fail when retrieving non-existent keys": {
+        "at the root level": function (store) {
+          assert.doesNotThrow(function() {
+            assert.equal(store.get('this:key:does:not:exist'), undefined);
+          }, TypeError);
+        },
+        "within numbers": function (store) {
+          assert.doesNotThrow(function() {
+            assert.equal(store.get('falsy:number:not:exist'), undefined);
+          }, TypeError);
+        },
+        "within booleans": function (store) {
+          assert.doesNotThrow(function() {
+            assert.equal(store.get('falsy:boolean:not:exist'), undefined);
+          }, TypeError);
+        },
+        "within objects": function (store) {
+          assert.doesNotThrow(function() {
+            assert.equal(store.get('falsy:object:not:exist'), undefined);
+          }, TypeError);
+        },
+        "within empty strings": function (store) {
+          assert.doesNotThrow(function() {
+            assert.equal(store.get('falsy:string:empty:not:exist'), undefined);
+          }, TypeError);
+        },
+        "within non-empty strings": function (store) {
+          assert.doesNotThrow(function() {
+            assert.equal(store.get('falsy:string:value:not:exist'), undefined);
+          }, TypeError);
+        }
+      }
+    },
+    "the clear() method": {
+      "should respond with the true": function (store) {
+        assert.equal(store.get('foo:bar:bazz'), 'buzz');
+        assert.isTrue(store.clear('foo:bar:bazz'));
+        assert.isTrue(typeof store.get('foo:bar:bazz') === 'undefined');
+      }
+    },
+    "the merge() method": {
+      "when overriding an existing literal value": function (store) {
+        store.set('merge:literal', 'string-value');
+        store.merge('merge:literal', merge);
+        assert.deepEqual(store.get('merge:literal'), merge);
+      },
+      "when overriding an existing Array value": function (store) {
+        store.set('merge:array', [1,2,3,4]);
+        store.merge('merge:array', merge);
+        assert.deepEqual(store.get('merge:literal'), merge);
+      },
+      "when merging into an existing Object value": function (store) {
+        store.set('merge:object', {
+          prop1: 2, 
+          prop2: 'prop2',
+          prop3: {
+            bazz: 'bazz'
+          },
+          prop4: ['foo', 'bar']
+        });
+        store.merge('merge:object', merge);
+
+        assert.equal(store.get('merge:object:prop1'), 1);
+        assert.equal(store.get('merge:object:prop2').length, 3);
+        assert.deepEqual(store.get('merge:object:prop3'), {
+          foo: 'bar',
+          bar: 'foo',
+          bazz: 'bazz'
+        });
+        assert.equal(store.get('merge:object:prop4').length, 2);        
+      }
+    }
+  }
+}).export(module);