StackGenVis/frontend/node_modules/cint/test/spec.js

var assert = require('chai').assert
var cint = require('../src/cint.js')

/***********************************
 * String
 ***********************************/

describe('supplant', function() {

	it('should supplant an array by index', function() {
		assert.equal(cint.supplant('{0} walks his {1} in the {2}.', 
			['Jim', 'dinosaur', 'park']), 
			'Jim walks his dinosaur in the park.')
	})

	it('should supplant an object by key', function() {
		assert.equal(cint.supplant('{owner} walks his {pet} in the {place}.', 
			{ owner: 'Jim', pet: 'dinosaur', place: 'park' }), 
			'Jim walks his dinosaur in the park.', 
			'Supplant with object by key')
	})

	it('should ignore non-existant keys', function() {
		assert.equal(cint.supplant('{owner} walks his {pet} in the {place}.', 
			{ owner: 'Jim', pet: 'dinosaur' }), 
			'Jim walks his dinosaur in the {place}.', 
			'Ignores non-existant keys')
	})

	it('should toString all values to be interpolated', function() {
		var Dino = function() {}
		Dino.prototype.toString = function() { return 'dinosaur' }
		assert.equal(cint.supplant('{owner} walks his {pet}.', 
			{ owner: 'Jim', pet: new Dino() }), 
			'Jim walks his dinosaur.'
		)
	})
})

describe('startsWith', function() {
	it('abc starts with a', function() {
		assert.equal(cint.startsWith('abc', 'a'), true)
	})
	it('abc doesn\'t start with c', function() {
		assert.equal(cint.startsWith('abc', 'c'), false)
	})
	it('Testing if something starts with empty string is always false.', function() {
		assert.equal(cint.startsWith('abc', ''), false)
	})
})

describe('before', function() {
	it('Return the substring before the given delimiter', function() {
		assert.equal(cint.before('ab,cd,ef', ','), 'ab')
	})
})

describe('after', function() {
	it('Return the substring after the first given delimiter', function() {
		assert.equal(cint.after('ab,cd,ef', ','), 'cd,ef')
	})
})

describe('between', function() {
	it('Return the substring between the given two delimiters', function() {
		assert.equal(cint.between('abcdef', 'ab', 'ef'), 'cd')
	})
})

describe('bookend', function() {
	it('Add a string to the beginning and a string to the end of a string.', function() {
		assert.equal(cint.bookend('b', 'a', 'c'), 'abc')
	})
	it('Wrap a string with another string', function() {
		assert.equal(cint.bookend('b', 'a'), 'aba')
	})
	it('Ignores falsey begin and end values', function() {
		assert.equal(cint.bookend('b'), 'b')
	})
})

describe('repeatString', function() {
	it('Repeat a string n times', function() {
		assert.equal(cint.repeatString('abc', 3), 'abcabcabc')
	})
	it('Repeating a string 0 times returns an empty string', function() {
		assert.equal(cint.repeatString('abc', 0), '')
	})
})

describe('toTitleCase', function() {
	it('Capitalize the first letter of each word in a sentence', function() {
		assert.equal(cint.toTitleCase('this is a test'), 'This Is A Test')
	})
	it('Lowercase the rest', function() {
		assert.equal(cint.toTitleCase('tHis is A tEst'), 'This Is A Test')
	})
	it('Do not alter punctuation.', function() {
		assert.equal(cint.toTitleCase('don\'t fail the test.'), 'Don\'t Fail The Test.')
	})
})


/***********************************
 * Number
 ***********************************/

describe('ordinal', function() {
	it('should add the correct ordinal', function() {
		assert.equal(cint.ordinal(1), '1st')
		assert.equal(cint.ordinal(2), '2nd')
		assert.equal(cint.ordinal(3), '3rd')
		assert.equal(cint.ordinal(4), '4th')
		assert.equal(cint.ordinal(5), '5th')
		assert.equal(cint.ordinal(6), '6th')
		assert.equal(cint.ordinal(7), '7th')
		assert.equal(cint.ordinal(8), '8th')
		assert.equal(cint.ordinal(9), '9th')
		assert.equal(cint.ordinal(10), '10th')
		assert.equal(cint.ordinal(11), '11th')
		assert.equal(cint.ordinal(12), '12th')
		assert.equal(cint.ordinal(13), '13th')
		assert.equal(cint.ordinal(14), '14th')
		assert.equal(cint.ordinal(15), '15th')
		assert.equal(cint.ordinal(16), '16th')
		assert.equal(cint.ordinal(17), '17th')
		assert.equal(cint.ordinal(18), '18th')
		assert.equal(cint.ordinal(19), '19th')
		assert.equal(cint.ordinal(20), '20th')
		assert.equal(cint.ordinal(21), '21st')
		assert.equal(cint.ordinal(22), '22nd')
		assert.equal(cint.ordinal(23), '23rd')
		assert.equal(cint.ordinal(24), '24th')
		assert.equal(cint.ordinal(100), '100th')
		assert.equal(cint.ordinal(101), '101st')
		assert.equal(cint.ordinal(102), '102nd')
		assert.equal(cint.ordinal(103), '103rd')
		assert.equal(cint.ordinal(104), '104th')
	})
})

