TheThing
/
nconf-lite
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

Migrating a bunch of tests to ecmamodule

master
Jonatan Nilsson 2 years ago
parent
44a22ce6dd
commit
1104c0d3ad
15 changed files with 482 additions and 489 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      .circleci/config.yml
  2. 1
      .npmrc
  3. 6
      lib/nconf/provider.js
  4. 12
      package.json
  5. 66
      test/helpers.js
  6. 64
      test/helpers.mjs
  7. 64
      test/hierarchy.test.js
  8. 46
      test/hierarchy.test.mjs
  9. 13
      test/mocks/mock-store.js
  10. 108
      test/nconf.test.js
  11. 111
      test/nconf.test.mjs
  12. 31
      test/provider-save.test.js
  13. 26
      test/provider-save.test.mjs
  14. 198
      test/provider.test.js
  15. 223
      test/provider.test.mjs

2
.circleci/config.yml
View File

@ -17,8 +17,6 @@ commands:
- run:
name: Test
command: npm test
- coverage
- save-npm-cache
save-npm-cache:
steps:
- save_cache:

1
.npmrc
View File

@ -0,0 +1 @@
package-lock=false

6
lib/nconf/provider.js
View File

@ -229,7 +229,7 @@ Provider.prototype.get = function (key, callback) {
// the entire set of stores, but up until there is a defined value.
//
var current = 0,
names = Object.keys(this.stores),
names = Object.keys(this.stores).filter(x => x !== 'mock'),
self = this,
response,
mergeObjs = [];
@ -437,7 +437,7 @@ Provider.prototype.load = function (callback) {
function loadStoreSync(store) {
if (!store.loadSync) {
throw new Error('nconf store ' + store.type + ' has no loadSync() method');
throw new Error('nconf store "' + store.type + '" has no loadSync() method');
}
return store.loadSync();
@ -597,7 +597,7 @@ Provider.prototype._execute = function (action, syncLength /* [arguments] */) {
self = this,
response,
mergeObjs = [],
keys = Object.keys(this.stores);
keys = Object.keys(this.stores).filter(x => x !== 'mock');
function runAction (name, next) {

12
package.json
View File

@ -23,17 +23,11 @@
"ini": "^1.3.0"
},
"devDependencies": {
"coveralls": "^3.0.2",
"eslint": "^6.0.0",
"istanbul": "^0.4.1",
"jest": "^24.0.0",
"nconf-yaml": "^1.0.2"
"eltro": "^1.0.2"
},
"main": "./lib/nconf",
"main": "./lib/nconf.mjs",
"scripts": {
"test": "jest --verbose",
"cover": "jest --coverage",
"coveralls": "cat coverage/lcov.info | coveralls",
"test": "eltro test/**/*.test.mjs -r dot",
"lint": "eslint ."
},
"files": [

66
test/helpers.js
View File

@ -1,66 +0,0 @@
/*
* helpers.js: Test helpers for nconf.
*
* (C) 2011, Charlie Robbins and the Contributors.
*
*/
var spawn = require('child_process').spawn;
var fs = require('fs');
var path = require('path');
var nconf = require('../lib/nconf');
exports.assertMerged = function (err, merged) {
merged = merged instanceof nconf.Provider
? merged.store.store
: merged;
expect()
expect(err).toBeNull();
expect(typeof merged).toBe('object');
expect(merged.apples).toBeTruthy();
expect(merged.bananas).toBeTruthy();
expect(typeof merged.candy).toBe('object');
expect(merged.candy.something1).toBeTruthy();
expect(merged.candy.something2).toBeTruthy();
expect(merged.candy.something3).toBeTruthy();
expect(merged.candy.something4).toBeTruthy();
expect(merged.dates).toBeTruthy();
expect(merged.elderberries).toBeTruthy();
};
//FIXME TODO
exports.assertSystemConf = function (options) {
return done => {
var env = null;
if (options.env) {
env = {}
Object.keys(process.env).forEach(function (key) {
env[key] = process.env[key];
});
Object.keys(options.env).forEach(function (key) {
env[key] = options.env[key];
});
}
var child = spawn('node', [options.script].concat(options.argv), {env: env});
child.stdout.once('data', data => {
expect(data.toString()).toEqual('foobar');
done();
});
}
}
// copy a file
exports.cp = function (from, to, callback) {
fs.readFile(from, function (err, data) {
if (err) return callback(err);
fs.writeFile(to, data, callback);
});
};
exports.fixture = function (file) {
return path.join(__dirname, 'fixtures', file);
};

64
test/helpers.mjs
View File

@ -0,0 +1,64 @@
import { assert } from 'eltro'
import fs from 'fs'
import path from 'path'
import { exec as ex } from 'child_process'
import { fileURLToPath } from 'url'
import nconf from '../lib/nconf.js'
let __dirname = path.dirname(fileURLToPath(import.meta.url))
export function assertMerged(err, merged) {
merged = merged instanceof nconf.Provider
? merged.store.store
: merged;
assert.strictEqual(err, null)
assert.strictEqual(typeof(merged), 'object')
assert.ok(merged.apples)
assert.ok(merged.bananas)
assert.strictEqual(typeof(merged.candy), 'object')
assert.ok(merged.candy.something1)
assert.ok(merged.candy.something2)
assert.ok(merged.candy.something3)
assert.ok(merged.candy.something4)
assert.ok(merged.dates)
assert.ok(merged.elderberries)
};
// copy a file
export function cp(from, to) {
return new Promise(function(res, rej) {
fs.readFile(from, function (err, data) {
if (err) return rej(err);
fs.writeFile(to, data, function(err, data) {
if (err) return rej(err)
res(data)
});
});
})
};
export function exec(script, prefix = 'node') {
let command = `${prefix} ${script}`
return new Promise(function(res, rej) {
ex(command,
function (err, stdout, stderr) {
if (err) {
err.stdout = stdout
err.stderr = stderr
return rej(err)
}
res({
stdout,
stderr,
})
}
)
})
}
export function fixture(file) {
return path.resolve(path.join(__dirname, 'fixtures', file));
};

64
test/hierarchy.test.js
View File

@ -1,64 +0,0 @@
/*
* hierarchy-test.js: Basic tests for hierarchical file stores.
*
* (C) 2011, Charlie Robbins and the Contributors.
*
*/
var fs = require('fs');
var path = require('path');
var spawn = require('child_process').spawn;
var nconf = require('../lib/nconf');
var configDir = path.join(__dirname, 'fixtures', 'hierarchy');
var globalConfig = path.join(configDir, 'global.json');
var userConfig = path.join(configDir, 'user.json');
describe('nconf/hierarchy, When using nconf', () => {
it("configured with two file stores, should have the appropriate keys present", () => {
nconf.add('user', {type: 'file', file: userConfig});
nconf.add('global', {type: 'file', file: globalConfig});
nconf.load();
expect(nconf.get('title')).toEqual('My specific title');
expect(nconf.get('color')).toEqual('green');
expect(nconf.get('movie')).toEqual('Kill Bill');
});
it("configured with two file stores using `file` should have the appropriate keys present", () => {
nconf.file('user', userConfig);
nconf.file('global', globalConfig);
nconf.load();
expect(nconf.get('title')).toEqual('My specific title');
expect(nconf.get('color')).toEqual('green');
expect(nconf.get('movie')).toEqual('Kill Bill');
});
it("configured with .file(), .defaults() should deep merge objects should merge nested objects ", done => {
var script = path.join(__dirname, 'fixtures', 'scripts', 'nconf-hierarchical-defaults-merge.js');
var data = '';
var child = spawn('node', [script]);
child.stdout.on('data', function (d) {
data += d;
});
child.on('close', function () {
expect(JSON.parse(data)).toEqual({
candy: {
something: 'much better something for you',
something1: true,
something2: true,
something18: 'completely unique',
something5: {
first: 1,
second: 99
}
}
});
done();
});
})
})

46
test/hierarchy.test.mjs
View File

@ -0,0 +1,46 @@
import { Eltro as t, assert} from 'eltro'
import * as helpers from './helpers.mjs'
import nconf from '../lib/nconf.js'
var globalConfig = helpers.fixture('hierarchy/global.json');
var userConfig = helpers.fixture('hierarchy/user.json');
t.describe('nconf/hierarchy, When using nconf', function() {
t.test("configured with two file stores, should have the appropriate keys present", function() {
nconf.add('user', {type: 'file', file: userConfig});
nconf.add('global', {type: 'file', file: globalConfig});
nconf.load();
assert.strictEqual(nconf.get('title'), 'My specific title');
assert.strictEqual(nconf.get('color'), 'green');
assert.strictEqual(nconf.get('movie'), 'Kill Bill');
});
t.test("configured with two file stores using `file` should have the appropriate keys present", function() {
nconf.file('user', userConfig);
nconf.file('global', globalConfig);
nconf.load();
assert.strictEqual(nconf.get('title'), 'My specific title');
assert.strictEqual(nconf.get('color'), 'green');
assert.strictEqual(nconf.get('movie'), 'Kill Bill');
});
t.test("configured with .file(), .defaults() should deep merge objects should merge nested objects ", async function() {
var script = helpers.fixture('scripts/nconf-hierarchical-defaults-merge.js');
let res = await helpers.exec(script)
assert.deepEqual(JSON.parse(res.stdout), {
candy: {
something: 'much better something for you',
something1: true,
something2: true,
something18: 'completely unique',
something5: {
first: 1,
second: 99
}
}
});
})
})

13
test/mocks/mock-store.js
View File

@ -1,10 +1,3 @@
/*
* mock-store.js: Mock store for ensuring certain operations are actually called.
*
* (C) 2011, Charlie Robbins and the Contributors.
*
*/
var util = require('util'),
events = require('events'),
nconf = require('../../lib/nconf');
@ -35,4 +28,8 @@ Mock.prototype.save = function (value, callback) {
self.emit('save');
callback();
}, 1000);
};
};
Mock.prototype.loadSync = function() {
return {}
}

108
test/nconf.test.js
View File

@ -1,108 +0,0 @@
/*
* file-store-test.js: Tests for the nconf File store.
*
* (C) 2011, Charlie Robbins and the Contributors.
*
*/
var fs = require('fs');
var path = require('path');
var nconf = require('../lib/nconf');
describe('nconf, When using the nconf', () => {
it("should have the correct methods set", () => {
expect(typeof nconf.key).toBe('function');
expect(typeof nconf.path).toBe('function');
expect(typeof nconf.use).toBe('function');
expect(typeof nconf.any).toBe('function');
expect(typeof nconf.get).toBe('function');
expect(typeof nconf.set).toBe('function');
expect(typeof nconf.clear).toBe('function');
expect(typeof nconf.load).toBe('function');
expect(typeof nconf.save).toBe('function');
expect(typeof nconf.reset).toBe('function');
expect(typeof nconf.required).toBe('function');
});
it("the use() method should instaniate the correct store", () => {
nconf.use('memory');
nconf.load();
expect(nconf.stores['memory'] instanceof nconf.Memory).toBe(true);
});
it("nconf should have the correct version set", done => {
fs.readFile(path.join(__dirname, '..', 'package.json'), (err, data) => {
expect(err).toBe(null);
data = JSON.parse(data.toString());
expect(nconf.version).toEqual(data.version);
done();
})
});
describe("the required() method", () => {
it("should throw error with missing keys", () => {
nconf.set('foo:bar:bazz', 'buzz');
expect(nconf.required.bind(nconf, ['missing', 'foo:bar:bazz'])).toThrow(Error);
});
it("should return the provider if all required keys exist", () => {
var Provider = nconf.Provider;
nconf.set('foo:bar:bazz', 'buzz');
expect(nconf.required(['foo:bar:bazz']) instanceof Provider).toBe(true);
});
});
describe("with the memory store", () => {
describe("the set() method", () => {
it("should respond with true", () => {
expect(nconf.set('foo:bar:bazz', 'buzz')).toBeTruthy();
});
it("should respond allow access to the root and complain about non-objects", () => {
expect(nconf.set(null, null)).toBeFalsy();
expect(nconf.set(null, undefined)).toBeFalsy();
expect(nconf.set(null)).toBeFalsy();
expect(nconf.set(null, '')).toBeFalsy();
expect(nconf.set(null, 1)).toBeFalsy();
var original = nconf.get();
expect(nconf.set(null, nconf.get())).toBeTruthy();
expect(nconf.get()).not.toBe(original);
expect(nconf.get()).toEqual(original)
})
});
describe("the get() method", () => {
it("should respond with the correct value without a callback", () => {
expect(nconf.get('foo:bar:bazz')).toEqual('buzz');
})
it("should not step inside strings without a callback", () => {
expect(nconf.get('foo:bar:bazz:0')).toEqual(undefined);
});
it("should respond with the correct value with a callback", done => {
nconf.get('foo:bar:bazz', (err, value) => {
expect(value).toEqual('buzz');
done();
})
})
it("should respond allow access to the root", () => {
expect(nconf.get(null)).toBeTruthy();
expect(nconf.get(undefined)).toBeTruthy();
expect(nconf.get()).toBeTruthy();
})
});
describe("the clear() method", () => {
it("should respond with the true", () => {
expect(nconf.get('foo:bar:bazz')).toEqual('buzz');
expect(nconf.clear('foo:bar:bazz')).toBeTruthy();
expect(typeof nconf.get('foo:bar:bazz') === 'undefined').toBeTruthy();
})
})
describe("the load() method", () => {
it("should respond with the merged store without a callback", () => {
expect(nconf.load()).toEqual({"foo": {"bar": {}}});
});
it("should respond with the merged store", done => {
nconf.load((err, store) => {
expect(err).toBe(null);
expect(store).toEqual({"foo": {"bar": {}}});
done();
});
})
})
})
})

111
test/nconf.test.mjs
View File

@ -0,0 +1,111 @@
import fs from 'fs'
import path from 'path'
import { Eltro as t, assert} from 'eltro'
import nconf from '../lib/nconf.js'
import * as helpers from './helpers.mjs'
t.describe('nconf, When using the nconf', function() {
t.test("should have the correct methods set", function() {
assert.strictEqual(typeof(nconf.key), 'function')
assert.strictEqual(typeof(nconf.path), 'function')
assert.strictEqual(typeof(nconf.use), 'function')
assert.strictEqual(typeof(nconf.any), 'function')
assert.strictEqual(typeof(nconf.get), 'function')
assert.strictEqual(typeof(nconf.set), 'function')
assert.strictEqual(typeof(nconf.clear), 'function')
assert.strictEqual(typeof(nconf.load), 'function')
assert.strictEqual(typeof(nconf.save), 'function')
assert.strictEqual(typeof(nconf.reset), 'function')
assert.strictEqual(typeof(nconf.required), 'function')
})
t.test("the use() method should instaniate the correct store", function() {
nconf.use('memory')
nconf.load()
assert.ok(nconf.stores['memory'] instanceof nconf.Memory)
})
t.test("nconf should have the correct version set", function () {
let pckg = JSON.parse(fs.readFileSync(helpers.fixture('../../package.json')))
assert.ok(pckg.version)
assert.strictEqual(nconf.version, pckg.version)
})
t.describe("the required() method", function() {
t.test("should throw error with missing keys", function() {
nconf.set('foo:bar:bazz', 'buzz')
assert.throws(function() {
nconf.required(['missing', 'foo:bar:bazz'])
})
})
t.test("should return the provider if all required keys exist", function() {
var Provider = nconf.Provider
nconf.set('foo:bar:bazz', 'buzz')
assert.ok(nconf.required(['foo:bar:bazz']) instanceof Provider)
})
})
t.describe("with the memory store", function() {
t.describe("the set() method", function() {
t.test("should respond with true", function() {
assert.ok(nconf.set('foo:bar:bazz', 'buzz'))
})
t.test("should respond allow access to the root and complain about non-objects", function() {
assert.notOk(nconf.set(null, null))
assert.notOk(nconf.set(null, undefined))
assert.notOk(nconf.set(null))
assert.notOk(nconf.set(null, ''))
assert.notOk(nconf.set(null, 1))
var original = nconf.get()
assert.ok(nconf.set(null, nconf.get()))
assert.notStrictEqual(nconf.get(), original)
assert.deepEqual(nconf.get(), original)
})
})
t.describe("the get() method", function() {
t.test("should respond with the correct value without a callback", function() {
assert.strictEqual(nconf.get('foo:bar:bazz'), 'buzz')
})
t.test("should not step inside strings without a callback", function() {
assert.strictEqual(nconf.get('foo:bar:bazz:0'), undefined)
})
t.test("should respond with the correct value with a callback", function (done) {
nconf.get('foo:bar:bazz', (err, value) => {
try {
assert.strictEqual(value, 'buzz')
done()
} catch (leErr) {
done(leErr)
}
})
})
t.test("should respond allow access to the root", function() {
assert.ok(nconf.get(null))
assert.ok(nconf.get(undefined))
assert.ok(nconf.get())
})
})
t.describe("the clear() method", function() {
t.test("should respond with the true", function() {
assert.strictEqual(nconf.get('foo:bar:bazz'), 'buzz')
assert.ok(nconf.clear('foo:bar:bazz'))
assert.ok(typeof(nconf.get('foo:bar:bazz')) === 'undefined')
})
})
t.describe("the load() method", function() {
t.test("should respond with the merged store without a callback", function() {
assert.deepEqual(nconf.load(), {"foo": {"bar": {}}})
})
t.test("should respond with the merged store", function (done) {
nconf.load((err, store) => {
try {
assert.strictEqual(err, null)
assert.deepEqual(store, {"foo": {"bar": {}}})
done()
} catch (leErr) {
done(leErr)
}
})
})
})
})
})

31
test/provider-save.test.js
View File

@ -1,31 +0,0 @@
/*
* provider-save-test.js: Ensures consistency for Provider `save` operations.
*
* (C) 2011, Charlie Robbins and the Contributors.
*
*/
var nconf = require('../lib/nconf');
//
// Expose `nconf.Mock`
//
require('./mocks/mock-store');
describe('nconf/provider/save', () => {
describe("When using nconf an instance of 'nconf.Provider' with a Mock store", () => {
var nconfMock = nconf.use('mock');
it("the save() method should actually save before responding", done => {
var mock = nconf.stores.mock;
mock.on('save', function () {
nconfMock.saved = true;
});
nconf.save(() => {
expect(nconfMock.saved).toBeTruthy();
done();
});
})
})
});

26
test/provider-save.test.mjs
View File

@ -0,0 +1,26 @@
import { Eltro as t, assert} from 'eltro'
import nconf from '../lib/nconf.js'
import './mocks/mock-store.js'
t.describe('nconf/provider/save', () => {
t.describe("When using nconf an instance of 'nconf.Provider' with a Mock store", () => {
var nconfMock = nconf.use('mock');
t.test("the save() method should actually save before responding", function(done) {
var mock = nconf.stores.mock;
mock.on('save', function () {
nconfMock.saved = true;
});
nconf.save(() => {
try {
assert.strictEqual(nconfMock.saved, true)
done();
} catch (err) {
done(err)
}
});
})
})
});

198
test/provider.test.js
View File

@ -1,198 +0,0 @@
/*
* provider-test.js: Tests for the nconf Provider object.
*
* (C) 2011, Charlie Robbins and the Contributors.
*
*/
var fs = require('fs');
var path = require('path');
var helpers = require('./helpers');
var nconf = require('../lib/nconf');
var fixturesDir = path.join(__dirname, 'fixtures');
var mergeFixtures = path.join(fixturesDir, 'merge');
var files = [path.join(mergeFixtures, 'file1.json'), path.join(mergeFixtures, 'file2.json')];
var override = JSON.parse(fs.readFileSync(files[0]), 'utf8');
describe('nconf/provider When using nconf', () => {
describe("an instance of 'nconf.Provider'", () => {
it("calling the use() method with the same store type and different options"
+ " should use a new instance of the store type", () => {
var provider = new nconf.Provider().use('file', {file: files[0]});
var old = provider.stores['file'];
expect(provider.stores.file.file).toEqual(files[0]);
provider.use('file', {file: files[1]});
expect(old).not.toEqual(provider.stores.file);
expect(provider.stores.file.file).toEqual(files[1]);
})
});
it("respond with correct arg when 'env' is true", helpers.assertSystemConf({
script: path.join(fixturesDir, 'scripts', 'provider-env.js'),
env: {SOMETHING: 'foobar'}
}));
it("respond with correct arg when 'env' is true and 'parseValues' option is true", () => {
var env = {
SOMETHING: 'foobar',
SOMEBOOL: 'true',
SOMENULL: 'null',
SOMEUNDEF: 'undefined',
SOMEINT: '3600',
SOMEFLOAT: '0.5',
SOMEBAD: '5.1a'
};
var oenv = {};
Object.keys(env).forEach(function (key) {
if (process.env[key]) oenv[key] = process.env[key];
process.env[key] = env[key];
});
var provider = new nconf.Provider().use('env', {parseValues: true});
Object.keys(env).forEach(function (key) {
delete process.env[key];
if (oenv[key]) process.env[key] = oenv[key];
});
expect(provider.get('SOMETHING')).toEqual('foobar');
expect(provider.get('SOMEBOOL')).toEqual(true);
expect(provider.get('SOMEBOOL')).not.toEqual('true');
expect(provider.get('SOMENULL')).toEqual(null);
expect(provider.get('SOMEUNDEF')).toEqual(undefined);
expect(provider.get('SOMEINT')).toEqual(3600);
expect(provider.get('SOMEFLOAT')).toEqual(.5);
expect(provider.get('SOMEBAD')).toEqual('5.1a');
});
describe("an instance of 'nconf.Provider'", () => {
describe("the merge() method", () => {
it("should have the result merged in", () => {
var provider = new nconf.Provider().use('file', {file: files[1]});
provider.load();
provider.merge(override);
helpers.assertMerged(null, provider.stores.file.store);
expect(provider.stores.file.store.candy.something).toEqual('file1');
});
it("should merge Objects over null", () => {
var provider = new nconf.Provider().use('file', {file: files[1]});
provider.load();
provider.merge(override);
expect(provider.stores.file.store.unicorn.exists).toEqual(true);
});
})
describe("the load() method", () => {
it("should respect the hierarchy when sources are passed in", () => {
var provider = new nconf.Provider({
sources: {
user: {
type: 'file',
file: files[0]
},
global: {
type: 'file',
file: files[1]
}
}
});
var merged = provider.load();
helpers.assertMerged(null, merged);
expect(merged.candy.something).toEqual('file1');
})
it("should respect the hierarchy when multiple stores are used", () => {
var provider = new nconf.Provider().overrides({foo: {bar: 'baz'}})
.add('file1', {type: 'file', file: files[0]})
.add('file2', {type: 'file', file: files[1]});
var merged = provider.load();
helpers.assertMerged(null, merged);
expect(merged.foo.bar).toEqual('baz');
expect(merged.candy.something).toEqual('file1');
})
})
})
describe("the .file() method", () => {
it("should use the correct File store with a single filepath", () => {
var provider = new nconf.Provider();
provider.file(helpers.fixture('store.json'));
expect(typeof provider.stores.file).toBe('object');
});
it("should use the correct File store with a name and a filepath", () => {
var provider = new nconf.Provider();
provider.file('custom', helpers.fixture('store.json'));
expect(typeof provider.stores.custom).toBe('object');
});
it("should use the correct File store with a single object", () => {
var provider = new nconf.Provider();
provider.file({
dir: helpers.fixture(''),
file: 'store.json',
search: true
});
expect(typeof provider.stores.file).toBe('object');
expect(provider.stores.file.file).toEqual(helpers.fixture('store.json'));
});
it("should use the correct File store with a name and an object", () => {
var provider = new nconf.Provider();
provider.file('custom', {
dir: helpers.fixture(''),
file: 'store.json',
search: true
});
expect(typeof provider.stores.custom).toBe('object');
expect(provider.stores.custom.file).toEqual(helpers.fixture('store.json'));
})
describe("the any() method", () => {
var provider = new nconf.Provider({
type: 'literal',
store: {
key: "getThisValue"
}
})
describe("without a callback", () => {
it("should respond with the correct value given an array of keys with one matching", () => {
expect(provider.any(["notthis", "orthis", "key"])).toEqual('getThisValue');
})
it("should respond with null given an array of keys with no match", () => {
expect(provider.any(["notthis", "orthis"])).toBe(null);
});
it("should respond with the correct value given a variable argument list of keys with one matching", () => {
expect(provider.any("notthis", "orthis", "key")).toEqual('getThisValue');
});
it("should respond with null given no arguments", () => {
expect(provider.any()).toBe(null);
});
})
describe("with a callback", () => {
it("should respond with the correct value given an array of keys with one matching", done => {
provider.any(["notthis", "orthis", "key"], (err, value) => {
expect(value).toEqual('getThisValue');
done();
});
});
it("should respond with an undefined value given an array of keys with no match", done => {
provider.any(["notthis", "orthis"], (err, value) => {
expect(value).toBe(undefined)
done();
});
});
it("should respond with the correct value given a variable argument list of keys with one matching", done => {
provider.any("notthis", "orthis", "key", (err, value) => {
expect(value).toEqual('getThisValue');
done();
});
});
it("should respond with an undefined value given no keys", done => {
provider.any((err, value) => {
expect(value).toBe(undefined)
done();
});
});
})
})
})
});

223
test/provider.test.mjs
View File

@ -0,0 +1,223 @@
import fs from 'fs'
import path from 'path'
import { spawn } from 'child_process'
import { Eltro as t, assert} from 'eltro'
import * as helpers from './helpers.mjs'
import nconf from '../lib/nconf.js'
var files = [
helpers.fixture('merge/file1.json'),
helpers.fixture('merge/file2.json'),
];
var override = JSON.parse(fs.readFileSync(files[0]), 'utf8');
function assertSystemConf(options) {
return new Promise(function(res, rej) {
var env = null;
if (options.env) {
env = {}
Object.keys(process.env).forEach(function (key) {
env[key] = process.env[key];
});
Object.keys(options.env).forEach(function (key) {
env[key] = options.env[key];
});
}
var child = spawn('node', [options.script].concat(options.argv), {env: env});
child.stdout.once('data', data => {
res(data.toString())
});
})
}
t.describe('nconf/provider When using nconf', function() {
t.describe("an instance of 'nconf.Provider'", function() {
t.test("calling the use() method with the same store type and different options"
+ " should use a new instance of the store type", function() {
var provider = new nconf.Provider().use('file', {file: files[0]});
var old = provider.stores['file'];
assert.strictEqual(provider.stores.file.file, files[0]);
provider.use('file', {file: files[1]});
assert.notStrictEqual(old, provider.stores.file);
assert.strictEqual(provider.stores.file.file, files[1]);
})
});
t.test("respond with correct arg when 'env' is true", async function() {
let result = await assertSystemConf({
script: helpers.fixture('scripts/provider-env.js'),
env: {SOMETHING: 'foobar'}
})
assert.strictEqual(result.toString(), 'foobar')
});
t.test("respond with correct arg when 'env' is true and 'parseValues' option is true", function() {
var env = {
SOMETHING: 'foobar',
SOMEBOOL: 'true',
SOMENULL: 'null',
SOMEUNDEF: 'undefined',
SOMEINT: '3600',
SOMEFLOAT: '0.5',
SOMEBAD: '5.1a'
};
var oenv = {};
Object.keys(env).forEach(function (key) {
if (process.env[key]) oenv[key] = process.env[key];
process.env[key] = env[key];
});
var provider = new nconf.Provider().use('env', {parseValues: true});
Object.keys(env).forEach(function (key) {
delete process.env[key];
if (oenv[key]) process.env[key] = oenv[key];
});
assert.strictEqual(provider.get('SOMETHING'), 'foobar');
assert.strictEqual(provider.get('SOMEBOOL'), true);
assert.notStrictEqual(provider.get('SOMEBOOL'), 'true');
assert.strictEqual(provider.get('SOMENULL'), null);
assert.strictEqual(provider.get('SOMEUNDEF'), undefined);
assert.strictEqual(provider.get('SOMEINT'), 3600);
assert.strictEqual(provider.get('SOMEFLOAT'), .5);
assert.strictEqual(provider.get('SOMEBAD'), '5.1a');
});
t.describe("an instance of 'nconf.Provider'", function() {
t.describe("the merge() method", function() {
t.test("should have the result merged in", function() {
var provider = new nconf.Provider().use('file', {file: files[1]});
provider.load();
provider.merge(override);
helpers.assertMerged(null, provider.stores.file.store);
assert.strictEqual(provider.stores.file.store.candy.something, 'file1');
});
t.test("should merge Objects over null", function() {
var provider = new nconf.Provider().use('file', {file: files[1]});
provider.load();
provider.merge(override);
assert.strictEqual(provider.stores.file.store.unicorn.exists, true);
});
})
t.describe("the load() method", function() {
t.test("should respect the hierarchy when sources are passed in", function() {
var provider = new nconf.Provider({
sources: {
user: {
type: 'file',
file: files[0]
},
global: {
type: 'file',
file: files[1]
}
}
});
var merged = provider.load();
helpers.assertMerged(null, merged);
assert.strictEqual(merged.candy.something, 'file1');
})
t.test("should respect the hierarchy when multiple stores are used", function() {
var provider = new nconf.Provider().overrides({foo: {bar: 'baz'}})
.add('file1', {type: 'file', file: files[0]})
.add('file2', {type: 'file', file: files[1]});
var merged = provider.load();
helpers.assertMerged(null, merged);
assert.strictEqual(merged.foo.bar, 'baz');
assert.strictEqual(merged.candy.something, 'file1');
})
})
})
t.describe("the .file() method", function() {
t.test("should use the correct File store with a single filepath", function() {
var provider = new nconf.Provider();
provider.file(helpers.fixture('store.json'));
assert.strictEqual(typeof(provider.stores.file), 'object');
});
t.test("should use the correct File store with a name and a filepath", function() {
var provider = new nconf.Provider();
provider.file('custom', helpers.fixture('store.json'));
assert.strictEqual(typeof(provider.stores.custom), 'object');
});
t.test("should use the correct File store with a single object", function() {
var provider = new nconf.Provider();
provider.file({
dir: helpers.fixture(''),
file: 'store.json',
search: true
});
assert.strictEqual(typeof(provider.stores.file), 'object');
assert.strictEqual(provider.stores.file.file, helpers.fixture('store.json'));
});
t.test("should use the correct File store with a name and an object", function() {
var provider = new nconf.Provider();
provider.file('custom', {
dir: helpers.fixture(''),
file: 'store.json',
search: true
});
assert.strictEqual(typeof(provider.stores.custom), 'object');
assert.strictEqual(provider.stores.custom.file, helpers.fixture('store.json'));
})
t.describe("the any() method", function() {
var provider = new nconf.Provider({
type: 'literal',
store: {
key: "getThisValue"
}
})
t.describe("without a callback", function() {
t.test("should respond with the correct value given an array of keys with one matching", function() {
assert.strictEqual(provider.any(["notthis", "orthis", "key"]), 'getThisValue');
})
t.test("should respond with null given an array of keys with no match", function() {
assert.strictEqual(provider.any(["notthis", "orthis"]), null);
});
t.test("should respond with the correct value given a variable argument list of keys with one matching", function() {
assert.strictEqual(provider.any("notthis", "orthis", "key"), 'getThisValue');
});
t.test("should respond with null given no arguments", function() {
assert.strictEqual(provider.any(), null);
});
})
t.describe("with a callback", function() {
t.test("should respond with the correct value given an array of keys with one matching", function(done) {
provider.any(["notthis", "orthis", "key"], (err, value) => {
assert.strictEqual(value, 'getThisValue');
done();
});
});
t.test("should respond with an undefined value given an array of keys with no match", function(done) {
provider.any(["notthis", "orthis"], (err, value) => {
assert.strictEqual(value, undefined)
done();
});
});
t.test("should respond with the correct value given a variable argument list of keys with one matching", function(done) {
provider.any("notthis", "orthis", "key", (err, value) => {
assert.strictEqual(value, 'getThisValue');
done();
});
});
t.test("should respond with an undefined value given no keys", function(done) {
provider.any((err, value) => {
assert.strictEqual(value, undefined)
done();
});
});
})
})
})
});
Write Preview
Loading…
Cancel
Save