rttc
Version:
Runtime type-checking for JavaScript.
190 lines (167 loc) • 7.43 kB
JavaScript
var util = require('util');
var assert = require('assert');
var _ = require('@sailshq/lodash');
var rttc = require('../');
describe('.typeInfo()', function() {
describe('when given a valid type schema', function (){
it('should always return an object', function() {
assert.strictEqual(typeof rttc.typeInfo(rttc.infer('foo')), 'object');
assert.strictEqual(typeof rttc.typeInfo(rttc.infer('')), 'object');
assert.strictEqual(typeof rttc.typeInfo(rttc.infer(2323)), 'object');
assert.strictEqual(typeof rttc.typeInfo(rttc.infer(true)), 'object');
assert.strictEqual(typeof rttc.typeInfo(rttc.infer({x:'foo',z: [{a:4}]})), 'object');
assert.strictEqual(typeof rttc.typeInfo(rttc.infer([1,2,3])), 'object');
});
/**
* Helper fn that asserts that a specific typeSchema
* @param {[type]} typeSchema [description]
* @param {[type]} expectedTypeId [description]
* @return {[type]} [description]
*/
var checkResultingTypeDef = function(typeSchema, expectedTypeId) {
assert.equal(typeof rttc.typeInfo(typeSchema),'object');
assert.strictEqual(rttc.typeInfo(typeSchema).id, expectedTypeId);
};
it('should recognize facets and patterns', function() {
checkResultingTypeDef(rttc.infer({a:3}), 'dictionary');
checkResultingTypeDef(rttc.infer({a:'asdg', b:23, c: true}), 'dictionary');
checkResultingTypeDef(rttc.infer({a:'asdg', b:23, c: {foo: 'bar'}}), 'dictionary');
checkResultingTypeDef(rttc.infer([3]), 'array');
checkResultingTypeDef(rttc.infer([3,4]), 'array');
checkResultingTypeDef(rttc.infer(['a']), 'array');
checkResultingTypeDef(rttc.infer(['a','b']), 'array');
checkResultingTypeDef(rttc.infer([true]), 'array');
checkResultingTypeDef(rttc.infer([false]), 'array');
checkResultingTypeDef(rttc.infer([false, false, true, false]), 'array');
checkResultingTypeDef(rttc.infer([false, null, 'a', -45.3, Infinity]), 'array');
checkResultingTypeDef(rttc.infer({a:'asdg', b:23, c: [{foo: ['bar']}]}), 'dictionary');
checkResultingTypeDef(rttc.infer([{a:'asdg', b:23, c: [true]}]), 'array');
checkResultingTypeDef(rttc.infer(['asdg', {b:23}]), 'array');
checkResultingTypeDef(rttc.infer([{a:'asdg', b:23, c: [{foo: ['bar']}]}]), 'array');
});
it('should recognize schemas with generic dictionaries', function() {
checkResultingTypeDef(rttc.infer({}), 'dictionary');
checkResultingTypeDef(rttc.infer({a:3}), 'dictionary');
checkResultingTypeDef(rttc.infer({a:'asdg'}), 'dictionary');
checkResultingTypeDef(rttc.infer({a:true}), 'dictionary');
});
it('should recognize schemas with generic arrays', function() {
checkResultingTypeDef(rttc.infer([]), 'array');
checkResultingTypeDef(rttc.infer([[]]), 'array');
checkResultingTypeDef(rttc.infer([[[]]]), 'array');
checkResultingTypeDef(rttc.infer([[[['a', 3, true]]]]), 'array');
checkResultingTypeDef(rttc.infer([{}]), 'array');
checkResultingTypeDef(rttc.infer([{a:[]}]), 'array');
checkResultingTypeDef(rttc.infer([{a:[[[[]]]], b: [[]] }]), 'array');
});
});
describe('when given an invalid type schema', function (){
it('should throw', function (){
assert.throws(function (){
typeof rttc.typeInfo('undefined');
});
assert.throws(function (){
typeof rttc.typeInfo(undefined);
});
assert.throws(function (){
typeof rttc.typeInfo(rttc.infer(null));
});
assert.throws(function (){
typeof rttc.typeInfo(rttc.infer(null));
});
assert.throws(function (){
typeof rttc.typeInfo(rttc.infer(Infinity));
});
assert.throws(function (){
typeof rttc.typeInfo(rttc.infer(-Infinity));
});
assert.throws(function (){
typeof rttc.typeInfo(rttc.infer(NaN));
});
assert.throws(function (){
typeof rttc.typeInfo(rttc.infer(new Error('wat')));
});
assert.throws(function (){
typeof rttc.typeInfo(rttc.infer(new Buffer('stuff')));
});
assert.throws(function (){
typeof rttc.typeInfo(rttc.infer(new Date('stuff')));
});
assert.throws(function (){
typeof rttc.typeInfo(rttc.infer(new Error('stuff')));
});
assert.throws(function (){
typeof rttc.typeInfo(rttc.infer(new RegExp('stuff')));
});
assert.throws(function (){
typeof rttc.typeInfo(rttc.infer(function foo(a,b){}));
});
});
});
describe('when explicitly given known rttc types', function (){
it('should recognize "json" and return type definition', function (){
assert.strictEqual(typeof rttc.typeInfo('json'), 'object');
assert.strictEqual(rttc.typeInfo('json').id, 'json');
});
it('should recognize "ref" and return type definition', function (){
assert.strictEqual(typeof rttc.typeInfo('ref'), 'object');
assert.strictEqual(rttc.typeInfo('ref').id, 'ref');
});
it('should recognize "lamda" and return type definition', function (){
assert.strictEqual(typeof rttc.typeInfo('lamda'), 'object');
assert.strictEqual(rttc.typeInfo('lamda').id, 'lamda');
});
it('should recognize "dictionary" and return type definition', function (){
assert.strictEqual(typeof rttc.typeInfo('dictionary'), 'object');
assert.strictEqual(rttc.typeInfo('dictionary').id, 'dictionary');
});
it('should recognize "array" and return type definition', function (){
assert.strictEqual(typeof rttc.typeInfo('array'), 'object');
assert.strictEqual(rttc.typeInfo('array').id, 'array');
});
it('should recognize "boolean" and return type definition', function (){
assert.strictEqual(typeof rttc.typeInfo('boolean'), 'object');
assert.strictEqual(rttc.typeInfo('boolean').id, 'boolean');
});
it('should recognize "number" and return type definition', function (){
assert.strictEqual(typeof rttc.typeInfo('number'), 'object');
assert.strictEqual(rttc.typeInfo('number').id, 'number');
});
it('should recognize "string" and return type definition', function (){
assert.strictEqual(typeof rttc.typeInfo('string'), 'object');
assert.strictEqual(rttc.typeInfo('string').id, 'string');
});
});
describe('when given unknown or invalid types', function (){
it('should not recognize "blah blah"', function (){
assert.throws(function (){
var typeDef = rttc.typeInfo('blah blah');
});
});
it('should not recognize arbitrary things which aren\'t strings', function (){
assert.throws(function (){
rttc.typeInfo(/weird stuff/gi);
});
assert.throws(function (){
rttc.typeInfo(new Error('whee'));
});
});
});
describe('when given an example you\'d normally use for type inference', function (){
it('should not recognize "*" and throw', function (){
assert.throws(function (){
var typeDef = rttc.typeInfo('*');
});
});
it('should not recognize "===" and throw', function (){
assert.throws(function (){
var typeDef = rttc.typeInfo('===');
});
});
it('should not recognize "->" and throw', function (){
assert.throws(function (){
var typeDef = rttc.typeInfo('->');
});
});
});
});