describe('mapNumber', function() {
	it('should map numbers', function() {
		var xTwo = function(n) { return n*2 }
		assert.deepEqual(cint.mapNumber(3, xTwo), [0, 2, 4])
	})
})

describe('addTwo', function() {
	it('Add two numbers.', function() {
		assert.equal(cint.addTwo(4,5), 9)
	})
})

describe('add', function() {
	it('No arguments returns 0', function() {
		assert.equal(cint.add(), 0)
	})
	it('1 argument returns the argument', function() {
		assert.equal(cint.add(1), 1)
	})
	it('2 arguments are added', function() {
		assert.equal(cint.add(1,2), 3)
	})
	it('More than 2 arguments are added', function() {
		assert.equal(cint.add(1,2,3), 6)
	})
})

/***********************************
 * Array
 ***********************************/

// test('orderedGroup', function() {
// })

// test('tally', function() {
// })

describe('tallyProps', function() {
	it('should tally property values', function() {

		var data = [
			{
				ideal: 4,
				past: 3,
				present: 7
			},
			{
				ideal: 3,
				past: 7,
				present: 7
			}
		]

		var expectedTallies = {
			"4": {
				ideal: 1
			},
			"3": {
				past: 1,
				ideal: 1
			},
			"7": {
				present: 2,
				past: 1
			}
		}

		assert.deepEqual(cint.tallyProps(data), expectedTallies)

	})
})

describe('index', function() {
	var arr = [1,2,3,4,5]
	it('Index into an array as normal', function() {
		assert.equal(cint.index(arr, 2), 3)
	})
	it('Negative index', function() {
		assert.equal(cint.index(arr, -1), 5)
	})
	it('Out of bounds index', function() {
		assert.equal(cint.index(arr, 16), 2)
	})

	var str = 'abcde'
	it('Index into an array-like object as normal', function() {
		assert.equal(cint.index(str, 2), 'c')
	})
	it('Negative index of array-like object', function() {
		assert.equal(cint.index(str, -1), 'e')
	})
	it('Out of bounds index of array-like object', function() {
		assert.equal(cint.index(str, 16), 'b')
	})
})

describe('rotate', function() {
	var arr = ['a', 'b', 'c']
	var resultArr = cint.rotate(arr, 0)
	it('Rotate array 0 spaces.', function() {
		assert.deepEqual(resultArr, ['a', 'b', 'c'])
	})
	it('Rotate array 1 space to the left.', function() {
		assert.deepEqual(cint.rotate(['a', 'b', 'c'], 1), ['b', 'c', 'a'])
	})
	it('Returns a new array instance', function() {
		assert.notEqual(arr, resultArr)
	})
	it('Does not modify the original array', function() {
		assert.deepEqual(arr, ['a', 'b', 'c'])
	})
	it('Rotate an array more spaces than its length.', function() {
		assert.deepEqual(cint.rotate(['a', 'b', 'c'], 5), ['c', 'a', 'b'])
	})
	it('Rotate array 1 space to the left.', function() {
		assert.deepEqual(cint.rotate(['a', 'b', 'c'], -1), ['c', 'a', 'b'])
	})
})

describe('toObject', function() {
	it('should convert an array to an object', function() {
		var animals = ['cat', 'dog', 'gecko']
		var pluralAnimals = cint.toObject(animals, function(animal) {
			return cint.keyValue(animal, animal + 's')
		})
		assert.deepEqual(pluralAnimals, {
			cat: 'cats',
			dog: 'dogs',
			gecko: 'geckos'
		})
	})
})

