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.
265 lines
7.9 KiB
265 lines
7.9 KiB
/**
|
|
* 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();
|
|
});
|
|
});
|