Adds unit tests for serverValidationManager and fixes it up to ensure that the correct culture callbacks are called.

src/Umbraco.Web.UI.Client/src/common/services/servervalidationmgr.service.js

@@ -80,8 +80,9 @@ function serverValidationManager($timeout) {
                 if (propErrors.length > 0) {
                     executeCallback(self, propErrors, callbacks[cb].callback, callbacks[cb].culture);
                 }
-            } else {
-                //its a property error
+            }
+            else {
+                //its a culture error
                 var cultureErrors = getCultureErrors(self, callbacks[cb].culture);
                 if (cultureErrors.length > 0) {
                     executeCallback(self, cultureErrors, callbacks[cb].callback, callbacks[cb].culture);
@@ -277,8 +278,8 @@ function serverValidationManager($timeout) {
          */
         getCultureCallbacks: function (culture) {
             var found = _.filter(callbacks, function (item) {
-                //returns any callback that have been registered directly against the field
-                return (item.culture === culture);
+                //returns any callback that have been registered directly/ONLY against the culture
+                return (item.culture === culture && item.propertyAlias === null && item.fieldName === null);
             });
             return found;
         },
@@ -354,6 +355,13 @@ function serverValidationManager($timeout) {
             for (var cb in cbs) {
                 executeCallback(this, errorsForCallback, cbs[cb].callback, culture);
             }
+
+            //execute culture specific callbacks here too when a propery error is added
+            var cultureCbs = this.getCultureCallbacks(culture);
+            //call each callback for this error
+            for (var cb in cultureCbs) {
+                executeCallback(this, errorsForCallback, cultureCbs[cb].callback, culture);
+            }
         },      
         
         /**

src/Umbraco.Web.UI.Client/test/unit/common/services/server-validation-manager.spec.js

@@ -22,6 +22,7 @@
             expect(err.propertyAlias).toBeNull();
             expect(err.fieldName).toEqual("Name");
             expect(err.errorMsg).toEqual("Required");
+            expect(err.culture).toEqual("invariant");
         });
         
         it('will return null for a non-existing field error', function () {
@@ -72,11 +73,43 @@
             expect(err1.propertyAlias).toEqual("myProperty");
             expect(err1.fieldName).toEqual("value1");
             expect(err1.errorMsg).toEqual("Some value 1");
+            expect(err1.culture).toEqual("invariant");
             
             expect(err2).not.toBeUndefined();
             expect(err2.propertyAlias).toEqual("myProperty");
             expect(err2.fieldName).toEqual("value2");
             expect(err2.errorMsg).toEqual("Another value 2");
+            expect(err2.culture).toEqual("invariant");
+        });
+
+        it('can retrieve property validation errors for a sub field for culture', function () {
+
+            //arrange
+            serverValidationManager.addPropertyError("myProperty", "en-US", "value1", "Some value 1");
+            serverValidationManager.addPropertyError("myProperty", "fr-FR", "value2", "Another value 2");
+
+            //act
+            var err1 = serverValidationManager.getPropertyError("myProperty", "en-US", "value1");
+            var err1NotFound = serverValidationManager.getPropertyError("myProperty", null, "value2");
+            var err2 = serverValidationManager.getPropertyError("myProperty", "fr-FR", "value2");
+            var err2NotFound = serverValidationManager.getPropertyError("myProperty", null, "value2");
+
+
+            //assert            
+            expect(err1NotFound).toBeUndefined();
+            expect(err2NotFound).toBeUndefined();
+
+            expect(err1).not.toBeUndefined();
+            expect(err1.propertyAlias).toEqual("myProperty");
+            expect(err1.fieldName).toEqual("value1");
+            expect(err1.errorMsg).toEqual("Some value 1");
+            expect(err1.culture).toEqual("en-US");
+
+            expect(err2).not.toBeUndefined();
+            expect(err2.propertyAlias).toEqual("myProperty");
+            expect(err2.fieldName).toEqual("value2");
+            expect(err2.errorMsg).toEqual("Another value 2");
+            expect(err2.culture).toEqual("fr-FR");
         });
         
         it('can add a property errors with multiple sub fields and it the first will be retreived with only the property alias', function () {
@@ -93,6 +126,7 @@
             expect(err.propertyAlias).toEqual("myProperty");
             expect(err.fieldName).toEqual("value1");
             expect(err.errorMsg).toEqual("Some value 1");
+            expect(err.culture).toEqual("invariant");
         });
 
         it('will return null for a non-existing property error', function () {
@@ -162,6 +196,26 @@
 
     });
 
+    describe('managing culture validation errors', function () {
+
+        it('can retrieve culture validation errors', function () {
+
+            //arrange
+            serverValidationManager.addPropertyError("myProperty", null, "value1", "Some value 1");
+            serverValidationManager.addPropertyError("myProperty", "en-US", "value1", "Some value 2");
+            serverValidationManager.addPropertyError("myProperty", null, "value2", "Another value 2");
+            serverValidationManager.addPropertyError("myProperty", "fr-FR", "value2", "Another value 3");
+
+            //assert
+            expect(serverValidationManager.hasCultureError(null)).toBe(true);
+            expect(serverValidationManager.hasCultureError("en-US")).toBe(true);
+            expect(serverValidationManager.hasCultureError("fr-FR")).toBe(true);
+            expect(serverValidationManager.hasCultureError("es-ES")).toBe(false);
+
+        });
+
+    });
+
     describe('validation error subscriptions', function() {
 
         it('can subscribe to a field error', function() {
@@ -267,6 +321,45 @@
             // if the property has errors existing.
             expect(numCalled).toEqual(3);
         });
+
+        it('can subscribe to a culture error for both a property and its sub field', function () {
+            var args1;
+            var args2;
+            var numCalled = 0;
+
+            //arrange
+            serverValidationManager.subscribe(null, "en-US", null, function (isValid, propertyErrors, allErrors) {
+                numCalled++;
+                args1 = {
+                    isValid: isValid,
+                    propertyErrors: propertyErrors,
+                    allErrors: allErrors
+                };
+            });
+
+            serverValidationManager.subscribe(null, "es-ES", null, function (isValid, propertyErrors, allErrors) {
+                numCalled++;
+                args2 = {
+                    isValid: isValid,
+                    propertyErrors: propertyErrors,
+                    allErrors: allErrors
+                };
+            });
+
+            //act
+            serverValidationManager.addPropertyError("myProperty", null, "value1", "Some value 1");
+            serverValidationManager.addPropertyError("myProperty", "en-US", "value1", "Some value 1");
+            serverValidationManager.addPropertyError("myProperty", "en-US", "value2", "Some value 2");
+            serverValidationManager.addPropertyError("myProperty", "fr-FR", "", "Some value 3");
+
+            //assert
+            expect(args1).not.toBeUndefined();
+            expect(args1.isValid).toBe(false);
+
+            expect(args2).toBeUndefined();
+
+            expect(numCalled).toEqual(2);
+        });
         
         // TODO: Finish testing the rest!