fix(ngModel): fix issues when parserName is same as validator key

For $validate(), it is necessary to store the parseError state
in the controller. Otherwise, if the parser name equals a validator
key, $validate() will assume a parse error occured if the validator
is invalid.

Also, setting the validity for the parser now happens after setting
validity for the validator key. Otherwise, the parse key is set,
and then immediately afterwards the validator key is unset
(because parse errors remove all other validations).

Fixes angular#10698
Closes angular#10828

Author: Narretz

src/ng/directive/ngModel.js

@@ -233,6 +233,7 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
   this.$dirty = false;
   this.$valid = true;
   this.$invalid = false;
+  this.$$parseError = false;
   this.$error = {}; // keep invalid keys here
   this.$$success = {}; // keep valid keys here
   this.$pending = undefined; // keep pending keys here
@@ -518,7 +519,7 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
 
     // Check if the there's a parse error, so we don't unset it accidentially
     var parserName = ctrl.$$parserName || 'parse';
-    var parserValid = ctrl.$error[parserName] ? false : undefined;
+    var parserValid = ctrl.$$parseError ? false : undefined;
 
     var prevValid = ctrl.$valid;
     var prevModelValue = ctrl.$modelValue;
@@ -563,17 +564,21 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
       if (parseValid === undefined) {
         setValidity(errorKey, null);
       } else {
-        setValidity(errorKey, parseValid);
         if (!parseValid) {
           forEach(ctrl.$validators, function(v, name) {
             setValidity(name, null);
           });
           forEach(ctrl.$asyncValidators, function(v, name) {
             setValidity(name, null);
           });
-          return false;
+          ctrl.$$parseError = true;
         }
+        // Set the parse error last, to prevent unsetting it, should a $validators key == parserName
+        setValidity(errorKey, parseValid);
+        return parseValid;
       }
+
+      ctrl.$$parseError = false;
       return true;
     }
 
@@ -814,6 +819,7 @@ var NgModelController = ['$scope', '$exceptionHandler', '$attrs', '$element', '$
     // TODO(perf): why not move this to the action fn?
     if (modelValue !== ctrl.$modelValue) {
       ctrl.$modelValue = ctrl.$$rawModelValue = modelValue;
+      ctrl.$$parseError = false;
 
       var formatters = ctrl.$formatters,
           idx = formatters.length;

test/ng/directive/ngModelSpec.js

@@ -1221,6 +1221,80 @@ describe('ngModel', function() {
         expect(ctrl.$validators.mock).toHaveBeenCalledWith('a', 'ab');
         expect(ctrl.$validators.mock.calls.length).toEqual(2);
       });
+
+      it('should validate correctly when $parser equals $validator key', function() {
+
+        var testValid, otherValid, parseValid;
+
+        ctrl.$validators.test = function(value) {
+          return testValid;
+        };
+
+        ctrl.$validators.other = function(value) {
+          return otherValid;
+        };
+
+        ctrl.$$parserName = 'test';
+        ctrl.$parsers.push(function(value) {
+          return parseValid ? true : undefined;
+        });
+
+
+        testValid = otherValid = parseValid = false;
+        scope.$apply('value = "allInvalid"');
+        expect(scope.value).toBe('allInvalid');
+        expect(ctrl.$error).toEqual({test: true, other: true});
+
+        ctrl.$validate();
+        expect(scope.value).toBe('allInvalid');
+        expect(ctrl.$error).toEqual({test: true, other: true});
+
+        ctrl.$setViewValue('stillAllInvalid');
+        expect(scope.value).toBeUndefined();
+        expect(ctrl.$error).toEqual({test: true});
+
+        ctrl.$validate();
+        expect(scope.value).toBeUndefined();
+        expect(ctrl.$error).toEqual({test: true});
+
+
+        parseValid = true;
+        scope.$apply('value = "parseValidAndValidatorInvalid"');
+        expect(scope.value).toBe('parseValidAndValidatorInvalid');
+        expect(ctrl.$error).toEqual({test: true, other: true});
+
+        ctrl.$validate();
+        expect(scope.value).toBe('parseValidAndValidatorInvalid');
+        expect(ctrl.$error).toEqual({test: true, other: true});
+
+        ctrl.$setViewValue('stillParseValidAndValidatorInvalid');
+        expect(scope.value).toBeUndefined();
+        expect(ctrl.$error).toEqual({test: true, other: true});
+
+        ctrl.$validate();
+        expect(scope.value).toBeUndefined();
+        expect(ctrl.$error).toEqual({test: true, other: true});
+
+
+        parseValid = false;
+        testValid = otherValid = true;
+        scope.$apply('value = "parseInvalidAndValidatorValid"');
+        expect(scope.value).toBe('parseInvalidAndValidatorValid');
+        expect(ctrl.$error).toEqual({});
+
+        ctrl.$validate();
+        expect(scope.value).toBe('parseInvalidAndValidatorValid');
+        expect(ctrl.$error).toEqual({});
+
+        ctrl.$setViewValue('stillParseInvalidAndValidatorValid');
+        expect(scope.value).toBeUndefined();
+        expect(ctrl.$error).toEqual({test: true});
+
+        ctrl.$validate();
+        expect(scope.value).toBeUndefined();
+        expect(ctrl.$error).toEqual({test: true});
+      });
+
     });
   });