Added tests for severity

Fixed jshint-warnings
Fixed case where observable with severity-function defined causes errors. This can happen when for example 'equal'-rule is used and it refers to validatable observable.

dist/knockout.validation.js

@@ -525,7 +525,7 @@ kv.configuration = configuration;
 				//	  }
 				//  )};
 				//
-				if (params && (params.message || params.onlyIf || params.severity)) { //if it has a message, condition, or severity object, then its an object literal to use
+				if (params && !ko.isObservable(params) && (params.message || params.onlyIf || params.severity)) { //if it has a message, condition, or severity object, then its an object literal to use
 					return kv.addRule(observable, {
 						rule: ruleName,
 						message: params.message,

src/api.js

@@ -327,16 +327,16 @@
 				//	  }
 				//  )};
 				//
-				if (params && (params.message || params.onlyIf || params.severity)) { //if it has a message, condition, or severity object, then its an object literal to use
-					return kv.addRule(observable, {
+				if (params && !ko.isObservable(params) && (params.message || params.onlyIf || params.severity)) { //if it has a message, condition, or severity object, then its an object literal to use
+					return ko.validation.addRule(observable, {
 						rule: ruleName,
 						message: params.message,
 						params: utils.isEmptyVal(params.params) ? true : params.params,
 						severity: params.severity || 1,
 						condition: params.onlyIf
 					});
 				} else {
-					return kv.addRule(observable, {
+					return ko.validation.addRule(observable, {
 						rule: ruleName,
 						params: params,
 						severity: 1

src/extenders.js

@@ -133,9 +133,9 @@ function validateSync(observable, rule, ctx) {
 	if (!rule.validator(observable(), (ctx.params === undefined ? true : ko.utils.unwrapObservable(ctx.params)))) { // default param is true, eg. required = true
 
 		//not valid, so format the error message and stick it in the 'error' variable
-		observable.setError(kv.formatMessage(
+		observable.setError(ko.validation.formatMessage(
 					ctx.message || rule.message,
-					unwrap(ctx.params),
+					ko.utils.unwrapObservable(ctx.params),
 					observable), ctx.severity || rule.severity);
 		return ctx.severity === 1 ? false : "warning";
 	} else {
@@ -185,7 +185,7 @@ function validateAsync(observable, rule, ctx) {
 	});
 }
 
-kv.validateObservable = function (observable) {
+ko.validation.validateObservable = function (observable) {
 	var i = 0,
 		rule, // the rule validator to execute
 		ctx, // the current Rule Context for the loop
@@ -205,7 +205,7 @@ kv.validateObservable = function (observable) {
 		}
 
 		//get the core Rule to use for validation
-		rule = ctx.rule ? kv.rules[ctx.rule] : ctx;
+		rule = ctx.rule ? ko.validation.rules[ctx.rule] : ctx;
 
 		if (rule['async'] || ctx['async']) {
 			//run async validation

test/api-tests.js

@@ -766,7 +766,10 @@ QUnit.test('setRules applies rules to all properties', function(assert) {
 			},
 			grandchild: {
 				property3: {
-					number: true
+					number: true,
+					required: {
+						severity: 2
+					}
 				}
 			},
 			ignoredDefinition: { required: true }
@@ -799,22 +802,23 @@ QUnit.test('setRules applies rules to all properties', function(assert) {
 
 	//check that all rules have been applied
 	assert.deepEqual(target.property1.rules(), [
-        { rule: 'required', params: true },
-        { rule: 'min', params: 10 },
-        { rule: 'max', params: 99 }
+        { rule: 'required', params: true, severity: 1 },
+        { rule: 'min', params: 10, severity: 1 },
+        { rule: 'max', params: 99, severity: 1 }
 	]);
 
 	assert.deepEqual(target.child.property2.rules(), [
-        { rule: 'pattern', message: 'Only AlphaNumeric please', params: '^[a-z0-9].$', condition: undefined }
+        { rule: 'pattern', message: 'Only AlphaNumeric please', params: '^[a-z0-9].$', condition: undefined, severity: 1 }
 	]);
 
 	assert.deepEqual(target.child.grandchild.property3.rules(), [
-        { rule: 'number', params: true }
+        { rule: 'number', params: true, severity: 1 },
+		{ rule: 'required', condition: undefined, message: undefined, params: true, severity: 2 }
 	]);
 
 	for (var i = 0; i < target.nestedArray().length; i++) {
 		assert.deepEqual(target.nestedArray()[i].property4.rules(), [
-			{ rule: 'email', params: true }
+			{ rule: 'email', params: true, severity: 1 }
 		]);
 	}
 
@@ -827,6 +831,27 @@ QUnit.test('setRules applies rules to all properties', function(assert) {
 	assert.ok(!target.nestedArray()[2].ignoredProperty.rules);
 });
 
+QUnit.test('setRules work correctly when params is validatedObservable', function(assert) {
+	var equalityComparison = ko.observable().extend({ min: 2 });
+
+	var definition = {
+		property1: {
+			equal: equalityComparison
+		}
+	};
+
+	var target = {
+		property1: ko.observable()
+	};
+
+	ko.validation.setRules(target, definition);
+
+	//check that all rules have been applied
+	assert.deepEqual(target.property1.rules(), [
+		{ rule: 'equal', params: equalityComparison, severity: 1 }
+	]);
+});
+
 QUnit.test('Issue #461 - validatedObservable works with nested view models if grouping.deep is true', function(assert) {
 	ko.validation.init({grouping: {deep: true}}, true);
 

test/validation-tests.js

@@ -433,3 +433,59 @@ QUnit.test('message parameter receives params and observable when async', functi
 });
 
 //#endregion
+
+//#region Severity tests
+
+QUnit.module('Severity tests');
+
+QUnit.test('isValid returns false for warning severity', function(assert) {
+    var testObj = ko.observable('something').extend({
+        required: {
+            severity: 2
+        }
+    });
+    testObj('');
+    assert.equal(testObj.isValid(), false);
+    assert.equal(testObj.severity(), 2, 'Severity should equal severity defined in required-validation');
+});
+
+QUnit.test('default severity is 1', function(assert) {
+    var testObj = ko.observable('something').extend({
+        required: true
+    });
+    testObj('');
+    assert.equal(testObj.isValid(), false);
+    assert.equal(testObj.severity(), 1, 'Severity should be 1 when not defined');
+});
+
+QUnit.test('Lowest invalid rule severity is returned', function(assert) {
+    var testObj = ko.observable('something').extend({
+        minLength: {
+            params: 200,
+            severity: 3
+        },
+        email: {
+            severity: 2
+        },
+        required: {
+            severity: 1,
+            params: true
+        }
+    });
+    testObj('test');
+    assert.equal(testObj.isValid(), false);
+    assert.equal(testObj.severity(), 2, 'Lowest broken rule severity should be 2');
+});
+
+QUnit.test('Lowest invalid rule severity for default severity is returned', function(assert) {
+    var testObj = ko.observable('something').extend({
+        required: {
+            severity: 2
+        },
+        equal: 'cant be this.'
+    });
+    testObj('');
+    assert.equal(testObj.isValid(), false);
+    assert.equal(testObj.severity(), 1, 'Default severity for broken rule should be 1');
+});
+//#endregion