describe('spliced', function() {
	var arr = [1,2,3,4,5]
	it('should splice an array', function() {
		assert.deepEqual(cint.spliced(arr, 2, 1, 100, 200, 300), [1,2,100,200,300,4,5])
	})
	it('Original array is unchanged.', function() {
		assert.deepEqual(arr, [1,2,3,4,5])
	})
})

describe('chunk', function() {
	var arr = [1,2,3,4,5,6,7,8,9,10]
	it('should split an array into chunks', function() {
		assert.deepEqual(cint.chunk(arr, 1), [[1,2,3,4,5,6,7,8,9,10]])
		assert.deepEqual(cint.chunk(arr, 2), [[1,2,3,4,5], [6,7,8,9,10]])
		assert.deepEqual(cint.chunk(arr, 3), [[1,2,3,4], [5,6,7], [8,9,10]])
		assert.deepEqual(cint.chunk(arr, 7), [[1,2], [3,4], [5,6], [7], [8], [9], [10]])
		assert.deepEqual(cint.chunk(arr, 10), [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]])
	})
	it('Original array is unchanged', function() {
		assert.deepEqual(arr, [1,2,3,4,5,6,7,8,9,10])
	})
})


/***********************************
 * Object
 ***********************************/

// object
describe('keyValue', function() {
	it('Creates a key-value pair.', function() {
		assert.deepEqual(cint.keyValue('a',1), {a:1})
	})
	it('Creates a new object instance each time.', function() {
		assert.notEqual(cint.keyValue('a',1), cint.keyValue('a',1))
	})
})

describe('getValue', function() {
	var o = {a:1}
	it('Gets the value of a key of the gven object', function() {
		assert.equal(cint.getValue(o, 'a'), 1)
	})
})

describe('setValue', function() {
	var o = {a:1}
	it('Sets the value of the given existing key', function() {
		cint.setValue(o, 'a', 2)
		assert.deepEqual(o, {a:2})
	})

	it('Sets the value of the given new key', function() {
		cint.setValue(o, 'b', 10)
		assert.deepEqual(o, {a:2, b:10})
	})

	it('Returns the object', function() {
		assert.equal(cint.setValue(o, 'a', 10), o)
	})
})

describe('mapOverKey', function() {
	
	var increment = function(n) { return ++n }
	var people = [
		{ name: 'Bob', age: 26 },
		{ name: 'Tia', age: 32 },
		{ name: 'José', age: 40 }
	]
	it('Maps the given function over the values of a key', function() {
		var olderPeople = [
			{ name: 'Bob', age: 27 },
			{ name: 'Tia', age: 33 },
			{ name: 'José', age: 41 }
		]
		var incrementAge = cint.mapOverKey(increment, 'age')
		assert.deepEqual(people.map(incrementAge), olderPeople)
	})

	it('Maps the given function over the values of a key and assigns them to a new key', function() {
		var nextPeople = [
			{ name: 'Bob', age: 27, nextAge: 28 },
			{ name: 'Tia', age: 33, nextAge: 34 },
			{ name: 'José', age: 41, nextAge: 42 }
		]
		var incrementNextAge = cint.mapOverKey(increment, 'age', 'nextAge')
		assert.deepEqual(people.map(incrementNextAge), nextPeople)
	})

})

describe('joinObject', function() {
	var o = { a: 1, b: 2, c: 3 }
	it('Join object keys and values together into a string', function() {
		assert.equal(cint.joinObject(o, '&', '='), 'a=1&b=2&c=3')
	})
	it('Empty object gets joined into an empty string', function() {
		assert.equal(cint.joinObject({}, '&', '='), '')
	})
})

describe('mapObject', function() {
	it('should map an object to an object with new key/values', function() {
		var o = { a: 1, b: 2, c: 3 }
		var swap = function(k,v) { return cint.keyValue(v,k) }
		assert.deepEqual(cint.mapObject(o, swap), { '1': 'a', '2': 'b', '3': 'c' })
	})
})

describe('toArray', function() {
	var o = { a: 1, b: 2, c: 3 }
	it('should convert an object to an array', function() {
		assert.deepEqual(cint.toArray(o, function(key, value) {
			return key + '-' + value
		}), ['a-1', 'b-2', 'c-3'])
	})

	it('should convert an object to an array of { key: ____, value: ____ } objects if no function is given.', function() {
		assert.deepEqual(cint.toArray(o), [
			{ key: 'a', value: 1 },
			{ key: 'b', value: 2 },
			{ key: 'c', value: 3 }
		])
	})
})

