Merge pull request #12 from CodingCarlos/develop

Core tested and some validators. Also Travis to Master.

Author: CodingCarlos

.npmignore

@@ -0,0 +1,6 @@
+{
+  "files": [
+    "lib/",
+    "index.js"
+  ]
+}

.travis.yml

@@ -0,0 +1,3 @@
+language: node_js
+node_js:
+ - "node"

README.md

@@ -7,11 +7,17 @@
 
 A data modeling tool for NodeJS. It's 100% database agnostic, and 100% customizable.
 
+# How to install
+Use NPM to install the package:
+```
+npm install modelate --save
+```
+
 # How does it work?
 Create a model, and turn your objects into that model. 
 
 ```javascript
-var Modelate = require('./index');
+var Modelate = require('modelate');
 
 var model = {
 	name: {
@@ -181,14 +187,14 @@ And now you can run tests ^^
 ## Test coverage:
 Master version might not have the last test updates. Check out the `develop` branch to see the last updates. Also, the actual test coverage (in `develop` branch) is fully referenced in #3 issue.
 
- - [ ] Core
+ - [x] Core
 	 - [x] Exported module
 	 - [x] Model
 	 - [x] Modelate
-	 - [ ] Validate
+	 - [x] Validate
  - [ ] Validators
-	 - [ ] Type
-	 - [ ] Length
+	 - [x] Type
+	 - [x] Length
 	 - [ ] Value
 	 - [ ] Custom function
 	 - [ ] Date

lib/validators/length.js

@@ -15,6 +15,9 @@ function isValid(data, model) {
 		return true;
 	}
 
+	// ToDo: Number length (toString?)
+	// ToDo: Object length (keys?)
+
 	// Data hasn't the exact eq lenght
 	if (model.length.eq && data.length !== model.length.eq) {
 		return false;

package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelate",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "A simple data modeling tool for NodeJS",
   "main": "index.js",
   "scripts": {

spec/validate.spec.js

@@ -0,0 +1,87 @@
+// const util = require('../lib/util');
+const validate = require('../lib/validate');
+
+// Test data
+const validData = '';
+const invalidData = '';
+const validatorDefault = {
+	name: 'default',
+	check: function (data, model) {
+		return (data === validData);
+	}
+};
+
+const validators = {
+	clear: function () {
+		validate.validators = [];
+	},
+	add: function (validator) {
+		if (validator) {
+			validate.validators.push(validator);
+		} else {
+			validate.validators.push(validatorDefault);
+		}
+	},
+	remove: function (validator) {
+		if(typeof validator === 'string') {
+			remValidator(validator);
+		} else if (validator && typeof validator.name === 'string') {
+			remValidator(validator.name);
+		}
+	}
+};
+
+function remValidator(name) {
+	for (var i = validate.validators.length - 1; i >= 0; i--) {
+		if(validate.validators[i].name === name) {
+			validate.validators.splice(i, 1);
+		}
+	}
+}
+
+// Start testing
+describe(' - Validate', () => {
+	it('shall be an object', () => {
+		expect(typeof validate).toEqual('object');
+	});
+
+	it('shall have a "validators" property', () => {
+		expect(validate.validators).toBeDefined();
+	});
+
+	it('shall have a "check" property', () => {
+		expect(validate.check).toBeDefined();
+	});
+
+
+	describe('.validators', () => {
+		it('shall be an array', () => {
+			expect(typeof validate.validators).toEqual('object');
+			expect(Array.isArray(validate.validators)).toEqual(true);
+		});
+
+		it('shall have some validations by default', () => {
+			expect(validate.validators.length > 0).toEqual(true);
+		});
+	});
+
+	describe('.check', () => {
+		it('shall be a function', () => {
+			expect(typeof validate.check).toEqual('function');
+		});
+
+		it('shall validate valid data', () => {
+			validators.clear();
+			validators.add();
+			expect(validate.check(validData, {})).toEqual(true);
+			validators.clear();
+		});
+
+		it('shall not validate invalid data', () => {
+			validators.clear();
+			validators.add();
+			expect(validate.check(invalidData, {})).toEqual(true);
+			validators.clear();
+		});
+	});
+});

spec/validators/length.spec.js

@@ -0,0 +1,131 @@
+var valid = require('../../lib/validators/length');
+
+const str = 'Hello world';
+const strLen = str.length;
+const arr = ['Hello world', 'other thing'];
+const arrLen = arr.length;
+
+const model = {
+	length: {}
+};
+
+
+describe(' - Length validator', () => {
+	it('shall be a function', () => {
+		expect(typeof valid).toEqual('function');
+	});
+
+	it('shall validate everything when empty model set', () => {
+		expect(valid(str, model)).toEqual(true);
+		expect(valid(arr, model)).toEqual(true);
+	});
+
+	describe('equal filter', () => {
+		describe('strings', () => {
+			it('shall validate string with string.length', () => {
+				const eqModel = { length: { eq: strLen } };
+				expect(valid(str, eqModel)).toEqual(true);
+			});
+
+			it('shall NOT validate string with string.length - 1', () => {
+				const eqModel = { length: { eq: (strLen - 1) } };
+				expect(valid(str, eqModel)).toEqual(false);
+			});
+
+			it('shall NOT validate string with string.length + 1', () => {
+				const eqModel = { length: { eq: (strLen + 1) } };
+				expect(valid(str, eqModel)).toEqual(false);
+			});
+		});
+
+		describe('arrays', () => {
+			it('shall validate array with array.length', () => {
+				const eqModel = { length: { eq: arrLen } };
+				expect(valid(arr, eqModel)).toEqual(true);
+			});
+
+			it('shall NOT validate array with array.length - 1', () => {
+				const eqModel = { length: { eq: (arrLen - 1) } };
+				expect(valid(arr, eqModel)).toEqual(false);
+			});
+
+			it('shall NOT validate array with array.length + 1', () => {
+				const eqModel = { length: { eq: (arrLen + 1) } };
+				expect(valid(arr, eqModel)).toEqual(false);
+			});
+		});
+	});
+
+	describe('max filter', () => {
+		describe('strings', () => {
+			it('shall validate string with max string.length', () => {
+				const eqModel = { length: { max: strLen } };
+				expect(valid(str, eqModel)).toEqual(true);
+			});
+
+			it('shall NOT validate string with max string.length - 1', () => {
+				const eqModel = { length: { max: (strLen - 1) } };
+				expect(valid(str, eqModel)).toEqual(false);
+			});
+
+			it('shall validate string with max string.length + 1', () => {
+				const eqModel = { length: { max: (strLen + 1) } };
+				expect(valid(str, eqModel)).toEqual(true);
+			});
+		});
+
+		describe('arrays', () => {
+			it('shall validate array with max array.length', () => {
+				const eqModel = { length: { max: arrLen } };
+				expect(valid(arr, eqModel)).toEqual(true);
+			});
+
+			it('shall NOT validate array with max array.length - 1', () => {
+				const eqModel = { length: { max: (arrLen - 1) } };
+				expect(valid(arr, eqModel)).toEqual(false);
+			});
+
+			it('shall validate array with max array.length + 1', () => {
+				const eqModel = { length: { max: (arrLen + 1) } };
+				expect(valid(arr, eqModel)).toEqual(true);
+			});
+		});
+	});
+
+	describe('min filter', () => {
+		describe('strings', () => {
+			it('shall validate string with min string.length', () => {
+				const eqModel = { length: { min: strLen } };
+				expect(valid(str, eqModel)).toEqual(true);
+			});
+
+			it('shall validate string with min string.length - 1', () => {
+				const eqModel = { length: { min: (strLen - 1) } };
+				expect(valid(str, eqModel)).toEqual(true);
+			});
+
+			it('shall NOT validate string with min string.length + 1', () => {
+				const eqModel = { length: { min: (strLen + 1) } };
+				expect(valid(str, eqModel)).toEqual(false);
+			});
+		});
+
+		describe('arrays', () => {
+			it('shall validate array with min array.length', () => {
+				const eqModel = { length: { min: arrLen } };
+				expect(valid(arr, eqModel)).toEqual(true);
+			});
+
+			it('shall validate array with min array.length - 1', () => {
+				const eqModel = { length: { min: (arrLen - 1) } };
+				expect(valid(arr, eqModel)).toEqual(true);
+			});
+
+			it('shall NOT validate array with min array.length + 1', () => {
+				const eqModel = { length: { min: (arrLen + 1) } };
+				expect(valid(arr, eqModel)).toEqual(false);
+			});
+		});
+	});
+
+});

spec/validators/type.spec.js

@@ -0,0 +1,35 @@
+var valid = require('../../lib/validators/type');
+
+const str = 'Hello world';
+const obj = {hello: 'world'};
+const num = 42;
+
+const types = {
+	string: str,
+	object: obj, 
+	number: num
+};
+
+const typesKeys = Object.keys(types);
+
+describe(' - Type validator', () => {
+	it('shall be a function', () => {
+		expect(typeof valid).toEqual('function');
+	});
+
+	for (let key in typesKeys) {
+		it('shall validate '+ typesKeys[key] +' when no model set', () => {
+			expect(valid(types[key], {})).toEqual(true);
+		});
+	}
+
+	for (let validType in typesKeys) {
+		let model = {type: typesKeys[validType]};
+		for (let check in typesKeys) {
+			it('shall only validate '+ typesKeys[validType] +' when model set, and '+ typesKeys[check] +' given', () => {
+				expect(valid(types[typesKeys[check]], model)).toEqual( (validType === check) );
+			});
+		}
+	}
+
+});