class-o-mat
Version:
ALPHA VERSION ONLY: class-o-mats will help to create getter-setter functionality with validations that can be attached to a container class for easier coding. Some basic validations are included. class-o-mats also has the ability to store params as bloc
315 lines (281 loc) • 10.2 kB
JavaScript
import Bunyan from 'bunyan';
const log = Bunyan.createLogger({name: "ValidationTest"});
import 'mocha';
import { expect } from 'chai';
import { NONE,
TEST_CLASS,
CLASS_O_MAT,
FIELD_O_MAT,
CHILD_ADDER,
COPY,
STACK,
QUEUE
} from '../src/constants';
import ClassOMat from '../src/class-o-mat';
describe(`Test of creating params with validation.`,
()=> {
class TestClass {
TYPE = 'TEST'
}
var classOMat;
var testClass;
it(`create a basic classOMat-created class`,
()=>{
classOMat = new ClassOMat();
classOMat.BaseClass(TestClass)
.$();
testClass = new (classOMat.$())();
expect(classOMat.TYPE).to.equal(CLASS_O_MAT);
expect(testClass.TYPE).to.equal('TEST');
}
);
it(`test int field`,
()=>{
classOMat.field('int').validate().int()
.$().$();
testClass = new (classOMat.$())();
testClass.int(3);
const setErr =()=>testClass.int(true);
const setErrFloat =()=>testClass.int(3.4);
expect(testClass.TYPE).to.equal('TEST');
expect(typeof testClass.int()).to.equal('number');
expect(Number.isInteger(testClass.int())).to.equal(true);
expect(setErr).to.throw(Error);
expect(setErrFloat).to.throw(Error);
}
);
it(`test NOT int field`,
()=>{
classOMat.field('intNot').validate().not().int()
.$().$();
testClass = new (classOMat.$())();
testClass.intNot('3');
const setErr =()=>testClass.intNot(true);
const setErrFloat =()=>testClass.intNot(3.4);
expect(testClass.TYPE).to.equal('TEST');
expect(typeof testClass.intNot()).to.equal('string');
expect(Number.isInteger(testClass.intNot())).to.equal(false);
expect(setErr).to.not.throw(Error);
expect(setErrFloat).to.not.throw(Error);
}
);
it(`test method field`,
()=>{
classOMat.field('method').validate().method()
.$().$();
testClass = new (classOMat.$())();
testClass.method(()=>true);
const setErr =()=>testClass.method(true);
expect(testClass.TYPE).to.equal('TEST');
expect(typeof testClass.method()).to.equal('function');
expect(setErr).to.throw(Error);
}
);
it(`test number field`,
()=>{
classOMat.field('number').validate().number()
.$().$();
testClass = new (classOMat.$())();
testClass.number(52.6);
const setErr =()=>testClass.number(true);
expect(testClass.TYPE).to.equal('TEST');
expect(typeof testClass.number()).to.equal('number');
expect(setErr).to.throw(Error);
}
);
it(`test string field`,
()=>{
classOMat.field('string').validate().string()
.$().$();
testClass = new (classOMat.$())();
testClass.string('bet');
const setErr =()=>testClass.string(true);
expect(testClass.TYPE).to.equal('TEST');
expect(typeof testClass.string()).to.equal('string');
expect(setErr).to.throw(Error);
}
);
it(`test equal field`,
()=>{
classOMat.field('equal').validate().equal(1970)
.$().$();
testClass = new (classOMat.$())();
testClass.equal(1970);
const setErr =()=>testClass.equal(2000);
const setErrType =()=>testClass.equal("1970");
expect(testClass.TYPE).to.equal('TEST');
expect(typeof testClass.equal()).to.equal('number');
expect(setErr).to.throw(Error);
expect(setErrType).to.throw(Error);
}
);
it(`test equalish field`,
()=>{
classOMat.field('equalIsh').validate().equalIsh(1970)
.$().$();
testClass = new (classOMat.$())();
testClass.equalIsh(1970);
const setErr =()=>testClass.equalIsh(2000);
const setErrType =()=>testClass.equalIsh("1970");
expect(testClass.TYPE).to.equal('TEST');
expect(typeof testClass.equalIsh()).to.equal('number');
expect(setErr).to.throw(Error);
expect(setErrType).to.not.throw(Error);
}
);
it(`test greater than field`,
()=>{
classOMat.field('gt').validate().greaterThan(1970)
.$().$();
testClass = new (classOMat.$())();
testClass.gt(1971);
const setErr =()=>testClass.gt(1970);
const setErrType =()=>testClass.gt("1971");
expect(testClass.TYPE).to.equal('TEST');
expect(typeof testClass.gt()).to.equal('number');
expect(setErr).to.throw(Error);
expect(setErrType).to.not.throw(Error);
}
);
it(`test greater than or equal field`,
()=>{
classOMat.field('gte').validate().greaterThanOrEqual(1970)
.$().$();
testClass = new (classOMat.$())();
testClass.gte(1971);
const setErr =()=>testClass.gte(1970);
const setErrType =()=>testClass.gte("1970");
expect(testClass.TYPE).to.equal('TEST');
expect(typeof testClass.gte()).to.equal('number');
expect(setErr).to.not.throw(Error);
expect(setErrType).to.not.throw(Error);
}
);
it(`test less than field`,
()=>{
classOMat.field('lt').validate().lessThan(1970)
.$().$();
testClass = new (classOMat.$())();
testClass.lt(1000);
const setErr =()=>testClass.lt(1970);
const setErrType =()=>testClass.lt("1000");
expect(testClass.TYPE).to.equal('TEST');
expect(typeof testClass.lt()).to.equal('number');
expect(setErr).to.throw(Error);
expect(setErrType).to.not.throw(Error);
}
);
it(`test less than or equal field`,
()=>{
classOMat.field('lte').validate().greaterThanOrEqual(1970)
.$().$();
testClass = new (classOMat.$())();
testClass.lte(1971);
const setErr =()=>testClass.lte(1970);
const setErrType =()=>testClass.lte("1970");
expect(testClass.TYPE).to.equal('TEST');
expect(typeof testClass.lte()).to.equal('number');
expect(setErr).to.not.throw(Error);
expect(setErrType).to.not.throw(Error);
}
);
it(`test and functionality`,
()=>{
classOMat.field('and').validate().greaterThanOrEqual(1970).and().number()
.$().$();
testClass = new (classOMat.$())();
testClass.and(1971);
const setErr =()=>testClass.and(1970);
const setErrType =()=>testClass.and("1970");
expect(testClass.TYPE).to.equal('TEST');
expect(typeof testClass.and()).to.equal('number');
expect(setErr).to.not.throw(Error);
expect(setErrType).to.throw(Error);
}
);
it(`test or functionality`,
()=>{
classOMat.field('or').validate().equal(42).or().equal(72)
.$().$();
testClass = new (classOMat.$())();
testClass.or(42);
const setErr =()=>testClass.or(1970);
const set72Err =()=>testClass.or(72);
const setErrType =()=>testClass.or("1970");
expect(testClass.TYPE).to.equal('TEST');
expect(typeof testClass.or()).to.equal('number');
expect(setErr).to.throw(Error);
expect(set72Err).to.not.throw(Error);
expect(setErrType).to.throw(Error);
}
);
it(`test arbitrary validator`,
()=>{
const validator = (value)=>value === 'Clara';
classOMat.field('clara').validate().withFunction(validator)
.$().$();
testClass = new (classOMat.$())();
testClass.clara('Clara');
const setErr =()=>testClass.clara(1970);
const setErr2 =()=>testClass.clara("1970");
expect(testClass.TYPE).to.equal('TEST');
expect(typeof testClass.clara()).to.equal('string');
expect(setErr).to.throw(Error);
expect(setErr2).to.throw(Error);
}
);
it(`test arbitrary validator with and`,
()=>{
const validator = (value)=>["1970", "2001", "42"].indexOf(value) !== -1;
classOMat.field('claraBow').validate()
.withFunction(validator)
.and()
.string()
.$().$();
testClass = new (classOMat.$())();
testClass.claraBow('1970');
const setErr =()=>testClass.claraBow('foxy');
const setErrType =()=>testClass.claraBow(1970);
expect(testClass.TYPE).to.equal('TEST');
expect(typeof testClass.claraBow()).to.equal('string');
expect(setErr).to.throw(Error);
expect(setErrType).to.throw(Error);
}
);
it(`test selectList`,
()=>{
classOMat.field('claraBow').validate()
.selectList("1970", "2001", "42")
.and()
.string()
.$().$();
testClass = new (classOMat.$())();
testClass.claraBow('1970');
const setErr =()=>testClass.claraBow('foxy');
const setErrType =()=>testClass.claraBow(1970);
expect(testClass.TYPE).to.equal('TEST');
expect(typeof testClass.claraBow()).to.equal('string');
expect(setErr).to.throw(Error);
expect(setErrType).to.throw(Error);
}
);
it(`test a validator with callbacks`,
()=>{
let validated;
const onAgeValidate =(isValid, key, v)=>{
validated = [isValid, key, v];
}
classOMat = new ClassOMat('validatorTestOMat');
classOMat.BaseClass(TestClass)
.field('age').validate().uint().callback(onAgeValidate).$();
const minion = new (classOMat.$())();
minion.age(21);
expect(minion.age()).to.equal(21);
expect(validated).to.deep.equal([true, 'age', 21]);
minion.age(-9);
expect(minion.age()).to.equal(21);
expect(validated).to.deep.equal([false, 'age', -9]);
}
);
}
);