Tests for validators.

src/Squidex.Domain.Apps.Core.Operations/ValidateContent/Validators/AllowedValuesValidator.cs

@@ -31,14 +31,7 @@ namespace Squidex.Domain.Apps.Core.ValidateContent.Validators
 
         public Task ValidateAsync(object value, ValidationContext context, AddError addError)
         {
-            if (value == null)
+            if (value != null && value is T typedValue && !allowedValues.Contains(typedValue))
-            {
-                return TaskHelper.Done;
-            }
-
-            var typedValue = (T)value;
-
-            if (!allowedValues.Contains(typedValue))
             {
                 addError(context.Path, "Not an allowed value.");
             }

src/Squidex.Domain.Apps.Core.Operations/ValidateContent/Validators/NoValueValidator.cs

@@ -21,7 +21,7 @@ namespace Squidex.Domain.Apps.Core.ValidateContent.Validators
         {
             if (value != null)
             {
-                addError(context.Path, "Field does not accept a value.");
+                addError(context.Path, "Value must not be defined.");
             }
 
             return Task.CompletedTask;

src/Squidex.Domain.Apps.Core.Operations/ValidateContent/Validators/RangeValidator.cs

@@ -29,34 +29,30 @@ namespace Squidex.Domain.Apps.Core.ValidateContent.Validators
 
         public Task ValidateAsync(object value, ValidationContext context, AddError addError)
         {
-            if (value == null)
+            if (value != null && value is T typedValue)
             {
-                return TaskHelper.Done;
+                if (min.HasValue && max.HasValue)
-            }
-
-            var typedValue = (T)value;
-
-            if (min.HasValue && max.HasValue)
-            {
-                if (Equals(min, max) && Equals(min.Value, max.Value))
-                {
-                    addError(context.Path, $"Must be exactly '{max}'.");
-                }
-                else if (typedValue.CompareTo(min.Value) < 0 || typedValue.CompareTo(max.Value) > 0)
                 {
-                    addError(context.Path, $"Must be between '{min}' and '{max}'.");
+                    if (Equals(min, max) && Equals(min.Value, max.Value))
+                    {
+                        addError(context.Path, $"Must be exactly '{max}'.");
+                    }
+                    else if (typedValue.CompareTo(min.Value) < 0 || typedValue.CompareTo(max.Value) > 0)
+                    {
+                        addError(context.Path, $"Must be between '{min}' and '{max}'.");
+                    }
                 }
-            }
+                else
-            else
-            {
-                if (min.HasValue && typedValue.CompareTo(min.Value) < 0)
-                {
-                    addError(context.Path, $"Must be greater or equal to '{min}'.");
-                }
-
-                if (max.HasValue && typedValue.CompareTo(max.Value) > 0)
                 {
-                    addError(context.Path, $"Must be less or equal to '{max}'.");
+                    if (min.HasValue && typedValue.CompareTo(min.Value) < 0)
+                    {
+                        addError(context.Path, $"Must be greater or equal to '{min}'.");
+                    }
+
+                    if (max.HasValue && typedValue.CompareTo(max.Value) > 0)
+                    {
+                        addError(context.Path, $"Must be less or equal to '{max}'.");
+                    }
                 }
             }
 

src/Squidex.Domain.Apps.Core.Operations/ValidateContent/Validators/RequiredStringValidator.cs

@@ -21,14 +21,12 @@ namespace Squidex.Domain.Apps.Core.ValidateContent.Validators
 
         public Task ValidateAsync(object value, ValidationContext context, AddError addError)
         {
-            if (context.IsOptional || (value != null && !(value is string)))
+            if (context.IsOptional)
             {
                 return TaskHelper.Done;
             }
 
-            var valueAsString = (string)value;
+            if (value == null || (value is string stringValue && validateEmptyStrings && string.IsNullOrWhiteSpace(stringValue)))
-
-            if (valueAsString == null || (validateEmptyStrings && string.IsNullOrWhiteSpace(valueAsString)))
             {
                 addError(context.Path, "Field is required.");
             }

tests/Squidex.Domain.Apps.Core.Tests/Operations/ValidateContent/UIFieldTests.cs

@@ -0,0 +1,65 @@
+// ==========================================================================
+//  Squidex Headless CMS
+// ==========================================================================
+//  Copyright (c) Squidex UG (haftungsbeschränkt)
+//  All rights reserved. Licensed under the MIT license.
+// ==========================================================================
+
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Squidex.Domain.Apps.Core.Schemas;
+using Squidex.Infrastructure.Json.Objects;
+using Xunit;
+
+namespace Squidex.Domain.Apps.Core.Operations.ValidateContent
+{
+    public class UIFieldTests
+    {
+        private readonly List<string> errors = new List<string>();
+
+        [Fact]
+        public void Should_instantiate_field()
+        {
+            var sut = Field(new UIFieldProperties());
+
+            Assert.Equal("my-ui", sut.Name);
+        }
+
+        [Fact]
+        public async Task Should_not_add_error_if_value_is_null()
+        {
+            var sut = Field(new UIFieldProperties());
+
+            await sut.ValidateAsync(null, errors, ValidationTestExtensions.ValidContext);
+
+            Assert.Empty(errors);
+        }
+
+        [Fact]
+        public async Task Should_not_add_error_if_value_is_json_null()
+        {
+            var sut = Field(new UIFieldProperties());
+
+            await sut.ValidateAsync(JsonValue.Null, errors);
+
+            Assert.Empty(errors);
+        }
+
+        [Fact]
+        public async Task Should_add_error_if_value_is_valid()
+        {
+            var sut = Field(new UIFieldProperties { IsRequired = true });
+
+            await sut.ValidateAsync(JsonValue.True, errors);
+
+            errors.Should().BeEquivalentTo(
+                new[] { "Value must not be defined." });
+        }
+
+        private static RootField<UIFieldProperties> Field(UIFieldProperties properties)
+        {
+            return Fields.UI(1, "my-ui", Partitioning.Invariant, properties);
+        }
+    }
+}

tests/Squidex.Domain.Apps.Core.Tests/Operations/ValidateContent/ValidationTestExtensions.cs

@@ -32,23 +32,28 @@ namespace Squidex.Domain.Apps.Core.Operations.ValidateContent
 
         public static Task ValidateOptionalAsync(this IValidator validator, object value, IList<string> errors, ValidationContext context = null)
         {
-            return validator.ValidateAsync(value,
+            return validator.ValidateAsync(
+                value,
                 CreateContext(context).Optional(true),
                 CreateFormatter(errors));
         }
 
         public static Task ValidateAsync(this IField field, IJsonValue value, IList<string> errors, ValidationContext context = null)
         {
-            return new FieldValidator(ValidatorsFactory.CreateValidators(field).ToArray(), field).ValidateAsync(value,
+            return new FieldValidator(ValidatorsFactory.CreateValidators(field).ToArray(), field)
-                CreateContext(context),
+                .ValidateAsync(
-                CreateFormatter(errors));
+                    value,
+                    CreateContext(context),
+                    CreateFormatter(errors));
         }
 
         public static Task ValidateOptionalAsync(this IField field, IJsonValue value, IList<string> errors, ValidationContext context = null)
         {
-            return new FieldValidator(ValidatorsFactory.CreateValidators(field).ToArray(), field).ValidateAsync(value,
+            return new FieldValidator(ValidatorsFactory.CreateValidators(field).ToArray(), field)
-                CreateContext(context).Optional(true),
+                .ValidateAsync(
-                CreateFormatter(errors));
+                    value,
+                    CreateContext(context).Optional(true),
+                    CreateFormatter(errors));
         }
 
         private static AddError CreateFormatter(IList<string> errors)

tests/Squidex.Domain.Apps.Core.Tests/Operations/ValidateContent/Validators/NoValueValidatorTests.cs

@@ -0,0 +1,53 @@
+// ==========================================================================
+//  Squidex Headless CMS
+// ==========================================================================
+//  Copyright (c) Squidex UG (haftungsbeschraenkt)
+//  All rights reserved. Licensed under the MIT license.
+// ==========================================================================
+
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Squidex.Domain.Apps.Core.ValidateContent.Validators;
+using Squidex.Infrastructure.Json.Objects;
+using Xunit;
+
+namespace Squidex.Domain.Apps.Core.Operations.ValidateContent.Validators
+{
+    public class NoValueValidatorTests
+    {
+        private readonly List<string> errors = new List<string>();
+
+        [Fact]
+        public async Task Should_not_add_error_if_value_is_null()
+        {
+            var sut = NoValueValidator.Instance;
+
+            await sut.ValidateAsync(null, errors);
+
+            Assert.Empty(errors);
+        }
+
+        [Fact]
+        public async Task Should_add_error_if_value_is_json_null()
+        {
+            var sut = NoValueValidator.Instance;
+
+            await sut.ValidateAsync(JsonValue.Null, errors);
+
+            errors.Should().BeEquivalentTo(
+                new[] { "Value must not be defined." });
+        }
+
+        [Fact]
+        public async Task Should_add_error_if_value_is_valid()
+        {
+            var sut = NoValueValidator.Instance;
+
+            await sut.ValidateAsync(JsonValue.True, errors);
+
+            errors.Should().BeEquivalentTo(
+                new[] { "Value must not be defined." });
+        }
+    }
+}