test/Validator.test.js
/**
* The goal here is to have a minimum-viable test case here, in order to
* check changes in Validator.
*
* Changes in Validator should ideally be checked to see if they trigger here.
*
* test-console reference: https://github.com/jamesshore/test-console
*/
var assert = require('assert');
var stdout = require('test-console').stdout;
var Validator = require("../lib/shared/Validator").default;
// Copied from lib/network/options.js
let string = 'string';
let bool = 'boolean';
let number = 'number';
let array = 'array';
let object = 'object'; // should only be in a __type__ property
let dom = 'dom';
let any = 'any';
let allOptions = {
// simple options
enabled: { boolean: bool },
inherit: { string: ['from', 'to', 'both'] },
size: { number },
filter: { 'function': 'function' },
chosen: {
label: { boolean: bool },
edge: { 'function': 'function' },
__type__: { object }
},
chosen2: {
label: { string },
__type__: { object }
},
// Tests with any. These have been tailored to test all paths in:
// - Validator.check()
// - Validator.checkFields()
__any__: { string }, // Any option name allowed here, but it must be a string
// NOTE: you can have as many new options as you want! IS THIS INTENTIONAL?
groups: {
generic: { any },
__any__: { any },
__type__: { object }
},
// TODO: add combined options, e.g.
//inherit: { string: ['from', 'to', 'both'], boolean: bool },
//filter: { boolean: bool, string, array, 'function': 'function' },
__type__: { object }
};
describe('Validator', function() {
function run_validator(options, check_correct, definition = undefined) {
let errorFound;
let output;
if (definition === undefined) {
definition = allOptions;
}
output = stdout.inspectSync(function() {
errorFound = Validator.validate(options, definition);
});
if (check_correct) {
assert(!errorFound);
assert(output.length === 0, 'No error expected');
} else {
//console.log(output); //sometimes useful here
assert(errorFound, 'Validation should have failed');
assert(output.length !== 0, 'must return errors');
}
return output;
}
function testExpected(output, expectedErrors) {
for (let i = 0; i < expectedErrors.length; ++i) {
assert(expectedErrors[i].test(output[i]), 'Regular expression at index ' + i + ' failed');
}
assert(output.length === expectedErrors.length, 'Number of expected errors does not match returned errors');
}
it('handles regular options correctly', function(done) {
// Empty options should be accepted as well
run_validator({}, true);
// test values for all options
var options = {
enabled: true,
inherit: 'from',
size : 123,
filter : function() { return true; },
chosen : {
label: false,
edge :function() { return true; },
},
chosen2: {
label: "I am a string"
},
myNameDoesntMatter: "My type does",
groups : {
generic: "any type is good here",
dontCareAboutName: [0,1,2,3] // Type can also be anything
}
};
run_validator(options, true);
done();
});
it('rejects incorrect options', function(done) {
// All of the options are wrong, all should generate an error
var options = {
iDontExist: 42, // name is 'any' but type must be string
enabled : 'boolean',
inherit : 'abc',
size : 'not a number',
filter : 42,
chosen : 'not an object',
chosen2 : {
label : 123,
// Following test the working of Validator.getSuggestion()
iDontExist: 'asdf',
generic : "I'm not defined here",
labe : 42, // Incomplete name
labell : 123,
},
};
var output = run_validator(options, false);
// Sometimes useful: console.log(output);
// Errors are in the order as the options are defined in the object
let expectedErrors = [
/Invalid type received for "iDontExist"\. Expected: string\. Received \[number\]/,
/Invalid type received for "enabled"\. Expected: boolean\. Received \[string\]/,
/Invalid option detected in "inherit"\. Allowed values are:from, to, both not/,
/Invalid type received for "size"\. Expected: number\. Received \[string\]/,
/Invalid type received for "filter"\. Expected: function\. Received \[number\]/,
/Invalid type received for "chosen"\. Expected: object\. Received \[string\]/,
/Invalid type received for "label". Expected: string. Received \[number\]/,
// Expected results of Validator.getSuggestion()
/Unknown option detected: "iDontExist"\. Did you mean one of these:/,
/Unknown option detected: "generic"[\s\S]*Perhaps it was misplaced\? Matching option found at:/gm,
/Unknown option detected: "labe"[\s\S]*Perhaps it was incomplete\? Did you mean:/gm,
/Unknown option detected: "labell"\. Did you mean "label"\?/
];
testExpected(output, expectedErrors);
done();
});
/**
* Explicit tests on explicit 'undefined', to be really sure it works as expected.
*/
it('properly handles explicit `undefined`', function(done) {
// Option definitions with 'undefined'
let undefinedOptions = {
width : { number, 'undefined': 'undefined' },
undefOnly : { 'undefined': 'undefined' },
colorOptions : {
fill : { string },
stroke : { string, 'undefined': 'undefined' },
strokeWidth: { number },
__type__ : { string, object, 'undefined': 'undefined' }
},
moreOptions : {
hello : { string },
world : { string, 'undefined': 'undefined' },
__type__ : { object }
}
}
//
// Test good actual option values
//
let correct1 = {
width : 42,
colorOptions: 'I am a string',
moreOptions : {
hello: 'world',
world: '!'
}
}
var output = run_validator(correct1, true, undefinedOptions);
let correct2 = {
width : undefined,
colorOptions: {
fill : 'I am a string',
stroke: 'I am a string'
},
moreOptions : {
world: undefined
}
}
var output = run_validator(correct2, true, undefinedOptions);
let correct3 = {
width : undefined,
undefOnly : undefined,
colorOptions: undefined
}
var output = run_validator(correct3, true, undefinedOptions);
//
// Test bad actual option values
//
let bad1 = {
width : 'string',
undefOnly : 42,
colorOptions: 42,
moreOptions : undefined
}
var output = run_validator(bad1, false, undefinedOptions);
let expectedErrors = [
/Invalid type received for "width"\. Expected: number, undefined\. Received \[string\]/,
/Invalid type received for "undefOnly"\. Expected: undefined\. Received \[number\]/,
/Invalid type received for "colorOptions"\. Expected: string, object, undefined\. Received \[number\]/,
/Invalid type received for "moreOptions"\. Expected: object\. Received \[undefined\]/
];
testExpected(output, expectedErrors);
let bad2 = {
undefOnly : 'undefined',
colorOptions: {
fill: undefined
} ,
moreOptions: {
hello: undefined,
world: 42
}
}
var output = run_validator(bad2, false, undefinedOptions);
let expectedErrors2= [
/Invalid type received for "undefOnly"\. Expected: undefined\. Received \[string\]/,
/Invalid type received for "fill"\. Expected: string\. Received \[undefined\]/,
/Invalid type received for "hello"\. Expected: string\. Received \[undefined\]/,
/Invalid type received for "world"\. Expected: string, undefined\. Received \[number\]/
];
testExpected(output, expectedErrors2);
done();
});
});