You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
684 lines
20 KiB
684 lines
20 KiB
var expect = require('chai').expect, |
|
objectPath = require('./index.js'); |
|
|
|
|
|
function getTestObj() { |
|
return { |
|
a: 'b', |
|
b: { |
|
c: [], |
|
d: ['a', 'b'], |
|
e: [{},{f: 'g'}], |
|
f: 'i' |
|
} |
|
}; |
|
} |
|
|
|
describe('get', function() { |
|
it('should return the value under shallow object', function() { |
|
var obj = getTestObj(); |
|
expect(objectPath.get(obj, 'a')).to.be.equal('b'); |
|
expect(objectPath.get(obj, ['a'])).to.be.equal('b'); |
|
}); |
|
|
|
it('should work with number path', function() { |
|
var obj = getTestObj(); |
|
expect(objectPath.get(obj.b.d, 0)).to.be.equal('a'); |
|
expect(objectPath.get(obj.b, 0)).to.be.equal(void 0); |
|
}); |
|
|
|
it('should return the value under deep object', function() { |
|
var obj = getTestObj(); |
|
expect(objectPath.get(obj, 'b.f')).to.be.equal('i'); |
|
expect(objectPath.get(obj, ['b','f'])).to.be.equal('i'); |
|
}); |
|
|
|
it('should return the value under array', function() { |
|
var obj = getTestObj(); |
|
expect(objectPath.get(obj, 'b.d.0')).to.be.equal('a'); |
|
expect(objectPath.get(obj, ['b','d',0])).to.be.equal('a'); |
|
}); |
|
|
|
it('should return the value under array deep', function() { |
|
var obj = getTestObj(); |
|
expect(objectPath.get(obj, 'b.e.1.f')).to.be.equal('g'); |
|
expect(objectPath.get(obj, ['b','e',1,'f'])).to.be.equal('g'); |
|
}); |
|
|
|
it('should return undefined for missing values under object', function() { |
|
var obj = getTestObj(); |
|
expect(objectPath.get(obj, 'a.b')).to.not.exist; |
|
expect(objectPath.get(obj, ['a','b'])).to.not.exist; |
|
}); |
|
|
|
it('should return undefined for missing values under array', function() { |
|
var obj = getTestObj(); |
|
expect(objectPath.get(obj, 'b.d.5')).to.not.exist; |
|
expect(objectPath.get(obj, ['b','d','5'])).to.not.exist; |
|
}); |
|
|
|
it('should return the value under integer-like key', function() { |
|
var obj = { '1a': 'foo' }; |
|
expect(objectPath.get(obj, '1a')).to.be.equal('foo'); |
|
expect(objectPath.get(obj, ['1a'])).to.be.equal('foo'); |
|
}); |
|
|
|
it('should return the default value when the key doesnt exist', function() { |
|
var obj = { '1a': 'foo' }; |
|
expect(objectPath.get(obj, '1b', null)).to.be.equal(null); |
|
expect(objectPath.get(obj, ['1b'], null)).to.be.equal(null); |
|
}); |
|
|
|
it('should return the default value when path is empty', function() { |
|
var obj = { '1a': 'foo' }; |
|
expect(objectPath.get(obj, '', null)).to.be.deep.equal({ '1a': 'foo' }); |
|
expect(objectPath.get(obj, [])).to.be.deep.equal({ '1a': 'foo' }); |
|
expect(objectPath.get({ }, ['1'])).to.be.equal(undefined); |
|
}); |
|
|
|
it('should skip non own properties with isEmpty', function(){ |
|
var Base = function(enabled){ }; |
|
Base.prototype = { |
|
one: { |
|
two: true |
|
} |
|
}; |
|
var Extended = function(){ |
|
Base.call(this, true); |
|
}; |
|
Extended.prototype = Object.create(Base.prototype); |
|
|
|
var extended = new Extended(); |
|
|
|
expect(objectPath.get(extended, ['one','two'])).to.be.equal(undefined); |
|
extended.enabled = true; |
|
|
|
expect(objectPath.get(extended, 'enabled')).to.be.equal(true); |
|
}); |
|
}); |
|
|
|
|
|
describe('set', function() { |
|
it('should set value under shallow object', function() { |
|
var obj = getTestObj(); |
|
objectPath.set(obj, 'c', {m: 'o'}); |
|
expect(obj).to.have.deep.property('c.m', 'o'); |
|
obj = getTestObj(); |
|
objectPath.set(obj, ['c'], {m: 'o'}); |
|
expect(obj).to.have.deep.property('c.m', 'o'); |
|
}); |
|
|
|
it('should set value using number path', function() { |
|
var obj = getTestObj(); |
|
objectPath.set(obj.b.d, 0, 'o'); |
|
expect(obj).to.have.deep.property('b.d.0', 'o'); |
|
}); |
|
|
|
it('should set value under deep object', function() { |
|
var obj = getTestObj(); |
|
objectPath.set(obj, 'b.c', 'o'); |
|
expect(obj).to.have.deep.property('b.c', 'o'); |
|
obj = getTestObj(); |
|
objectPath.set(obj, ['b','c'], 'o'); |
|
expect(obj).to.have.deep.property('b.c', 'o'); |
|
}); |
|
|
|
it('should set value under array', function() { |
|
var obj = getTestObj(); |
|
objectPath.set(obj, 'b.e.1.g', 'f'); |
|
expect(obj).to.have.deep.property('b.e.1.g', 'f'); |
|
obj = getTestObj(); |
|
objectPath.set(obj, ['b','e',1,'g'], 'f'); |
|
expect(obj).to.have.deep.property('b.e.1.g', 'f'); |
|
}); |
|
|
|
it('should create intermediate objects', function() { |
|
var obj = getTestObj(); |
|
objectPath.set(obj, 'c.d.e.f', 'l'); |
|
expect(obj).to.have.deep.property('c.d.e.f', 'l'); |
|
obj = getTestObj(); |
|
objectPath.set(obj, ['c','d','e','f'], 'l'); |
|
expect(obj).to.have.deep.property('c.d.e.f', 'l'); |
|
}); |
|
|
|
it('should create intermediate arrays', function() { |
|
var obj = getTestObj(); |
|
objectPath.set(obj, 'c.0.1.m', 'l'); |
|
expect(obj.c).to.be.an('array'); |
|
expect(obj.c[0]).to.be.an('array'); |
|
expect(obj).to.have.deep.property('c.0.1.m', 'l'); |
|
obj = getTestObj(); |
|
objectPath.set(obj, ['c','0', 1,'m'], 'l'); |
|
expect(obj.c).to.be.an('object'); |
|
expect(obj.c[0]).to.be.an('array'); |
|
expect(obj).to.have.deep.property('c.0.1.m', 'l'); |
|
}); |
|
|
|
it('should set value under integer-like key', function() { |
|
var obj = getTestObj(); |
|
objectPath.set(obj, '1a', 'foo'); |
|
expect(obj).to.have.deep.property('1a', 'foo'); |
|
obj = getTestObj(); |
|
objectPath.set(obj, ['1a'], 'foo'); |
|
expect(obj).to.have.deep.property('1a', 'foo'); |
|
}); |
|
|
|
it('should set value under empty array', function() { |
|
var obj = []; |
|
objectPath.set(obj, [0], 'foo'); |
|
expect(obj[0]).to.be.equal('foo'); |
|
obj = []; |
|
objectPath.set(obj, '0', 'foo'); |
|
expect(obj[0]).to.be.equal('foo'); |
|
}); |
|
}); |
|
|
|
|
|
describe('push', function() { |
|
it('should push value to existing array', function() { |
|
var obj = getTestObj(); |
|
objectPath.push(obj, 'b.c', 'l'); |
|
expect(obj).to.have.deep.property('b.c.0', 'l'); |
|
obj = getTestObj(); |
|
objectPath.push(obj, ['b','c'], 'l'); |
|
expect(obj).to.have.deep.property('b.c.0', 'l'); |
|
}); |
|
|
|
it('should push value to new array', function() { |
|
var obj = getTestObj(); |
|
objectPath.push(obj, 'b.h', 'l'); |
|
expect(obj).to.have.deep.property('b.h.0', 'l'); |
|
obj = getTestObj(); |
|
objectPath.push(obj, ['b','h'], 'l'); |
|
expect(obj).to.have.deep.property('b.h.0', 'l'); |
|
}); |
|
|
|
it('should push value to existing array using number path', function() { |
|
var obj = getTestObj(); |
|
objectPath.push(obj.b.e, 0, 'l'); |
|
expect(obj).to.have.deep.property('b.e.0.0', 'l'); |
|
}); |
|
|
|
}); |
|
|
|
|
|
describe('ensureExists', function() { |
|
it('should create the path if it does not exists', function() { |
|
var obj = getTestObj(); |
|
var oldVal = objectPath.ensureExists(obj, 'b.g.1.l', 'test'); |
|
expect(oldVal).to.not.exist; |
|
expect(obj).to.have.deep.property('b.g.1.l', 'test'); |
|
oldVal = objectPath.ensureExists(obj, 'b.g.1.l', 'test1'); |
|
expect(oldVal).to.be.equal('test'); |
|
expect(obj).to.have.deep.property('b.g.1.l', 'test'); |
|
}); |
|
|
|
|
|
it('should return the object if path is empty', function() { |
|
var obj = getTestObj(); |
|
expect(objectPath.ensureExists(obj, [], 'test')).to.have.property('a', 'b'); |
|
}); |
|
|
|
it('Issue #26', function() { |
|
var any = {}; |
|
objectPath.ensureExists(any, ['1','1'], {}); |
|
expect(any).to.be.an('object'); |
|
expect(any[1]).to.be.an('object'); |
|
expect(any[1][1]).to.be.an('object'); |
|
}); |
|
}); |
|
|
|
describe('coalesce', function(){ |
|
it('should return the first non-undefined value', function(){ |
|
var obj = { |
|
should: {have: 'prop'} |
|
}; |
|
|
|
expect(objectPath.coalesce(obj, [ |
|
'doesnt.exist', |
|
['might','not','exist'], |
|
'should.have' |
|
])).to.equal('prop'); |
|
}); |
|
|
|
it('should work with falsy values (null, 0, \'\', false)', function(){ |
|
var obj = { |
|
is: { |
|
false: false, |
|
null: null, |
|
empty: '', |
|
zero: 0 |
|
} |
|
}; |
|
|
|
expect(objectPath.coalesce(obj, [ |
|
'doesnt.exist', |
|
'is.zero' |
|
])).to.equal(0); |
|
|
|
expect(objectPath.coalesce(obj, [ |
|
'doesnt.exist', |
|
'is.false' |
|
])).to.equal(false); |
|
|
|
expect(objectPath.coalesce(obj, [ |
|
'doesnt.exist', |
|
'is.null' |
|
])).to.equal(null); |
|
|
|
expect(objectPath.coalesce(obj, [ |
|
'doesnt.exist', |
|
'is.empty' |
|
])).to.equal(''); |
|
}); |
|
|
|
it('returns defaultValue if no paths found', function(){ |
|
var obj = { |
|
doesnt: 'matter' |
|
}; |
|
|
|
expect(objectPath.coalesce(obj, ['some.inexistant','path',['on','object']], 'false')).to.equal('false'); |
|
}); |
|
}); |
|
|
|
describe('empty', function(){ |
|
it('should ignore invalid arguments safely', function(){ |
|
var obj = {}; |
|
expect(objectPath.empty()).to.equal(void 0); |
|
expect(objectPath.empty(obj, 'path')).to.equal(void 0); |
|
expect(objectPath.empty(obj, '')).to.equal(obj); |
|
|
|
obj.path = true; |
|
|
|
expect(objectPath.empty(obj, 'inexistant')).to.equal(obj); |
|
}); |
|
|
|
it('should empty each path according to their types', function(){ |
|
function Instance(){ |
|
this.notOwn = true; |
|
} |
|
|
|
/*istanbul ignore next: not part of code */ |
|
Instance.prototype.test = function(){}; |
|
/*istanbul ignore next: not part of code */ |
|
Instance.prototype.arr = []; |
|
|
|
var |
|
obj = { |
|
string: 'some string', |
|
array: ['some','array',[1,2,3]], |
|
number: 21, |
|
boolean: true, |
|
object: { |
|
some:'property', |
|
sub: { |
|
'property': true |
|
} |
|
}, |
|
instance: new Instance() |
|
}; |
|
|
|
/*istanbul ignore next: not part of code */ |
|
obj['function'] = function(){}; |
|
|
|
objectPath.empty(obj, ['array','2']); |
|
expect(obj.array[2]).to.deep.equal([]); |
|
|
|
objectPath.empty(obj, 'object.sub'); |
|
expect(obj.object.sub).to.deep.equal({}); |
|
|
|
objectPath.empty(obj, 'instance.test'); |
|
expect(obj.instance.test).to.equal(null); |
|
expect(Instance.prototype.test).to.be.a('function'); |
|
|
|
objectPath.empty(obj, 'string'); |
|
objectPath.empty(obj, 'number'); |
|
objectPath.empty(obj, 'boolean'); |
|
objectPath.empty(obj, 'function'); |
|
objectPath.empty(obj, 'array'); |
|
objectPath.empty(obj, 'object'); |
|
objectPath.empty(obj, 'instance'); |
|
|
|
expect(obj.string).to.equal(''); |
|
expect(obj.array).to.deep.equal([]); |
|
expect(obj.number).to.equal(0); |
|
expect(obj.boolean).to.equal(false); |
|
expect(obj.object).to.deep.equal({}); |
|
expect(obj.instance.notOwn).to.be.an('undefined'); |
|
expect(obj.instance.arr).to.be.an('array'); |
|
expect(obj['function']).to.equal(null); |
|
}); |
|
}); |
|
|
|
describe('del', function(){ |
|
it('should return undefined on empty object', function(){ |
|
expect(objectPath.del({}, 'a')).to.equal(void 0); |
|
}); |
|
|
|
it('should work with number path', function(){ |
|
var obj = getTestObj(); |
|
objectPath.del(obj.b.d, 1); |
|
expect(obj.b.d).to.deep.equal(['a']); |
|
}); |
|
|
|
it('should delete deep paths', function(){ |
|
var obj = getTestObj(); |
|
|
|
expect(objectPath.del(obj)).to.be.equal(obj); |
|
|
|
objectPath.set(obj, 'b.g.1.0', 'test'); |
|
objectPath.set(obj, 'b.g.1.1', 'test'); |
|
objectPath.set(obj, 'b.h.az', 'test'); |
|
|
|
expect(obj).to.have.deep.property('b.g.1.0','test'); |
|
expect(obj).to.have.deep.property('b.g.1.1','test'); |
|
expect(obj).to.have.deep.property('b.h.az','test'); |
|
|
|
objectPath.del(obj, 'b.h.az'); |
|
expect(obj).to.not.have.deep.property('b.h.az'); |
|
expect(obj).to.have.deep.property('b.h'); |
|
|
|
objectPath.del(obj, 'b.g.1.1'); |
|
expect(obj).to.not.have.deep.property('b.g.1.1'); |
|
expect(obj).to.have.deep.property('b.g.1.0','test'); |
|
|
|
objectPath.del(obj, ['b','g','1','0']); |
|
expect(obj).to.not.have.deep.property('b.g.1.0'); |
|
expect(obj).to.have.deep.property('b.g.1'); |
|
|
|
expect(objectPath.del(obj, ['b'])).to.not.have.deep.property('b.g'); |
|
expect(obj).to.be.deep.equal({'a':'b'}); |
|
}); |
|
|
|
it('should remove items from existing array', function(){ |
|
var obj = getTestObj(); |
|
|
|
objectPath.del(obj, 'b.d.0'); |
|
expect(obj.b.d).to.have.length(1); |
|
expect(obj.b.d).to.be.deep.equal(['b']); |
|
|
|
objectPath.del(obj, 'b.d.0'); |
|
expect(obj.b.d).to.have.length(0); |
|
expect(obj.b.d).to.be.deep.equal([]); |
|
}); |
|
|
|
it('should skip undefined paths', function(){ |
|
var obj = getTestObj(); |
|
|
|
expect(objectPath.del(obj, 'do.not.exist')).to.be.equal(obj); |
|
expect(objectPath.del(obj, 'a.c')).to.be.equal('b'); |
|
}); |
|
}); |
|
|
|
describe('insert', function(){ |
|
it('should insert value into existing array', function(){ |
|
var obj = getTestObj(); |
|
|
|
objectPath.insert(obj, 'b.c', 'asdf'); |
|
expect(obj).to.have.deep.property('b.c.0', 'asdf'); |
|
expect(obj).to.not.have.deep.property('b.c.1'); |
|
}); |
|
|
|
it('should create intermediary array', function(){ |
|
var obj = getTestObj(); |
|
|
|
objectPath.insert(obj, 'b.c.0', 'asdf'); |
|
expect(obj).to.have.deep.property('b.c.0.0', 'asdf'); |
|
}); |
|
|
|
it('should insert in another index', function(){ |
|
var obj = getTestObj(); |
|
|
|
objectPath.insert(obj, 'b.d', 'asdf', 1); |
|
expect(obj).to.have.deep.property('b.d.1', 'asdf'); |
|
expect(obj).to.have.deep.property('b.d.0', 'a'); |
|
expect(obj).to.have.deep.property('b.d.2', 'b'); |
|
}); |
|
|
|
it('should handle sparse array', function(){ |
|
var obj = getTestObj(); |
|
obj.b.d = new Array(4); |
|
obj.b.d[0] = 'a'; |
|
obj.b.d[1] = 'b'; |
|
|
|
objectPath.insert(obj, 'b.d', 'asdf', 3); |
|
expect(obj.b.d).to.have.members([ |
|
'a', |
|
'b', |
|
, |
|
, |
|
'asdf' |
|
]); |
|
}); |
|
}); |
|
|
|
describe('has', function () { |
|
it('should return false for empty object', function () { |
|
expect(objectPath.has({}, 'a')).to.be.false; |
|
}); |
|
|
|
it('should return false for empty path', function () { |
|
var obj = getTestObj(); |
|
expect(objectPath.has(obj, '')).to.be.false; |
|
expect(objectPath.has(obj, [])).to.be.false; |
|
expect(objectPath.has(obj, [''])).to.be.false; |
|
}); |
|
|
|
it('should test under shallow object', function() { |
|
var obj = getTestObj(); |
|
expect(objectPath.has(obj, 'a')).to.be.true; |
|
expect(objectPath.has(obj, ['a'])).to.be.true; |
|
expect(objectPath.has(obj, 'z')).to.be.false; |
|
expect(objectPath.has(obj, ['z'])).to.be.false; |
|
}); |
|
|
|
it('should work with number path', function() { |
|
var obj = getTestObj(); |
|
expect(objectPath.has(obj.b.d, 0)).to.be.true; |
|
expect(objectPath.has(obj.b, 0)).to.be.false; |
|
expect(objectPath.has(obj.b.d, 10)).to.be.false; |
|
expect(objectPath.has(obj.b, 10)).to.be.false; |
|
}); |
|
|
|
it('should test under deep object', function() { |
|
var obj = getTestObj(); |
|
expect(objectPath.has(obj, 'b.f')).to.be.true; |
|
expect(objectPath.has(obj, ['b','f'])).to.be.true; |
|
expect(objectPath.has(obj, 'b.g')).to.be.false; |
|
expect(objectPath.has(obj, ['b','g'])).to.be.false; |
|
}); |
|
|
|
it('should test value under array', function() { |
|
var obj = getTestObj(); |
|
expect(objectPath.has(obj, 'b.d.0')).to.be.true; |
|
expect(objectPath.has(obj, ['b','d',0])).to.be.true; |
|
}); |
|
|
|
it('should test the value under array deep', function() { |
|
var obj = getTestObj(); |
|
expect(objectPath.has(obj, 'b.e.1.f')).to.be.true; |
|
expect(objectPath.has(obj, ['b','e',1,'f'])).to.be.true; |
|
expect(objectPath.has(obj, 'b.e.1.f.g.h.i')).to.be.false; |
|
expect(objectPath.has(obj, ['b','e',1,'f','g','h','i'])).to.be.false; |
|
}); |
|
|
|
it('should test the value under integer-like key', function() { |
|
var obj = { '1a': 'foo' }; |
|
expect(objectPath.has(obj, '1a')).to.be.true; |
|
expect(objectPath.has(obj, ['1a'])).to.be.true; |
|
}); |
|
|
|
it('should distinct nonexistent key and key = undefined', function() { |
|
var obj = {}; |
|
expect(objectPath.has(obj, 'key')).to.be.false; |
|
|
|
obj.key = undefined; |
|
expect(objectPath.has(obj, 'key')).to.be.true; |
|
}); |
|
}); |
|
|
|
|
|
|
|
describe('bind object', function () { |
|
// just get one scenario from each feature, so whole functionality is proxied well |
|
it('should return the value under shallow object', function() { |
|
var obj = getTestObj(); |
|
var model = objectPath(obj); |
|
expect(model.get('a')).to.be.equal('b'); |
|
expect(model.get(['a'])).to.be.equal('b'); |
|
}); |
|
|
|
it('should set value under shallow object', function() { |
|
var obj = getTestObj(); |
|
var model = objectPath(obj); |
|
model.set('c', {m: 'o'}); |
|
expect(obj).to.have.deep.property('c.m', 'o'); |
|
obj = getTestObj(); |
|
model = objectPath(obj); |
|
model.set(['c'], {m: 'o'}); |
|
expect(obj).to.have.deep.property('c.m', 'o'); |
|
}); |
|
|
|
it('should push value to existing array', function() { |
|
var obj = getTestObj(); |
|
var model = objectPath(obj); |
|
model.push('b.c', 'l'); |
|
expect(obj).to.have.deep.property('b.c.0', 'l'); |
|
obj = getTestObj(); |
|
model = objectPath(obj); |
|
model.push(['b','c'], 'l'); |
|
expect(obj).to.have.deep.property('b.c.0', 'l'); |
|
}); |
|
|
|
it('should create the path if it does not exists', function() { |
|
var obj = getTestObj(); |
|
var model = objectPath(obj); |
|
var oldVal = model.ensureExists('b.g.1.l', 'test'); |
|
expect(oldVal).to.not.exist; |
|
expect(obj).to.have.deep.property('b.g.1.l', 'test'); |
|
oldVal = model.ensureExists('b.g.1.l', 'test1'); |
|
expect(oldVal).to.be.equal('test'); |
|
expect(obj).to.have.deep.property('b.g.1.l', 'test'); |
|
}); |
|
|
|
it('should return the first non-undefined value', function(){ |
|
var obj = { |
|
should: {have: 'prop'} |
|
}; |
|
var model = objectPath(obj); |
|
|
|
expect(model.coalesce([ |
|
'doesnt.exist', |
|
['might','not','exist'], |
|
'should.have' |
|
])).to.equal('prop'); |
|
}); |
|
|
|
it('should empty each path according to their types', function(){ |
|
function Instance(){ |
|
this.notOwn = true; |
|
} |
|
|
|
/*istanbul ignore next: not part of code */ |
|
Instance.prototype.test = function(){}; |
|
/*istanbul ignore next: not part of code */ |
|
Instance.prototype.arr = []; |
|
|
|
var |
|
obj = { |
|
string: 'some string', |
|
array: ['some','array',[1,2,3]], |
|
number: 21, |
|
boolean: true, |
|
object: { |
|
some:'property', |
|
sub: { |
|
'property': true |
|
} |
|
}, |
|
instance: new Instance() |
|
}; |
|
|
|
/*istanbul ignore next: not part of code */ |
|
obj['function'] = function(){}; |
|
|
|
var model = objectPath(obj); |
|
|
|
model.empty(['array','2']); |
|
expect(obj.array[2]).to.deep.equal([]); |
|
|
|
model.empty('object.sub'); |
|
expect(obj.object.sub).to.deep.equal({}); |
|
|
|
model.empty('instance.test'); |
|
expect(obj.instance.test).to.equal(null); |
|
expect(Instance.prototype.test).to.be.a('function'); |
|
|
|
model.empty('string'); |
|
model.empty('number'); |
|
model.empty('boolean'); |
|
model.empty('function'); |
|
model.empty('array'); |
|
model.empty('object'); |
|
model.empty('instance'); |
|
|
|
expect(obj.string).to.equal(''); |
|
expect(obj.array).to.deep.equal([]); |
|
expect(obj.number).to.equal(0); |
|
expect(obj.boolean).to.equal(false); |
|
expect(obj.object).to.deep.equal({}); |
|
expect(obj.instance.notOwn).to.be.an('undefined'); |
|
expect(obj.instance.arr).to.be.an('array'); |
|
expect(obj['function']).to.equal(null); |
|
}); |
|
|
|
it('should delete deep paths', function(){ |
|
var obj = getTestObj(); |
|
var model = objectPath(obj); |
|
|
|
expect(model.del()).to.be.equal(obj); |
|
|
|
model.set('b.g.1.0', 'test'); |
|
model.set('b.g.1.1', 'test'); |
|
model.set('b.h.az', 'test'); |
|
|
|
expect(obj).to.have.deep.property('b.g.1.0','test'); |
|
expect(obj).to.have.deep.property('b.g.1.1','test'); |
|
expect(obj).to.have.deep.property('b.h.az','test'); |
|
|
|
model.del('b.h.az'); |
|
expect(obj).to.not.have.deep.property('b.h.az'); |
|
expect(obj).to.have.deep.property('b.h'); |
|
|
|
model.del('b.g.1.1'); |
|
expect(obj).to.not.have.deep.property('b.g.1.1'); |
|
expect(obj).to.have.deep.property('b.g.1.0','test'); |
|
|
|
model.del(['b','g','1','0']); |
|
expect(obj).to.not.have.deep.property('b.g.1.0'); |
|
expect(obj).to.have.deep.property('b.g.1'); |
|
|
|
expect(model.del(['b'])).to.not.have.deep.property('b.g'); |
|
expect(obj).to.be.deep.equal({'a':'b'}); |
|
}); |
|
|
|
it('should insert value into existing array', function(){ |
|
var obj = getTestObj(); |
|
var model = objectPath(obj); |
|
|
|
model.insert('b.c', 'asdf'); |
|
expect(obj).to.have.deep.property('b.c.0', 'asdf'); |
|
expect(obj).to.not.have.deep.property('b.c.1'); |
|
}); |
|
|
|
it('should test under shallow object', function() { |
|
var obj = getTestObj(); |
|
var model = objectPath(obj); |
|
|
|
expect(model.has('a')).to.be.true; |
|
expect(model.has(['a'])).to.be.true; |
|
expect(model.has('z')).to.be.false; |
|
expect(model.has(['z'])).to.be.false; |
|
}); |
|
|
|
});
|
|
|