describe('filterObject', function() {
	var o = { a: 1, b: 2, c: 3 }

	it('Filter an object based on its keys and values', function() {
		assert.deepEqual(cint.filterObject(o, function(key, value) {
			return key !== 'b' && value !== 3
		}), { a: 1 })
	})

	it('Original object is not modified.', function() {
		assert.deepEqual(o, { a: 1, b: 2, c: 3 })
	})
})

describe('changeKeys', function() {
	// Assertions, ok, equal, notEqual, deepEqual, notDeepEqual, strictEqual, notStrictEqual
	var oldObject = { fname: 'Raine', lname: 'Lourie', specialty: 'Javascript' }
	var newObject = cint.changeKeys( oldObject, { fname: 'first', lname: 'last' })
	it('Old object is unmodified.', function() {
		assert.deepEqual(oldObject, { fname: 'Raine', lname: 'Lourie', specialty: 'Javascript' })
	})
	it('New object ontains modified keys.', function() {
		assert.deepEqual(newObject, { first: 'Raine', last: 'Lourie', specialty: 'Javascript' })
	})

})

describe('tap', function() {
	
	var o = { a: 10 }
	var incrementA = function(o) { o.a++ }

	it('Returns the given object', function() {
		assert.equal(cint.tap(incrementA, o), o)
	})
	it('Invokes the given function on the object', function() {
		assert.deepEqual(o, { a: 11 })
	})

})

describe('look', function() {
	it('Returns the argument', function() {
		assert.equal(cint.look('test:look'), 'test:look')
	})
	// Cant' really test the console.log
})


/***********************************
 * Function
 ***********************************/

describe('not', function() {
	var yes = function() { return true }
	var no = function() { return false }
	var I = function(x) { return x }
	it('Reverses true to false.', function() {
		assert.equal(cint.not(yes)(), false)
	})
	it('Reverses false to true.', function() {
		assert.equal(cint.not(no)(), true)
	})
	it('Works with arguments.', function() {
		assert.equal(cint.not(I)(true), false)
	})
	it('Works with arguments.', function() {
		assert.equal(cint.not(I)(false), true)
	})
	it('Works with non-booleans.', function() {
		assert.equal(cint.not(I)('a'), false)
	})
	it('Works with non-booleans', function() {
		assert.equal(cint.not(I)(undefined), true)
	})
})

describe('partialAt', function() {
	var subtract = function(x,y) { return x - y }
	it('Inject arguments at the beginning.', function() {
		var subtractFromTen = cint.partialAt(subtract, 0, [10])
		assert.equal(subtractFromTen(1), 9)
	})

	it('Inject arguments in the middle.', function() {
		var subtractTen = cint.partialAt(subtract, 1, [10])
		assert.equal(subtractTen(100), 90)
	})

	it('Handles negative indexes', function() {
		var subtractTwenty = cint.partialAt(subtract, -1, [20])
		assert.equal(subtractTwenty(100), 80)
	})
})

describe('aritize', function() {
	it('should limit the arity of a function', function() {
		var joinEm = function() { 
			var givenArgs = Array.prototype.slice.call(arguments, 0)
			return givenArgs.join('')
		}
		var joinTwo = cint.aritize(joinEm, 2)
		assert.equal(joinTwo('a', 'b', 'c', 'd', 'e'), 'ab')
	})
})

// describe('callTillValue', function() {
// })

describe('spy', function() {
	it('should call a custom log function', function(done) {
		
		function add(x, y) { return x + y }

		function log(f, args, out) { 
			assert.equal(f, add, 'first argument is the function')
			assert.deepEqual(args, [1,2], 'second argument is an array of arguments to that function')
			assert.equal(out, 3, 'third argument is the return value of the function')
			done()
		}

		cint.spy(add, log)(1,2)
	})
})

describe('inContext', function() {
	var person = { name: 'Cecil' }
	it('calls the given function in the context of the first argument', function() {
		var getName = function() { return this.name }
		var getNameInContext = cint.inContext(getName)
		assert.equal(getNameInContext(person), 'Cecil')
	})

	it('passes other arguments as normal', function() {
		var greet = function(greeting) { return greeting + ' ' + this.name }
		var greetInContext = cint.inContext(greet)
		assert.equal(greetInContext(person, 'Hi'), 'Hi Cecil')
	})
})

