var assert = require('assert'), HashArray = require('../src/HashArray'), i = 0; describe('HashArray', function() { describe('new HashArray(keys) should work', function() { var ha = new HashArray(['key'], function(type) { it('Should callback with "construct"', function() { assert.equal(type, 'construct'); }); }); it('Should have a all.length of 0.', function() { assert.equal(ha.all.length, 0); }); it('Should have a map with no keys.', function() { for (var key in ha.map) assert.equal(true, false); }); var ha2 = new HashArray('key'); it('should work with a single key not wrapped in an array.', function() { assert.deepEqual(ha2.keyFields, ['key']); }); }); describe('add(items) should work with 1 item', function() { var ha = new HashArray(['key']); var item = { key: 'whatever' }; ha.callback = function(type, what) { it('Should have a "add" callback.', function() { assert.equal(type, 'add'); assert.strictEqual(what[0], item); }); }; ha.add(item); it('Should have a single item.', function() { assert.equal(ha.all.length, 1); }); it('Should map "whatever" to that item.', function() { assert.equal(ha.get('whatever'), item); }); it('Should not crash on the reserved keyword "constructor".', function() { assert.equal(ha.get('constructo'), undefined); }); it('Should return true to a collides for a similar object.', function() { assert.equal(ha.collides({key: 'whatever'}), true); }); it('Should return false to a collides for a non-similar object.', function() { assert.equal(ha.collides({otherKey: 'whatever'}), false); }); }); describe('add(items) should work with 2 item and duplicate keys', function() { var ha = new HashArray(['key1', 'key2']); var item1 = { key1: 'whatever', key2: 'whatever' }; var item2 = { key1: 'whatever', key2: 'whatever' }; ha.add(item1, item2); it('Should have a 2 items.', function() { assert.equal(ha.all.length, 2); }); it('Should map "whatever" to both items in proper order.', function() { assert.equal(ha.getAsArray('whatever')[0], item1); assert.equal(ha.getAsArray('whatever')[1], item2); }); it('Should return true to a collides for a similar object.', function() { assert.equal(ha.collides({key1: 'whatever'}), true); assert.equal(ha.collides({key2: 'whatever'}), true); }); }); describe('add(items) should work with 2 item and duplicate keys and options.ignoreDuplicates = true', function() { var ha = new HashArray(['key1', 'key2'], undefined, {ignoreDuplicates: true}); var item1 = { key1: 'whatever1', key2: 'whatever2' }; var item2 = { key1: 'whatever2', key2: 'whatever1' }; ha.add(item1, item2); it('Should have a 1 item.', function() { assert.equal(ha.all.length, 1); }); it('Should map "whatever1" to item1 only (first inserted).', function() { assert.equal(ha.getAsArray('whatever1').length, 1); }); it('Should map "whatever2" to item1 only (first inserted).', function() { assert.equal(ha.getAsArray('whatever2').length, 1); }); }); describe('add(items) should not allow addition of same item twice.', function() { var ha = new HashArray(['key']); var item = { key: 'whatever' }; ha.add(item); ha.add(item); ha.add(item); ha.add(item); it('Should have a single item.', function() { assert.equal(ha.all.length, 1); }); it('Should map "whatever" to that item.', function() { assert.equal(ha.get('whatever'), item); }); }); describe('add(items) should work with 1 item and multiple keys and key depths.', function() { var ha = new HashArray([ 'key', ['child', 'key'], ['child', 'key2'] ]); var item = { key: 'whatever', child: { key: 'deeeep', key2: 'sup' } }; ha.add(item); it('Should map "deeeep" to that item.', function() { assert.equal(ha.get('deeeep'), item); }); it('Should have the item be the same for all key lookups', function() { assert.equal(ha.get('deeeep'), ha.get('sup')); assert.equal(ha.get('sup'), ha.get('whatever')); }); }); describe('add(items) should work with > 1 item', function() { var ha = new HashArray(['key']); var item1 = { key: 'whatever' }, item2 = { key: 'whatever2' }, item3 = { key: 'whatever3' }, item4 = { key: 'whatever3' }; ha.callback = function(type, what) { it('Should have a "add" callback.', function() { assert.equal(type, 'add'); assert.strictEqual(what[0], item1); assert.strictEqual(what[1], item2); assert.strictEqual(what[2], item3); assert.strictEqual(what[3], item4); }); }; ha.add(item1, item2, item3, item4); it('Should have 3 items', function() { assert.equal(ha.all.length, 4); }); it('Should map "whatever" to item1', function() { assert.deepEqual(ha.get('whatever'), item1); }); it('Should map "whatever2" to item2', function() { assert.equal(ha.get('whatever2'), item2); }); it('Should map "whatever3" to item3', function() { assert.deepEqual(ha.get('whatever3'), [item3, item4]); }); }); describe('removeByKey(keys) should work with 1 item', function() { var ha = new HashArray(['key']); var item = { key: 'whatever' }; ha.add(item); ha.removeByKey('whatever'); it('Should have no items after remove by key', function() { assert.equal(ha.all.length, 0); }); it('Should have a map with no keys.', function() { for (var key in ha.map) assert.equal(key, undefined); }); }); describe('removeByKey(keys) should work with 1 item and multiple key depths', function() { var ha = new HashArray([ ['child', 'key'], ['child', 'key2'], 'key' ]); var item = { key: 'whatever', child: { key: 'deeeeep', key2: 'foobang' } }; ha.add(item); ha.removeByKey('deeeeep'); it('Should have no items after remove by key', function() { assert.equal(ha.all.length, 0); }); it('Should have a map with no keys.', function() { for (var key in ha.map) assert.equal(key, undefined); }); }); describe('removeByKey(keys) should work with 4 items', function() { var ha = new HashArray(['key']); var item1 = { key: 'whatever' }, item2 = { key: 'whatever2' }, item3 = { key: 'whatever3' }, item4 = { key: 'whatever3' }; console.log("START"); ha.add(item1, item2, item3, item4); ha.callback = function(type, what) { it('Should have a "removeByKey" callback.', function() { assert.equal(type, 'removeByKey'); assert.strictEqual(what[0], item3); assert.strictEqual(what[1], item4); }); }; ha.removeByKey('whatever3'); it('Should have 2 items after remove by key', function() { assert.equal(ha.all.length, 2); }); it('Should have no key for removed item (has)', function() { assert.equal(ha.has('whatever3'), false); }); it('Should have no key for removed item (get)', function() { assert.equal(ha.get('whatever3'), undefined); }); it('Should have remaining two items by key', function() { assert.equal(ha.get('whatever'), item1); assert.equal(ha.get('whatever2'), item2); }); }); describe('remove(items) should work with 1 item', function() { var ha = new HashArray(['key']); var item = { key: 'whatever' }; ha.add(item); ha.callback = function(type, what) { it('Should have a "remove" callback.', function() { assert.equal(type, 'remove'); assert.strictEqual(what[0], item); }); }; ha.remove(item); it('Should have no items after remove', function() { assert.equal(ha.all.length, 0); }); it('Should have a map with no keys.', function() { for (var key in ha.map) assert.equal(key, undefined); }); }); describe('remove(items) should work with 3 items', function() { var ha = new HashArray(['key']); var item1 = { key: 'whatever' }, item2 = { key: 'whatever2' }, item3 = { key: 'whatever3' }; ha.add(item1, item2, item3); ha.callback = function(type, what) { it('Should have a "remove" callback.', function() { assert.equal(type, 'remove'); assert.strictEqual(what[0], item2); }); }; ha.remove(item2); it('Should have 2 items after remove by key', function() { assert.equal(ha.all.length, 2); }); it('Should have no key for removed item (has)', function() { assert.equal(ha.has('whatever2'), false); }); it('Should have no key for removed item (get)', function() { assert.equal(ha.get('whatever2'), undefined); }); it('Should have remaining two items by key', function() { assert.equal(ha.get('whatever'), item1); assert.equal(ha.get('whatever3'), item3); }); }); describe('removeAll() should work', function() { var ha = new HashArray(['key']); var item1 = { key: 'whatever' }, item2 = { key: 'whatever2' }, item3 = { key: 'whatever3' }; ha.add(item1, item2, item3); ha.callback = function(type, what) { it('Should have a "remove" callback.', function() { assert.equal(type, 'remove'); assert.strictEqual(what[0], item1); assert.strictEqual(what[1], item2); assert.strictEqual(what[2], item3); }); it('Should have 0 items after removeAll', function() { assert.equal(ha.all.length, 0); }); it('Should have a map with no keys.', function() { for (var key in ha.map) assert.equal(key, undefined); }); }; ha.removeAll(); }); describe('removeAll() should work', function() { var ha = new HashArray(['key']); var item1 = { key: 'whatever' }, item2 = { key: 'whatever2' }, item3 = { key: 'whatever3' }; ha.add(item1, item2, item3); ha.callback = function(type, what) { it('Should have a "remove" callback.', function() { assert.equal(type, 'remove'); assert.strictEqual(what[0], item1); assert.strictEqual(what[1], item2); assert.strictEqual(what[2], item3); }); it('Should have 0 items after removeAll', function() { assert.equal(ha.all.length, 0); }); it('Should have a map with no keys.', function() { for (var key in ha.map) assert.equal(key, undefined); }); }; ha.removeAll(); }); describe('add should not allow adding of duplicate objects (single key)', function() { var ha = new HashArray('key'); var item1 = { key: 'whatever' }, item2 = { key: 'whatever2' }, item3 = { key: 'whatever3' }; ha.add(item1, item2, item3, item3); it('Length should be 3', function() { assert(ha.all.length == 3, 'Length was not 3, was ' + ha.all.length) }); }); describe('add should not allow adding of duplicate objects (multi key)', function() { var ha = new HashArray(['key1', 'key2']); var item1 = { key1: 'whatever2', key2: 'whatever3' }, item2 = { key1: 'whatever2' }, item3 = { key1: 'whatever3' }; ha.add(item1, item2, item3, item3); it('Length should be 3', function() { assert(ha.all.length == 3, 'Length was not 3, was ' + ha.all.length) }); }); describe('intersection(ha) should work with simple single-key hasharrays', function() { var ha1 = new HashArray('key'); var item1 = { key: 'whatever' }, item2 = { key: 'whatever2' }, item3 = { key: 'whatever3' }, item4 = { key: 'whatever4' }; ha1.add(item1, item2, item3); var ha2 = ha1.clone(null, true); ha2.add(item1, item3, item4); var intersection = ha1.intersection(ha2); it('Unioned hasharray should contain item1 and item3 only', function() { assert(intersection.all.length == 2); assert(intersection.collides(item1)); assert(!intersection.collides(item2)); assert(intersection.collides(item3)); assert(!intersection.collides(item4)); }); }); describe('intersection(ha) should work with simple multi-key hasharrays', function() { var ha1 = new HashArray(['key1', 'key2']); var item1 = { key1: 'whatever', key2: 'whatever4' }, item2 = { key1: 'whatever2' }, item3 = { key1: 'whatever3' }, item4 = { key1: 'whatever4' }; ha1.add(item1, item2, item3); var ha2 = ha1.clone(null, true); ha2.add(item1, item3, item4); var intersection = ha1.intersection(ha2); it('Unioned hasharray should contain item1, item3, and item4 because of the extra key', function() { assert(intersection.collides(item1), 'does not contain item1'); assert(!intersection.collides(item2), 'does contain item2'); assert(intersection.collides(item3), 'does not contain item3'); assert(intersection.collides(item4), 'does not contain item4'); }); }); describe('complement(ha) should work with simple multi-key hasharrays', function() { var ha1 = new HashArray(['key1', 'key2']); var item1 = { key1: 'whatever', key2: 'whatever4' }, item2 = { key1: 'whatever2' }, item3 = { key1: 'whatever3' }, item4 = { key1: 'whatever4' }; // Contains keys ['whatever', 'whatever2', 'whatever3', 'whatever4'] ha1.add(item1, item2, item3, item4); var ha2 = ha1.clone(null, true); // Contains keys ['whatever', 'whatever3', 'whatever4'] ha2.add(item1, item3); // SHOULD contain keys ['whatever2'] for item2 only. var complement = ha1.complement(ha2); it('Complemented hasharray should contain item2 only', function() { assert(!complement.collides(item1), 'does contain item1'); assert(complement.collides(item2), 'does not contain item2'); assert(!complement.collides(item3), 'does contain item3'); assert(!complement.collides(item4), 'does contain item4'); }); }); describe('getAll(keys) should work', function() { var ha = new HashArray(['firstName', 'lastName']); var person1 = {firstName: 'Victor', lastName: 'Victor'}, person2 = {firstName: 'Victor', lastName: 'Manning'}, person3 = {firstName: 'Manning', lastName: 'Victor'}; person4 = {firstName: 'John', lastName: 'Smith'}; ha.add(person1, person2, person3, person4); it('Should retrieve only items for the keys requested without duplicates.', function() { assert.equal(ha.getAll(['Victor', 'Smith']).length, 4); assert.equal(ha.getAll(['John', 'Smith']).length, 1); }); }); describe('forEach(keys, callback) should work', function() { var ha = new HashArray(['type']); var a = {type: 'airplane', data: {speed: 100, weight: 10000}}, b = {type: 'airplane', data: {speed: 50, weight: 20000}}, c = {type: 'airplane', data: {speed: 25, weight: 50000}}; d = {type: 'boat', data: {speed: 10, weight: 100000}}; e = {type: 'boat', data: {speed: 5, weight: 200000}}; ha.add(a, b, c, d, e); it('should work.', function() { var s = 0; ha.forEach('airplane', function (airplane) { s += airplane.data.speed; }); assert.equal(s, 175); }); it('should work (speed test boats).', function() { var s = 0; ha.forEach(['boat'], function (item) { s += item.data.speed; }); assert.equal(s, 15); }); it('should work (speed test all).', function() { var s = 0; ha.forEach(['airplane', 'boat'], function (item) { s += item.data.speed; }); assert.equal(s, 190); }); }); describe('forEachDeep(keys, key, callback) should work', function() { var ha = new HashArray(['type']); var a = {type: 'airplane', data: {speed: 100, weight: 10000}}, b = {type: 'airplane', data: {speed: 50, weight: 20000}}, c = {type: 'airplane', data: {speed: 25, weight: 50000}}; d = {type: 'boat', data: {speed: 10, weight: 100000}}; e = {type: 'boat', data: {speed: 5, weight: 200000}}; ha.add(a, b, c, d, e); it('should work (speed test airplanes).', function() { var s = 0; ha.forEachDeep('airplane', ['data', 'speed'], function (speed) { s += speed; }); assert.equal(s, 175); }); it('should work (speed test boats).', function() { var s = 0; ha.forEachDeep(['boat'], ['data', 'speed'], function (speed) { s += speed; }); assert.equal(s, 15); }); it('should work (speed test all).', function() { var s = 0; ha.forEachDeep(['airplane', 'boat'], ['data', 'speed'], function (speed) { s += speed; }); assert.equal(s, 190); }); }); describe('sum(keys, key) should work', function() { var ha = new HashArray(['type']); var a = {type: 'airplane', data: {speed: 100, weight: 10000}}, b = {type: 'airplane', data: {speed: 50, weight: 20000}}, c = {type: 'airplane', data: {speed: 25, weight: 50000}}; d = {type: 'boat', data: {speed: 10, weight: 100000}}; e = {type: 'boat', data: {speed: 5, weight: 200000}}; ha.add(a, b, c, d, e); it('should work (speed test airplanes).', function() { assert.equal(ha.sum('airplane', ['data', 'speed']), 175); }); it('should work (speed test boats).', function() { assert.equal(ha.sum(['boat'], ['data', 'speed']), 15); }); it('should work (speed test all).', function() { assert.equal(ha.sum(['airplane', 'boat'], ['data', 'speed']), 190); }); it('should work with weighted sums.', function() { assert.equal(ha.sum('boat', ['data', 'speed'], ['data', 'weight']), (10 * 100000) + (5 * 200000)); }); }); describe('average(keys, key, weight) should work', function() { var ha = new HashArray(['type']); var a = {type: 'airplane', data: {speed: 100, weight: 0.1}}, b = {type: 'airplane', data: {speed: 50, weight: 0.2}}, c = {type: 'airplane', data: {speed: 25, weight: 0.2}}; d = {type: 'boat', data: {speed: 10, weight: 0.2}}; e = {type: 'boat', data: {speed: 5, weight: 0.3}}; ha.add(a, b, c, d, e); it('should work (speed test airplanes).', function() { assert.equal(ha.average('airplane', ['data', 'speed']), 175 / 3); }); it('should work (speed test boats).', function() { assert.equal(ha.average(['boat'], ['data', 'speed']), 15 / 2); }); it('should work (speed test all).', function() { assert.equal(ha.average(['airplane', 'boat'], ['data', 'speed']), 190 / 5); }); it('should work with weighted average == 1.0.', function() { assert.equal(ha.average(['airplane', 'boat'], ['data', 'speed'], ['data', 'weight']), 28.5); }); it('should work with weighted average != 1.0.', function() { a.data.weight = 1.1; assert.equal(ha.average(['airplane', 'boat'], ['data', 'speed'], ['data', 'weight']), 64.25); }); }); describe('filter(keys, callback) should work and return new HashArray', function() { var ha = new HashArray(['type']); var a = {type: 'airplane', data: {speed: 100, weight: 0.1, mobile: true}}, b = {type: 'airplane', data: {speed: 50, weight: 0.2, mobile: true}}, c = {type: 'airplane', data: {speed: 25, weight: 0.2, mobile: false}}; d = {type: 'boat', data: {speed: 10, weight: 0.2, mobile: true}}; e = {type: 'boat', data: {speed: 5, weight: 0.3, mobile: true}}; ha.add(a, b, c, d, e); it('should return a new HashArray', function() { assert.equal(ha.filter('*', function (item) { return item.data.speed == 100; }).isHashArray, true); }); it('should return a new HashArray with the right length of items', function() { assert.equal(ha.filter('*', function (item) { return item.data.speed == 100; }).all.length, 1); }); it('should work with a key for the callback', function() { assert.equal(ha.filter('airplane', ['data', 'mobile']).all.length, 2); }); it('should work with a key for the callback for a non-existent key', function() { assert.equal(ha.filter('airplane', 'does not exist').all.length, 0); }); }); describe('methods without a standard return should return this.', function() { var ha = new HashArray('type'); var item = {type: 'blah'}; it('add(...) should return this', function() { assert(ha.add(item) === ha); }); it('addAll(...) should return this', function() { assert(ha.addAll([{type: 'blah2'}]) === ha); }); it('remove(...) should return this', function() { assert(ha.remove(item) === ha); }); it('removeByKey(...) should return this', function() { assert(ha.removeByKey('blah2') === ha); }); }); });