195 lines
6.5 KiB
JavaScript
195 lines
6.5 KiB
JavaScript
import fs from 'fs'
|
|
import path from 'path'
|
|
import { Eltro as t, assert} from 'eltro'
|
|
import Nconf from '../lib/nconf.mjs'
|
|
import * as helpers from './helpers.mjs'
|
|
|
|
t.describe('nconf', function() {
|
|
t.test('should have the correct methods set', function() {
|
|
let nconf = new Nconf()
|
|
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('memory() should instaniate the correct store', function() {
|
|
let nconf = new Nconf()
|
|
nconf.memory()
|
|
assert.ok(nconf.use('memory') instanceof Nconf.Memory)
|
|
})
|
|
|
|
t.test('should have the correct version set', function () {
|
|
let nconf = new Nconf()
|
|
let pckg = JSON.parse(fs.readFileSync(helpers.fixture('../../package.json')))
|
|
assert.ok(pckg.version)
|
|
assert.strictEqual(nconf.version, pckg.version)
|
|
})
|
|
})
|
|
|
|
t.describe('#required()', function() {
|
|
let nconf = new Nconf()
|
|
nconf.memory()
|
|
nconf.set('foo:bar:bazz', 'buzz')
|
|
|
|
t.test('should throw error with missing keys', function() {
|
|
assert.throws(function() {
|
|
nconf.required(['missingtest', 'foo:bar:bazz'])
|
|
}, /missingtest/)
|
|
})
|
|
|
|
t.test('should throw error with missing keys with non-array parameter', function() {
|
|
assert.throws(function() {
|
|
nconf.required(['missingtest', 'foo:bar:bazz'])
|
|
}, /missingtest/)
|
|
})
|
|
|
|
t.test('should return the provider if all keys exist', function() {
|
|
assert.strictEqual(nconf.required(['foo:bar:bazz']), nconf)
|
|
})
|
|
})
|
|
t.describe('#any()', function() {
|
|
let nconf = new Nconf()
|
|
nconf.memory()
|
|
nconf.set('foo:bar:bazz', 'buzz')
|
|
|
|
t.test('should return if found', function() {
|
|
assert.strictEqual(nconf.any(['missingtest', 'nope', 'foo:bar:bazz']), 'buzz')
|
|
})
|
|
t.test('should return first item found', function() {
|
|
assert.deepStrictEqual(nconf.any(['missingtest', 'foo', 'nope', 'foo:bar:bazz']), {
|
|
bar: {
|
|
bazz: 'buzz',
|
|
},
|
|
})
|
|
})
|
|
t.test('should return if found as paramaters', function() {
|
|
assert.strictEqual(nconf.any('missingtest', 'nope', 'foo:bar:bazz'), 'buzz')
|
|
})
|
|
t.test('should return undefined otherwise', function() {
|
|
assert.strictEqual(nconf.any(['missingtest', 'nope']), undefined)
|
|
})
|
|
})
|
|
t.describe('#set()', function() {
|
|
t.test('should respond with self if success', function() {
|
|
let nconf = new Nconf()
|
|
nconf.memory()
|
|
assert.strictEqual(nconf.set('foo:bar:bazz', 'buzz'), nconf)
|
|
})
|
|
|
|
t.test('should respond with false if not successful', function() {
|
|
let nconf = new Nconf()
|
|
nconf.memory({ readOnly: true })
|
|
assert.strictEqual(nconf.set('foo:bar:bazz', 'buzz'), false)
|
|
})
|
|
|
|
t.test('should always set the first writeable store', function() {
|
|
let nconf = new Nconf()
|
|
nconf.memory('first')
|
|
nconf.memory('second')
|
|
nconf.use('second').set('foo:bar:bazz', 'buzz')
|
|
assert.strictEqual(nconf.get('foo:bar:bazz'), 'buzz')
|
|
nconf.set('foo:bar:bazz', 'overwritten')
|
|
assert.strictEqual(nconf.get('foo:bar:bazz'), 'overwritten')
|
|
assert.strictEqual(nconf.use('second').get('foo:bar:bazz'), 'buzz')
|
|
})
|
|
|
|
t.test('should respond allow access to the root and complain about non-objects', function() {
|
|
let nconf = new Nconf()
|
|
nconf.memory()
|
|
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.deepStrictEqual(nconf.get(), original)
|
|
})
|
|
})
|
|
t.describe('#get()', function() {
|
|
let nconf = new Nconf()
|
|
nconf.memory()
|
|
nconf.set('foo:bar:bazz', 'buzz')
|
|
|
|
t.test('should respond with the correct value', function() {
|
|
assert.strictEqual(nconf.get('foo:bar:bazz'), 'buzz')
|
|
})
|
|
|
|
t.test('unknown keys should return undefined', function() {
|
|
assert.strictEqual(nconf.get('foo:bar:bazz:toString'), undefined)
|
|
})
|
|
|
|
t.test('should not step inside strings', function() {
|
|
assert.strictEqual(nconf.get('foo:bar:bazz:0'), undefined)
|
|
})
|
|
|
|
t.test('should respond allow access to the root', function() {
|
|
assert.ok(nconf.get(null))
|
|
assert.ok(nconf.get(undefined))
|
|
assert.ok(nconf.get())
|
|
assert.deepStrictEqual(nconf.get(), { foo: { bar: { bazz: 'buzz' } } })
|
|
})
|
|
|
|
t.test('should merge stores correctly', function() {
|
|
let testMerge = new Nconf()
|
|
testMerge.memory('higherpriority')
|
|
testMerge.set('foo:bar', {
|
|
bazz: 'overwritten',
|
|
test: 1
|
|
})
|
|
testMerge.memory('lowerdefaults')
|
|
testMerge.use('lowerdefaults').set('foo:bar:bazz', 'buzz')
|
|
testMerge.use('lowerdefaults').set('foo:bar:buzz', 'buzz')
|
|
|
|
assert.strictEqual(testMerge.get('foo:bar:bazz'), 'overwritten')
|
|
assert.strictEqual(testMerge.get('foo:bar:buzz'), 'buzz')
|
|
|
|
assert.deepStrictEqual(testMerge.get('foo:bar'), {
|
|
bazz: 'overwritten',
|
|
buzz: 'buzz',
|
|
test: 1,
|
|
})
|
|
})
|
|
})
|
|
t.describe('#clear()', function() {
|
|
t.test('should respond with self if success', function() {
|
|
let nconf = new Nconf()
|
|
nconf.memory().set('foo:bar:bazz', 'buzz')
|
|
assert.strictEqual(nconf.get('foo:bar:bazz'), 'buzz')
|
|
assert.strictEqual(nconf.clear('foo:bar:bazz'), nconf)
|
|
assert.strictEqual(nconf.get('foo:bar:bazz'), undefined)
|
|
})
|
|
|
|
t.test('should respond with self if success even with readOnly store', function() {
|
|
let nconf = new Nconf()
|
|
nconf
|
|
.literal({ testetytest: 'buzz' })
|
|
.memory()
|
|
.set('foo:bar:bazz', 'buzz')
|
|
|
|
assert.strictEqual(nconf.get('foo:bar:bazz'), 'buzz')
|
|
assert.strictEqual(nconf.get('testetytest'), 'buzz')
|
|
assert.strictEqual(nconf.clear('foo:bar:bazz'), nconf)
|
|
assert.strictEqual(nconf.get('foo:bar:bazz'), undefined)
|
|
assert.strictEqual(nconf.use('literal').get('foo:bar:bazz'), undefined)
|
|
})
|
|
|
|
t.test('should respond with false if clearing readonly value', function() {
|
|
let nconf = new Nconf()
|
|
nconf.literal({ testetytest: 'buzz' })
|
|
|
|
assert.strictEqual(nconf.get('testetytest'), 'buzz')
|
|
assert.notOk(nconf.clear('testetytest'))
|
|
assert.strictEqual(nconf.get('testetytest'), 'buzz')
|
|
})
|
|
})
|