describe('toAsync', function() {
	it('should return a function that invokes the given function and passes its results to a node-style callback', function(done) {
		function add(x, y) { return x + y }
		var addAsync = cint.toAsync(add)

		addAsync(1, 2, function(error, result) {
			assert.notOk(error, 'error is null when successful')
			assert.equal(result, 3, 'gives the result in a callback')
			done()
		})
	})
	it('pass error as first argument to callback', function(done) {
		function toss() { throw new Error('Got tossed') }
		var tossAsync = cint.toAsync(toss)

		tossAsync(function(error, result) {
			assert.instanceOf(error, Error)
			assert.equal(error.message, 'Got tossed')
			assert.notOk(result, 'no result')
			done()
		})
	})
})


/***********************************
 * Utility
 ***********************************/

describe('compare', function() {
	it('Returns 1 if a > b', function() {
		assert.equal(cint.compare(2,1), 1)
	})
	it('Returns 0 if a == b', function() {
		assert.equal(cint.compare(1,1), 0)
	})
	it('Returns -1 if a < b', function() {
		assert.equal(cint.compare(1,2), -1)
	})
	it('Returns 1 if a > b for strings', function() {
		assert.equal(cint.compare('ace', 'Ann'), 1)
	})
	it('Returns 0 if a == b for strings', function() {
		assert.equal(cint.compare('ace', 'ace'), 0)
	})
	it('Returns -1 if a < b for strings', function() {
		assert.equal(cint.compare('Ann', 'ace'), -1)
	})
})

describe('compareProperty', function() {
	var small = { n: 1 }
	var big = { n: 2 }
	var compareN = cint.compareProperty.bind(cint, 'n')
	it('Returns 1 if a > b', function() {
		assert.equal(compareN(big, small), 1)
	})
	it('Returns 0 if a == b', function() {
		assert.equal(compareN(big, big), 0)
	})
	it('Returns -1 if a < b', function() {
		assert.equal(compareN(small, big), -1)
	})
})

// test('dynamicCompare', function() {
// })

// test('equals', function() {
// })

describe('isValue', function() {
	it('false is not valueful', function() {
		assert.equal(cint.isValue(null), false)
	})
	it('undefined is not valueful', function() {
		assert.equal(cint.isValue(undefined), false)
	})
	it('empty string is not valueful', function() {
		assert.equal(cint.isValue(''), false)
	})
	it('0 is valueful', function() {
		assert.equal(cint.isValue(0), true)
	})
	it('1 is valueful', function() {
		assert.equal(cint.isValue(1), true)
	})
	it('false is valueful', function() {
		assert.equal(cint.isValue(false), true)
	})
	it('true is valueful', function() {
		assert.equal(cint.isValue(true), true)
	})
	it('a string is valueful', function() {
		assert.equal(cint.isValue('test'), true)
	})
})

// test('hash', function() {
// })

// test('guid', function() {
// })

describe('typeOf', function() {
	it('should work for null', function() {
		assert.equal(cint.typeOf(null), 'null')
	})
	it('should work for undefined', function() {
		assert.equal(cint.typeOf(undefined), 'undefined')
	})
	it('should work for string', function() {
		assert.equal(cint.typeOf('test'), 'string')
	})
	it('should work for number', function() {
		assert.equal(cint.typeOf(1), 'number')
		assert.equal(cint.typeOf(NaN), 'number')
	})
	it('should work for array', function() {
		assert.equal(cint.typeOf([]), 'array')
	})
	it('should work for object', function() {
		assert.equal(cint.typeOf({}), 'object')
	})
	it('should work for function', function() {
		assert.equal(cint.typeOf(function(){}), 'function')
	})
})

describe('new', function() {
	it('should create an instance using the given constructor', function() {
		var Person = function(name, age) {
			this.name = name
			this.age = age
		}
		var p = cint.new(Person, ['Raine', 26])
		assert.instanceOf(p, Person)
		assert.equal(p.name, 'Raine')
		assert.equal(p.age, 26)
	})
})

describe('intoString', function() {
	it('Converts a number to a string', function() {
		assert.equal(cint.intoString(4), '4')
	})
	it('Converts a boolean to a string', function() {
		assert.equal(cint.intoString(true), 'true')
	})
	it('should throw a TypeError if null is passed', function() {
		assert.throws(function() { cint.intoString(null) }, 'Cannot read property \'toString\' of null')
	})
	it('should throw a TypeError if undefined is passed', function() {
		assert.throws(
			cint.intoString.bind(cint, undefined), 'Cannot read property \'toString\' of undefined')
	})
})