diff --git a/src/Squidex.Domain.Apps.Core/ContentValidator.cs b/src/Squidex.Domain.Apps.Core/ContentValidator.cs index c11038918..fcf5939dc 100644 --- a/src/Squidex.Domain.Apps.Core/ContentValidator.cs +++ b/src/Squidex.Domain.Apps.Core/ContentValidator.cs @@ -52,7 +52,7 @@ namespace Squidex.Domain.Apps.Core if (!schema.FieldsByName.TryGetValue(fieldData.Key, out var field)) { - errors.AddError(" is not a known field", fieldName); + errors.AddError(" is not a known field.", fieldName); } else { @@ -78,7 +78,7 @@ namespace Squidex.Domain.Apps.Core } else { - errors.AddError($" has an unsupported {partitioning.Key} value '{partitionValues.Key}'", field); + errors.AddError($" has an unsupported {partitioning.Key} value '{partitionValues.Key}'.", field); } } @@ -109,7 +109,7 @@ namespace Squidex.Domain.Apps.Core { if (!schema.FieldsByName.ContainsKey(fieldData.Key)) { - errors.AddError(" is not a known field", fieldData.Key); + errors.AddError(" is not a known field.", fieldData.Key); } } } @@ -125,7 +125,7 @@ namespace Squidex.Domain.Apps.Core { if (!partition.TryGetItem(partitionValues.Key, out var _)) { - errors.AddError($" has an unsupported {partitioning.Key} value '{partitionValues.Key}'", field); + errors.AddError($" has an unsupported {partitioning.Key} value '{partitionValues.Key}'.", field); } } diff --git a/src/Squidex.Domain.Apps.Core/FieldExtensions.cs b/src/Squidex.Domain.Apps.Core/FieldExtensions.cs index 18fe7baeb..084d8494e 100644 --- a/src/Squidex.Domain.Apps.Core/FieldExtensions.cs +++ b/src/Squidex.Domain.Apps.Core/FieldExtensions.cs @@ -51,7 +51,7 @@ namespace Squidex.Domain.Apps.Core } catch { - addError(" is not a valid value"); + addError(" is not a valid value."); } } } diff --git a/src/Squidex.Domain.Apps.Core/Schemas/AssetsFieldProperties.cs b/src/Squidex.Domain.Apps.Core/Schemas/AssetsFieldProperties.cs index 2798e241c..15aa36b17 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/AssetsFieldProperties.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/AssetsFieldProperties.cs @@ -49,5 +49,10 @@ namespace Squidex.Domain.Apps.Core.Schemas { return new JArray(); } + + public override T Visit(IFieldPropertiesVisitor visitor) + { + return visitor.Visit(this); + } } } diff --git a/src/Squidex.Domain.Apps.Core/Schemas/BooleanFieldProperties.cs b/src/Squidex.Domain.Apps.Core/Schemas/BooleanFieldProperties.cs index 8d3b5449a..1f06cb821 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/BooleanFieldProperties.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/BooleanFieldProperties.cs @@ -49,5 +49,10 @@ namespace Squidex.Domain.Apps.Core.Schemas { return DefaultValue; } + + public override T Visit(IFieldPropertiesVisitor visitor) + { + return visitor.Visit(this); + } } } diff --git a/src/Squidex.Domain.Apps.Core/Schemas/DateTimeFieldProperties.cs b/src/Squidex.Domain.Apps.Core/Schemas/DateTimeFieldProperties.cs index 6171fe2bf..8bd5ee54f 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/DateTimeFieldProperties.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/DateTimeFieldProperties.cs @@ -107,5 +107,10 @@ namespace Squidex.Domain.Apps.Core.Schemas return DefaultValue?.ToString(); } } + + public override T Visit(IFieldPropertiesVisitor visitor) + { + return visitor.Visit(this); + } } } diff --git a/src/Squidex.Domain.Apps.Core/Schemas/Edm/EdmSchemaExtensions.cs b/src/Squidex.Domain.Apps.Core/Schemas/Edm/EdmSchemaExtensions.cs index dd3ae37bc..df3b05027 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/Edm/EdmSchemaExtensions.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/Edm/EdmSchemaExtensions.cs @@ -36,7 +36,7 @@ namespace Squidex.Domain.Apps.Core.Schemas.Edm foreach (var field in schema.FieldsByName.Values.Where(x => !x.IsHidden)) { - var edmValueType = field.Visit(EdmTypeVisitor.Instance); + var edmValueType = EdmTypeVisitor.CreateEdmType(field); if (edmValueType == null) { diff --git a/src/Squidex.Domain.Apps.Core/Schemas/Edm/EdmTypeVisitor.cs b/src/Squidex.Domain.Apps.Core/Schemas/Edm/EdmTypeVisitor.cs index 5233b749b..9918b6936 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/Edm/EdmTypeVisitor.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/Edm/EdmTypeVisitor.cs @@ -12,7 +12,16 @@ namespace Squidex.Domain.Apps.Core.Schemas.Edm { public sealed class EdmTypeVisitor : IFieldVisitor { - public static readonly EdmTypeVisitor Instance = new EdmTypeVisitor(); + private static readonly EdmTypeVisitor Instance = new EdmTypeVisitor(); + + private EdmTypeVisitor() + { + } + + public static IEdmTypeReference CreateEdmType(Field field) + { + return field.Visit(Instance); + } public IEdmTypeReference Visit(AssetsField field) { diff --git a/src/Squidex.Domain.Apps.Core/Schemas/FieldProperties.cs b/src/Squidex.Domain.Apps.Core/Schemas/FieldProperties.cs index 32b877ff0..c5e2a43c9 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/FieldProperties.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/FieldProperties.cs @@ -61,6 +61,8 @@ namespace Squidex.Domain.Apps.Core.Schemas public abstract JToken GetDefaultValue(); + public abstract T Visit(IFieldPropertiesVisitor visitor); + public virtual bool ShouldApplyDefaultValue(JToken value) { return value.IsNull(); diff --git a/src/Squidex.Domain.Apps.Core/Schemas/GeolocationFieldProperties.cs b/src/Squidex.Domain.Apps.Core/Schemas/GeolocationFieldProperties.cs index 914c61d61..c597d6dc4 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/GeolocationFieldProperties.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/GeolocationFieldProperties.cs @@ -34,5 +34,10 @@ namespace Squidex.Domain.Apps.Core.Schemas { return null; } + + public override T Visit(IFieldPropertiesVisitor visitor) + { + return visitor.Visit(this); + } } } diff --git a/src/Squidex.Domain.Apps.Core/Schemas/IFieldPropertiesVisitor.cs b/src/Squidex.Domain.Apps.Core/Schemas/IFieldPropertiesVisitor.cs new file mode 100644 index 000000000..3d113156d --- /dev/null +++ b/src/Squidex.Domain.Apps.Core/Schemas/IFieldPropertiesVisitor.cs @@ -0,0 +1,29 @@ +// ========================================================================== +// IFieldPropertiesVisitor.cs +// Squidex Headless CMS +// ========================================================================== +// Copyright (c) Squidex Group +// All rights reserved. +// ========================================================================== + +namespace Squidex.Domain.Apps.Core.Schemas +{ + public interface IFieldPropertiesVisitor + { + T Visit(AssetsFieldProperties properties); + + T Visit(BooleanFieldProperties properties); + + T Visit(DateTimeFieldProperties properties); + + T Visit(GeolocationFieldProperties properties); + + T Visit(JsonFieldProperties properties); + + T Visit(NumberFieldProperties properties); + + T Visit(ReferencesFieldProperties properties); + + T Visit(StringFieldProperties properties); + } +} diff --git a/src/Squidex.Domain.Apps.Core/Schemas/JsonFieldProperties.cs b/src/Squidex.Domain.Apps.Core/Schemas/JsonFieldProperties.cs index e5273c3dc..a7e1c93d1 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/JsonFieldProperties.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/JsonFieldProperties.cs @@ -18,5 +18,10 @@ namespace Squidex.Domain.Apps.Core.Schemas { return JValue.CreateNull(); } + + public override T Visit(IFieldPropertiesVisitor visitor) + { + return visitor.Visit(this); + } } } diff --git a/src/Squidex.Domain.Apps.Core/Schemas/NumberFieldProperties.cs b/src/Squidex.Domain.Apps.Core/Schemas/NumberFieldProperties.cs index 728e063ce..931646988 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/NumberFieldProperties.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/NumberFieldProperties.cs @@ -95,5 +95,10 @@ namespace Squidex.Domain.Apps.Core.Schemas { return DefaultValue; } + + public override T Visit(IFieldPropertiesVisitor visitor) + { + return visitor.Visit(this); + } } } diff --git a/src/Squidex.Domain.Apps.Core/Schemas/ReferencesFieldProperties.cs b/src/Squidex.Domain.Apps.Core/Schemas/ReferencesFieldProperties.cs index 6586773f2..55a17006f 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/ReferencesFieldProperties.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/ReferencesFieldProperties.cs @@ -65,5 +65,10 @@ namespace Squidex.Domain.Apps.Core.Schemas { return new JArray(); } + + public override T Visit(IFieldPropertiesVisitor visitor) + { + return visitor.Visit(this); + } } } diff --git a/src/Squidex.Domain.Apps.Core/Schemas/Schema.cs b/src/Squidex.Domain.Apps.Core/Schemas/Schema.cs index c65162a2a..ce0a69239 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/Schema.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/Schema.cs @@ -10,7 +10,6 @@ using System; using System.Collections.Generic; using System.Collections.Immutable; using System.Linq; -using NJsonSchema; using Squidex.Infrastructure; namespace Squidex.Domain.Apps.Core.Schemas @@ -159,21 +158,12 @@ namespace Squidex.Domain.Apps.Core.Schemas { Guard.NotNull(field, nameof(field)); - if (fieldsByName.ContainsKey(field.Name)) + if (fieldsByName.ContainsKey(field.Name) || fieldsById.ContainsKey(field.Id)) { throw new ArgumentException($"A field with name '{field.Name}' already exists.", nameof(field)); } - ImmutableList newFields; - - if (fieldsById.ContainsKey(field.Id)) - { - newFields = fields.Select(f => f.Id == field.Id ? field : f).ToImmutableList(); - } - else - { - newFields = fields.Add(field); - } + var newFields = fields.Add(field); return new Schema(name, isPublished, properties, newFields); } diff --git a/src/Squidex.Domain.Apps.Core/Schemas/StringFieldProperties.cs b/src/Squidex.Domain.Apps.Core/Schemas/StringFieldProperties.cs index f76d9e2e7..859e66ca1 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/StringFieldProperties.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/StringFieldProperties.cs @@ -131,5 +131,10 @@ namespace Squidex.Domain.Apps.Core.Schemas { return value.IsNull() || (value is JValue jValue && Equals(jValue.Value, string.Empty)); } + + public override T Visit(IFieldPropertiesVisitor visitor) + { + return visitor.Visit(this); + } } } diff --git a/src/Squidex.Domain.Apps.Core/Schemas/Validators/AllowedValuesValidator.cs b/src/Squidex.Domain.Apps.Core/Schemas/Validators/AllowedValuesValidator.cs index 9346f454f..ff144c184 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/Validators/AllowedValuesValidator.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/Validators/AllowedValuesValidator.cs @@ -36,7 +36,7 @@ namespace Squidex.Domain.Apps.Core.Schemas.Validators if (!allowedValues.Contains(typedValue)) { - addError(" is not an allowed value"); + addError(" is not an allowed value."); } return TaskHelper.Done; diff --git a/src/Squidex.Domain.Apps.Core/Schemas/Validators/AssetsValidator.cs b/src/Squidex.Domain.Apps.Core/Schemas/Validators/AssetsValidator.cs index f724048ec..72eeecb9f 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/Validators/AssetsValidator.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/Validators/AssetsValidator.cs @@ -30,7 +30,7 @@ namespace Squidex.Domain.Apps.Core.Schemas.Validators { if (isRequired && !context.IsOptional) { - addError(" is required"); + addError(" is required."); } return; @@ -38,19 +38,19 @@ namespace Squidex.Domain.Apps.Core.Schemas.Validators if (minItems.HasValue && assets.AssetIds.Count < minItems.Value) { - addError($" must have at least {minItems} asset(s)"); + addError($" must have at least {minItems} asset(s)."); } if (maxItems.HasValue && assets.AssetIds.Count > maxItems.Value) { - addError($" must have not more than {maxItems} asset(s)"); + addError($" must have not more than {maxItems} asset(s)."); } var invalidIds = await context.GetInvalidAssetIdsAsync(assets.AssetIds); foreach (var invalidId in invalidIds) { - addError($" contains invalid asset '{invalidId}'"); + addError($" contains invalid asset '{invalidId}'."); } } } diff --git a/src/Squidex.Domain.Apps.Core/Schemas/Validators/PatternValidator.cs b/src/Squidex.Domain.Apps.Core/Schemas/Validators/PatternValidator.cs index 45db08d13..c7822c6d6 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/Validators/PatternValidator.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/Validators/PatternValidator.cs @@ -33,7 +33,7 @@ namespace Squidex.Domain.Apps.Core.Schemas.Validators { if (string.IsNullOrWhiteSpace(errorMessage)) { - addError(" is not valid"); + addError(" is not valid."); } else { diff --git a/src/Squidex.Domain.Apps.Core/Schemas/Validators/RangeValidator.cs b/src/Squidex.Domain.Apps.Core/Schemas/Validators/RangeValidator.cs index d0ca2cbba..3d8dcca14 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/Validators/RangeValidator.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/Validators/RangeValidator.cs @@ -39,12 +39,12 @@ namespace Squidex.Domain.Apps.Core.Schemas.Validators if (min.HasValue && typedValue.CompareTo(min.Value) < 0) { - addError($" must be greater than '{min}'"); + addError($" must be greater than '{min}'."); } if (max.HasValue && typedValue.CompareTo(max.Value) > 0) { - addError($" must be less than '{max}'"); + addError($" must be less than '{max}'."); } return TaskHelper.Done; diff --git a/src/Squidex.Domain.Apps.Core/Schemas/Validators/ReferencesValidator.cs b/src/Squidex.Domain.Apps.Core/Schemas/Validators/ReferencesValidator.cs index c315c7cd4..54e583231 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/Validators/ReferencesValidator.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/Validators/ReferencesValidator.cs @@ -32,7 +32,7 @@ namespace Squidex.Domain.Apps.Core.Schemas.Validators { if (isRequired && !context.IsOptional) { - addError(" is required"); + addError(" is required."); } return; @@ -40,19 +40,19 @@ namespace Squidex.Domain.Apps.Core.Schemas.Validators if (minItems.HasValue && references.ContentIds.Count < minItems.Value) { - addError($" must have at least {minItems} reference(s)"); + addError($" must have at least {minItems} reference(s)."); } if (maxItems.HasValue && references.ContentIds.Count > maxItems.Value) { - addError($" must have not more than {maxItems} reference(s)"); + addError($" must have not more than {maxItems} reference(s)."); } var invalidIds = await context.GetInvalidContentIdsAsync(references.ContentIds, schemaId); foreach (var invalidId in invalidIds) { - addError($" contains invalid reference '{invalidId}'"); + addError($" contains invalid reference '{invalidId}'."); } } } diff --git a/src/Squidex.Domain.Apps.Core/Schemas/Validators/RequiredStringValidator.cs b/src/Squidex.Domain.Apps.Core/Schemas/Validators/RequiredStringValidator.cs index 69aabed9f..39f176be0 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/Validators/RequiredStringValidator.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/Validators/RequiredStringValidator.cs @@ -32,7 +32,7 @@ namespace Squidex.Domain.Apps.Core.Schemas.Validators if (valueAsString == null || (validateEmptyStrings && string.IsNullOrWhiteSpace(valueAsString))) { - addError(" is required"); + addError(" is required."); } return TaskHelper.Done; diff --git a/src/Squidex.Domain.Apps.Core/Schemas/Validators/RequiredValidator.cs b/src/Squidex.Domain.Apps.Core/Schemas/Validators/RequiredValidator.cs index 97ff2c26a..85581fcbd 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/Validators/RequiredValidator.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/Validators/RequiredValidator.cs @@ -18,7 +18,7 @@ namespace Squidex.Domain.Apps.Core.Schemas.Validators { if (value == null && !context.IsOptional) { - addError(" is required"); + addError(" is required."); } return TaskHelper.Done; diff --git a/src/Squidex.Domain.Apps.Core/Schemas/Validators/StringLengthValidator.cs b/src/Squidex.Domain.Apps.Core/Schemas/Validators/StringLengthValidator.cs index 5a03db43e..997f97b6a 100644 --- a/src/Squidex.Domain.Apps.Core/Schemas/Validators/StringLengthValidator.cs +++ b/src/Squidex.Domain.Apps.Core/Schemas/Validators/StringLengthValidator.cs @@ -34,12 +34,12 @@ namespace Squidex.Domain.Apps.Core.Schemas.Validators { if (minLength.HasValue && stringValue.Length < minLength.Value) { - addError($" must have more than '{minLength}' characters"); + addError($" must have more than '{minLength}' characters."); } if (maxLength.HasValue && stringValue.Length > maxLength.Value) { - addError($" must have less than '{maxLength}' characters"); + addError($" must have less than '{maxLength}' characters."); } } diff --git a/src/Squidex.Domain.Apps.Core/Scripting/ContentWrapper/ContentFieldObject.cs b/src/Squidex.Domain.Apps.Core/Scripting/ContentWrapper/ContentFieldObject.cs index 8dc8e322e..e4eed7641 100644 --- a/src/Squidex.Domain.Apps.Core/Scripting/ContentWrapper/ContentFieldObject.cs +++ b/src/Squidex.Domain.Apps.Core/Scripting/ContentWrapper/ContentFieldObject.cs @@ -24,11 +24,6 @@ namespace Squidex.Domain.Apps.Core.Scripting.ContentWrapper private Dictionary valueProperties; private bool isChanged; - public bool IsChanged - { - get { return isChanged; } - } - public ContentFieldData FieldData { get { return fieldData; } diff --git a/src/Squidex.Domain.Apps.Write/Apps/AppClients.cs b/src/Squidex.Domain.Apps.Write/Apps/AppClients.cs index 8a032e007..0e5e36e43 100644 --- a/src/Squidex.Domain.Apps.Write/Apps/AppClients.cs +++ b/src/Squidex.Domain.Apps.Write/Apps/AppClients.cs @@ -17,11 +17,6 @@ namespace Squidex.Domain.Apps.Write.Apps { private readonly Dictionary clients = new Dictionary(); - public IReadOnlyDictionary Clients - { - get { return clients; } - } - public void Add(string id, string secret) { ThrowIfFound(id, () => "Cannot add client"); diff --git a/src/Squidex.Domain.Apps.Write/Contents/ContentDomainObject.cs b/src/Squidex.Domain.Apps.Write/Contents/ContentDomainObject.cs index 9286f9b14..a9fc44fb4 100644 --- a/src/Squidex.Domain.Apps.Write/Contents/ContentDomainObject.cs +++ b/src/Squidex.Domain.Apps.Write/Contents/ContentDomainObject.cs @@ -138,7 +138,7 @@ namespace Squidex.Domain.Apps.Write.Contents private void VerifyCanChangeStatus(Status newStatus) { - if (!StatusFlow.Exists(newStatus) && !StatusFlow.CanChange(status, newStatus)) + if (!StatusFlow.Exists(newStatus) || !StatusFlow.CanChange(status, newStatus)) { throw new DomainException($"Content cannot be changed from status {status} to {newStatus}."); } @@ -152,14 +152,6 @@ namespace Squidex.Domain.Apps.Write.Contents } } - private void VerifyDeleted() - { - if (!isDeleted) - { - throw new DomainException("Content has not been deleted."); - } - } - private void VerifyCreatedAndNotDeleted() { if (isDeleted || !isCreated) diff --git a/src/Squidex.Domain.Apps.Write/Schemas/Commands/AddField.cs b/src/Squidex.Domain.Apps.Write/Schemas/Commands/AddField.cs index fb569575b..d0e7b248a 100644 --- a/src/Squidex.Domain.Apps.Write/Schemas/Commands/AddField.cs +++ b/src/Squidex.Domain.Apps.Write/Schemas/Commands/AddField.cs @@ -40,7 +40,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Commands } else { - var propertyErrors = SchemaFieldGuard.ValidateProperties(Properties); + var propertyErrors = FieldPropertiesValidator.Validate(Properties); foreach (var error in propertyErrors) { diff --git a/src/Squidex.Domain.Apps.Write/Schemas/Commands/CreateSchema.cs b/src/Squidex.Domain.Apps.Write/Schemas/Commands/CreateSchema.cs index 3563b9e0a..d2fa51a4f 100644 --- a/src/Squidex.Domain.Apps.Write/Schemas/Commands/CreateSchema.cs +++ b/src/Squidex.Domain.Apps.Write/Schemas/Commands/CreateSchema.cs @@ -66,11 +66,6 @@ namespace Squidex.Domain.Apps.Write.Schemas.Commands errors.Add(new ValidationError("Name must be a valid slug.", nameof(Name))); } - if (Properties == null) - { - errors.Add(new ValidationError("Properties must be specified.", nameof(Properties))); - } - if (Fields.Any()) { var index = 0; diff --git a/src/Squidex.Domain.Apps.Write/Schemas/Commands/CreateSchemaField.cs b/src/Squidex.Domain.Apps.Write/Schemas/Commands/CreateSchemaField.cs index eaac093c7..45a9f3c2b 100644 --- a/src/Squidex.Domain.Apps.Write/Schemas/Commands/CreateSchemaField.cs +++ b/src/Squidex.Domain.Apps.Write/Schemas/Commands/CreateSchemaField.cs @@ -48,7 +48,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Commands } else { - var propertyErrors = SchemaFieldGuard.ValidateProperties(Properties); + var propertyErrors = FieldPropertiesValidator.Validate(Properties); foreach (var error in propertyErrors) { diff --git a/src/Squidex.Domain.Apps.Write/Schemas/Guards/FieldPropertiesValidator.cs b/src/Squidex.Domain.Apps.Write/Schemas/Guards/FieldPropertiesValidator.cs new file mode 100644 index 000000000..a6decb9df --- /dev/null +++ b/src/Squidex.Domain.Apps.Write/Schemas/Guards/FieldPropertiesValidator.cs @@ -0,0 +1,193 @@ +// ========================================================================== +// FieldPropertiesValidator.cs +// Squidex Headless CMS +// ========================================================================== +// Copyright (c) Squidex Group +// All rights reserved. +// ========================================================================== + +using System.Collections.Generic; +using Squidex.Domain.Apps.Core.Schemas; +using Squidex.Infrastructure; + +namespace Squidex.Domain.Apps.Write.Schemas.Guards +{ + public sealed class FieldPropertiesValidator : IFieldPropertiesVisitor> + { + private static readonly FieldPropertiesValidator Instance = new FieldPropertiesValidator(); + + private FieldPropertiesValidator() + { + } + + public static IEnumerable Validate(FieldProperties properties) + { + return properties.Visit(Instance); + } + + public IEnumerable Visit(AssetsFieldProperties properties) + { + if (properties.MaxItems.HasValue && properties.MinItems.HasValue && properties.MinItems.Value >= properties.MaxItems.Value) + { + yield return new ValidationError("Max items must be greater than min items.", + nameof(properties.MinItems), + nameof(properties.MaxItems)); + } + } + + public IEnumerable Visit(BooleanFieldProperties properties) + { + if (!properties.Editor.IsEnumValue()) + { + yield return new ValidationError("Editor is not a valid value.", + nameof(properties.Editor)); + } + } + + public IEnumerable Visit(DateTimeFieldProperties properties) + { + if (!properties.Editor.IsEnumValue()) + { + yield return new ValidationError("Editor is not a valid value.", + nameof(properties.Editor)); + } + + if (properties.DefaultValue.HasValue && properties.MinValue.HasValue && properties.DefaultValue.Value < properties.MinValue.Value) + { + yield return new ValidationError("Default value must be greater than min value.", + nameof(properties.DefaultValue)); + } + + if (properties.DefaultValue.HasValue && properties.MaxValue.HasValue && properties.DefaultValue.Value > properties.MaxValue.Value) + { + yield return new ValidationError("Default value must be less than max value.", + nameof(properties.DefaultValue)); + } + + if (properties.MaxValue.HasValue && properties.MinValue.HasValue && properties.MinValue.Value >= properties.MaxValue.Value) + { + yield return new ValidationError("Max value must be greater than min value.", + nameof(properties.MinValue), + nameof(properties.MaxValue)); + } + + if (properties.CalculatedDefaultValue.HasValue) + { + if (!properties.CalculatedDefaultValue.Value.IsEnumValue()) + { + yield return new ValidationError("Calculated default value is not valid.", + nameof(properties.CalculatedDefaultValue)); + } + + if (properties.DefaultValue.HasValue) + { + yield return new ValidationError("Calculated default value and default value cannot be used together.", + nameof(properties.CalculatedDefaultValue), + nameof(properties.DefaultValue)); + } + } + } + + public IEnumerable Visit(GeolocationFieldProperties properties) + { + if (!properties.Editor.IsEnumValue()) + { + yield return new ValidationError("Editor is not a valid value.", + nameof(properties.Editor)); + } + } + + public IEnumerable Visit(JsonFieldProperties properties) + { + yield break; + } + + public IEnumerable Visit(NumberFieldProperties properties) + { + if (!properties.Editor.IsEnumValue()) + { + yield return new ValidationError("Editor is not a valid value.", + nameof(properties.Editor)); + } + + if ((properties.Editor == NumberFieldEditor.Radio || properties.Editor == NumberFieldEditor.Dropdown) && (properties.AllowedValues == null || properties.AllowedValues.Count == 0)) + { + yield return new ValidationError("Radio buttons or dropdown list need allowed values.", + nameof(properties.AllowedValues)); + } + + if (properties.DefaultValue.HasValue && properties.MinValue.HasValue && properties.DefaultValue.Value < properties.MinValue.Value) + { + yield return new ValidationError("Default value must be greater than min value.", + nameof(properties.DefaultValue)); + } + + if (properties.DefaultValue.HasValue && properties.MaxValue.HasValue && properties.DefaultValue.Value > properties.MaxValue.Value) + { + yield return new ValidationError("Default value must be less than max value.", + nameof(properties.DefaultValue)); + } + + if (properties.MaxValue.HasValue && properties.MinValue.HasValue && properties.MinValue.Value >= properties.MaxValue.Value) + { + yield return new ValidationError("Max value must be greater than min value.", + nameof(properties.MinValue), + nameof(properties.MaxValue)); + } + + if (properties.AllowedValues != null && properties.AllowedValues.Count > 0 && (properties.MinValue.HasValue || properties.MaxValue.HasValue)) + { + yield return new ValidationError("Either allowed values or min and max value can be defined.", + nameof(properties.AllowedValues), + nameof(properties.MinValue), + nameof(properties.MaxValue)); + } + } + + public IEnumerable Visit(ReferencesFieldProperties properties) + { + if (properties.MaxItems.HasValue && properties.MinItems.HasValue && properties.MinItems.Value >= properties.MaxItems.Value) + { + yield return new ValidationError("Max items must be greater than min items.", + nameof(properties.MinItems), + nameof(properties.MaxItems)); + } + } + + public IEnumerable Visit(StringFieldProperties properties) + { + if (!properties.Editor.IsEnumValue()) + { + yield return new ValidationError("Editor is not a valid value.", + nameof(properties.Editor)); + } + + if ((properties.Editor == StringFieldEditor.Radio || properties.Editor == StringFieldEditor.Dropdown) && (properties.AllowedValues == null || properties.AllowedValues.Count == 0)) + { + yield return new ValidationError("Radio buttons or dropdown list need allowed values.", + nameof(properties.AllowedValues)); + } + + if (properties.Pattern != null && !properties.Pattern.IsValidRegex()) + { + yield return new ValidationError("Pattern is not a valid expression.", + nameof(properties.Pattern)); + } + + if (properties.MaxLength.HasValue && properties.MinLength.HasValue && properties.MinLength.Value >= properties.MaxLength.Value) + { + yield return new ValidationError("Max length must be greater than min length.", + nameof(properties.MinLength), + nameof(properties.MaxLength)); + } + + if (properties.AllowedValues != null && properties.AllowedValues.Count > 0 && (properties.MinLength.HasValue || properties.MaxLength.HasValue)) + { + yield return new ValidationError("Either allowed values or min and max length can be defined.", + nameof(properties.AllowedValues), + nameof(properties.MinLength), + nameof(properties.MaxLength)); + } + } + } +} diff --git a/src/Squidex.Domain.Apps.Write/Schemas/Guards/SchemaFieldGuard.cs b/src/Squidex.Domain.Apps.Write/Schemas/Guards/SchemaFieldGuard.cs index fc1cd7afc..9e6f320d3 100644 --- a/src/Squidex.Domain.Apps.Write/Schemas/Guards/SchemaFieldGuard.cs +++ b/src/Squidex.Domain.Apps.Write/Schemas/Guards/SchemaFieldGuard.cs @@ -6,8 +6,6 @@ // All rights reserved. // ========================================================================== -using System; -using System.Collections.Generic; using Squidex.Domain.Apps.Core.Schemas; using Squidex.Infrastructure; @@ -17,9 +15,9 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards { public static void GuardCanAdd(Schema schema, string name) { - if (!name.IsSlug()) + if (schema.FieldsByName.ContainsKey(name)) { - var error = new ValidationError("Name must be a valid slug.", "Name"); + var error = new ValidationError($"There is already a field with name '{name}'", "Name"); throw new ValidationException("Cannot add a new field.", error); } @@ -85,194 +83,24 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards } } - private static Field GetFieldOrThrow(Schema schema, long fieldId) + public static void GuardCanUpdate(Schema schema, long fieldId) { - if (!schema.FieldsById.TryGetValue(fieldId, out var field)) + var field = GetFieldOrThrow(schema, fieldId); + + if (field.IsLocked) { - throw new DomainObjectNotFoundException(fieldId.ToString(), "Fields", typeof(Field)); + throw new DomainException("Schema field is already locked."); } - - return field; } - public static IEnumerable ValidateProperties(FieldProperties properties) + private static Field GetFieldOrThrow(Schema schema, long fieldId) { - switch (properties) + if (!schema.FieldsById.TryGetValue(fieldId, out var field)) { - case AssetsFieldProperties a: - { - if (a.MaxItems.HasValue && a.MinItems.HasValue && a.MinItems.Value >= a.MaxItems.Value) - { - yield return new ValidationError("Max items must be greater than min items.", - nameof(a.MinItems), - nameof(a.MaxItems)); - } - - break; - } - - case BooleanFieldProperties b: - { - if (!b.Editor.IsEnumValue()) - { - yield return new ValidationError("Editor is not a valid value.", - nameof(b.Editor)); - } - - break; - } - - case GeolocationFieldProperties g: - { - if (!g.Editor.IsEnumValue()) - { - yield return new ValidationError("Editor is not a valid value.", - nameof(g.Editor)); - } - - break; - } - - case ReferencesFieldProperties r: - { - if (r.MaxItems.HasValue && r.MinItems.HasValue && r.MinItems.Value >= r.MaxItems.Value) - { - yield return new ValidationError("Max items must be greater than min items.", - nameof(r.MinItems), - nameof(r.MaxItems)); - } - - break; - } - - case DateTimeFieldProperties d: - { - if (!d.Editor.IsEnumValue()) - { - yield return new ValidationError("Editor is not a valid value.", - nameof(d.Editor)); - } - - if (d.DefaultValue.HasValue && d.MinValue.HasValue && d.DefaultValue.Value < d.MinValue.Value) - { - yield return new ValidationError("Default value must be greater than min value.", - nameof(d.DefaultValue)); - } - - if (d.DefaultValue.HasValue && d.MaxValue.HasValue && d.DefaultValue.Value > d.MaxValue.Value) - { - yield return new ValidationError("Default value must be less than max value.", - nameof(d.DefaultValue)); - } - - if (d.MaxValue.HasValue && d.MinValue.HasValue && d.MinValue.Value >= d.MaxValue.Value) - { - yield return new ValidationError("Max value must be greater than min value.", - nameof(d.MinValue), - nameof(d.MaxValue)); - } - - if (d.CalculatedDefaultValue.HasValue) - { - if (!d.CalculatedDefaultValue.Value.IsEnumValue()) - { - yield return new ValidationError("Calculated default value is not valid.", - nameof(d.CalculatedDefaultValue)); - } - - if (d.DefaultValue.HasValue) - { - yield return new ValidationError("Calculated default value and default value cannot be used together.", - nameof(d.CalculatedDefaultValue), - nameof(d.DefaultValue)); - } - } - - break; - } - - case NumberFieldProperties n: - { - if (!n.Editor.IsEnumValue()) - { - yield return new ValidationError("Editor is not a valid value.", - nameof(n.Editor)); - } - - if ((n.Editor == NumberFieldEditor.Radio || n.Editor == NumberFieldEditor.Dropdown) && (n.AllowedValues == null || n.AllowedValues.Count == 0)) - { - yield return new ValidationError("Radio buttons or dropdown list need allowed values.", - nameof(n.AllowedValues)); - } - - if (n.DefaultValue.HasValue && n.MinValue.HasValue && n.DefaultValue.Value < n.MinValue.Value) - { - yield return new ValidationError("Default value must be greater than min value.", - nameof(n.DefaultValue)); - } - - if (n.DefaultValue.HasValue && n.MaxValue.HasValue && n.DefaultValue.Value > n.MaxValue.Value) - { - yield return new ValidationError("Default value must be less than max value.", - nameof(n.DefaultValue)); - } - - if (n.MaxValue.HasValue && n.MinValue.HasValue && n.MinValue.Value >= n.MaxValue.Value) - { - yield return new ValidationError("Max value must be greater than min value.", - nameof(n.MinValue), - nameof(n.MaxValue)); - } - - if (n.AllowedValues != null && n.AllowedValues.Count > 0 && (n.MinValue.HasValue || n.MaxValue.HasValue)) - { - yield return new ValidationError("Either allowed values or min and max value can be defined.", - nameof(n.AllowedValues), - nameof(n.MinValue), - nameof(n.MaxValue)); - } - - break; - } - - case StringFieldProperties s: - { - if (!s.Editor.IsEnumValue()) - { - yield return new ValidationError("Editor is not a valid value.", - nameof(s.Editor)); - } - - if ((s.Editor == StringFieldEditor.Radio || s.Editor == StringFieldEditor.Dropdown) && (s.AllowedValues == null || s.AllowedValues.Count == 0)) - { - yield return new ValidationError("Radio buttons or dropdown list need allowed values.", - nameof(s.AllowedValues)); - } - - if (s.Pattern != null && !s.Pattern.IsValidRegex()) - { - yield return new ValidationError("Pattern is not a valid expression.", - nameof(s.Pattern)); - } - - if (s.MaxLength.HasValue && s.MinLength.HasValue && s.MinLength.Value >= s.MaxLength.Value) - { - yield return new ValidationError("Max length must be greater than min length.", - nameof(s.MinLength), - nameof(s.MaxLength)); - } - - if (s.AllowedValues != null && s.AllowedValues.Count > 0 && (s.MinLength.HasValue || s.MaxLength.HasValue)) - { - yield return new ValidationError("Either allowed values or min and max length can be defined.", - nameof(s.AllowedValues), - nameof(s.MinLength), - nameof(s.MaxLength)); - } - - break; - } + throw new DomainObjectNotFoundException(fieldId.ToString(), "Fields", typeof(Field)); } + + return field; } } } diff --git a/src/Squidex.Domain.Apps.Write/Schemas/Guards/SchemaGuard.cs b/src/Squidex.Domain.Apps.Write/Schemas/Guards/SchemaGuard.cs index d57ee4f7b..b228a7040 100644 --- a/src/Squidex.Domain.Apps.Write/Schemas/Guards/SchemaGuard.cs +++ b/src/Squidex.Domain.Apps.Write/Schemas/Guards/SchemaGuard.cs @@ -6,8 +6,8 @@ // All rights reserved. // ========================================================================== -using System; using System.Collections.Generic; +using System.Linq; using Squidex.Domain.Apps.Core.Schemas; using Squidex.Infrastructure; @@ -15,21 +15,16 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards { public static class SchemaGuard { - public static void GuardValidSchemaName(string name) + public static void GuardCanReorder(Schema schema, List fieldIds) { - if (!name.IsSlug()) + if (fieldIds.Count != schema.Fields.Count || fieldIds.Any(x => !schema.FieldsById.ContainsKey(x))) { - var error = new ValidationError("Name must be a valid slug.", "Name"); + var error = new ValidationError("Ids must cover all fields.", "FieldIds"); - throw new ValidationException("Cannot create a new schema.", error); + throw new ValidationException("Cannot reorder schema fields.", error); } } - internal static void GuardCanReorder(Schema schema, List fieldIds) - { - throw new NotImplementedException(); - } - public static void GuardCanPublish(Schema schema) { if (schema.IsPublished) diff --git a/src/Squidex.Domain.Apps.Write/Schemas/SchemaDomainObject.cs b/src/Squidex.Domain.Apps.Write/Schemas/SchemaDomainObject.cs index 336cb87c5..b82e139df 100644 --- a/src/Squidex.Domain.Apps.Write/Schemas/SchemaDomainObject.cs +++ b/src/Squidex.Domain.Apps.Write/Schemas/SchemaDomainObject.cs @@ -164,7 +164,7 @@ namespace Squidex.Domain.Apps.Write.Schemas VerifyCreatedAndNotDeleted(); - SchemaFieldGuard.GuardCanDelete(schema, command.FieldId); + SchemaFieldGuard.GuardCanUpdate(schema, command.FieldId); RaiseEvent(command, SimpleMapper.Map(command, new FieldUpdated())); diff --git a/tests/Squidex.Domain.Apps.Core.Tests/LanguagesConfigTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/LanguagesConfigTests.cs index 14e206b1e..7584f61ab 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/LanguagesConfigTests.cs +++ b/tests/Squidex.Domain.Apps.Core.Tests/LanguagesConfigTests.cs @@ -47,6 +47,7 @@ namespace Squidex.Domain.Apps.Core }); Assert.Equal(Language.DE, config.Master.Language); + Assert.Equal(3, config.Count); } [Fact] diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/AssetsFieldTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/AssetsFieldTests.cs index c8173acb3..baa83cb62 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/AssetsFieldTests.cs +++ b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/AssetsFieldTests.cs @@ -66,7 +66,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(null), errors); errors.ShouldBeEquivalentTo( - new[] { " is required" }); + new[] { " is required." }); } [Fact] @@ -77,7 +77,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(), errors); errors.ShouldBeEquivalentTo( - new[] { " is required" }); + new[] { " is required." }); } [Fact] @@ -88,7 +88,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync("invalid", errors); errors.ShouldBeEquivalentTo( - new[] { " is not a valid value" }); + new[] { " is not a valid value." }); } [Fact] @@ -99,7 +99,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(Guid.NewGuid(), Guid.NewGuid()), errors); errors.ShouldBeEquivalentTo( - new[] { " must have at least 3 asset(s)" }); + new[] { " must have at least 3 asset(s)." }); } [Fact] @@ -110,7 +110,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(Guid.NewGuid(), Guid.NewGuid()), errors); errors.ShouldBeEquivalentTo( - new[] { " must have not more than 1 asset(s)" }); + new[] { " must have not more than 1 asset(s)." }); } [Fact] @@ -123,7 +123,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(assetId), errors, ValidationTestExtensions.InvalidContext(assetId)); errors.ShouldBeEquivalentTo( - new[] { $" contains invalid asset '{assetId}'" }); + new[] { $" contains invalid asset '{assetId}'." }); } [Fact] @@ -206,6 +206,14 @@ namespace Squidex.Domain.Apps.Core.Schemas Assert.Same(token, result); } + [Fact] + public void Should_create_assets_value_with_empty_list_when_null() + { + var value = new AssetsValue(null); + + Assert.Equal(new List(), value.AssetIds); + } + private static JToken CreateValue(params Guid[] ids) { return ids == null ? JValue.CreateNull() : (JToken)new JArray(ids.OfType().ToArray()); diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/BooleanFieldTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/BooleanFieldTests.cs index 6ff2d9eba..8c03207be 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/BooleanFieldTests.cs +++ b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/BooleanFieldTests.cs @@ -62,7 +62,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(null), errors); errors.ShouldBeEquivalentTo( - new[] { " is required" }); + new[] { " is required." }); } [Fact] @@ -73,7 +73,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue("Invalid"), errors); errors.ShouldBeEquivalentTo( - new[] { " is not a valid value" }); + new[] { " is not a valid value." }); } private static JValue CreateValue(object v) diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/DateTimeFieldTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/DateTimeFieldTests.cs index 668b04f81..30c073a60 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/DateTimeFieldTests.cs +++ b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/DateTimeFieldTests.cs @@ -54,7 +54,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(null), errors); errors.ShouldBeEquivalentTo( - new[] { " is required" }); + new[] { " is required." }); } [Fact] @@ -65,7 +65,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(FutureDays(0)), errors); errors.ShouldBeEquivalentTo( - new[] { $" must be greater than '{FutureDays(10)}'" }); + new[] { $" must be greater than '{FutureDays(10)}'." }); } [Fact] @@ -76,7 +76,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(FutureDays(20)), errors); errors.ShouldBeEquivalentTo( - new[] { $" must be less than '{FutureDays(10)}'" }); + new[] { $" must be less than '{FutureDays(10)}'." }); } [Fact] @@ -87,7 +87,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue("Invalid"), errors); errors.ShouldBeEquivalentTo( - new[] { " is not a valid value" }); + new[] { " is not a valid value." }); } [Fact] @@ -98,7 +98,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(123), errors); errors.ShouldBeEquivalentTo( - new[] { " is not a valid value" }); + new[] { " is not a valid value." }); } private static Instant FutureDays(int days) diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/FieldRegistryTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/FieldRegistryTests.cs index ab21e2f53..215418532 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/FieldRegistryTests.cs +++ b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/FieldRegistryTests.cs @@ -7,7 +7,6 @@ // ========================================================================== using System; -using System.Collections.Generic; using Newtonsoft.Json.Linq; using Squidex.Infrastructure; using Xunit; diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/GeolocationFieldTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/GeolocationFieldTests.cs index 8d83d9f51..99e305ee9 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/GeolocationFieldTests.cs +++ b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/GeolocationFieldTests.cs @@ -70,7 +70,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(geolocation), errors); errors.ShouldBeEquivalentTo( - new[] { " is not a valid value" }); + new[] { " is not a valid value." }); } [Fact] @@ -86,7 +86,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(geolocation), errors); errors.ShouldBeEquivalentTo( - new[] { " is not a valid value" }); + new[] { " is not a valid value." }); } [Fact] @@ -97,7 +97,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(JValue.CreateNull()), errors); errors.ShouldBeEquivalentTo( - new[] { " is required" }); + new[] { " is required." }); } private static JToken CreateValue(JToken v) diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/JsonFieldTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/JsonFieldTests.cs index 7de264097..e4d649ee4 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/JsonFieldTests.cs +++ b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/JsonFieldTests.cs @@ -52,7 +52,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(JValue.CreateNull()), errors); errors.ShouldBeEquivalentTo( - new[] { " is required" }); + new[] { " is required." }); } private static JValue CreateValue(JValue v) diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/NumberFieldTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/NumberFieldTests.cs index afc742eca..95cfa32c2 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/NumberFieldTests.cs +++ b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/NumberFieldTests.cs @@ -53,7 +53,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(null), errors); errors.ShouldBeEquivalentTo( - new[] { " is required" }); + new[] { " is required." }); } [Fact] @@ -64,7 +64,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(5), errors); errors.ShouldBeEquivalentTo( - new[] { " must be greater than '10'" }); + new[] { " must be greater than '10'." }); } [Fact] @@ -75,7 +75,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(20), errors); errors.ShouldBeEquivalentTo( - new[] { " must be less than '10'" }); + new[] { " must be less than '10'." }); } [Fact] @@ -86,7 +86,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(20), errors); errors.ShouldBeEquivalentTo( - new[] { " is not an allowed value" }); + new[] { " is not an allowed value." }); } [Fact] @@ -97,7 +97,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue("Invalid"), errors); errors.ShouldBeEquivalentTo( - new[] { " is not a valid value" }); + new[] { " is not a valid value." }); } private static JValue CreateValue(object v) diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/ReferencesFieldTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/ReferencesFieldTests.cs index bfd5b08ec..6864a0a4e 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/ReferencesFieldTests.cs +++ b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/ReferencesFieldTests.cs @@ -67,7 +67,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(null), errors); errors.ShouldBeEquivalentTo( - new[] { " is required" }); + new[] { " is required." }); } [Fact] @@ -78,7 +78,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(), errors); errors.ShouldBeEquivalentTo( - new[] { " is required" }); + new[] { " is required." }); } [Fact] @@ -89,7 +89,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync("invalid", errors); errors.ShouldBeEquivalentTo( - new[] { " is not a valid value" }); + new[] { " is not a valid value." }); } [Fact] @@ -100,7 +100,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(Guid.NewGuid(), Guid.NewGuid()), errors); errors.ShouldBeEquivalentTo( - new[] { " must have at least 3 reference(s)" }); + new[] { " must have at least 3 reference(s)." }); } [Fact] @@ -111,7 +111,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(Guid.NewGuid(), Guid.NewGuid()), errors); errors.ShouldBeEquivalentTo( - new[] { " must have not more than 1 reference(s)" }); + new[] { " must have not more than 1 reference(s)." }); } [Fact] @@ -124,7 +124,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(referenceId), errors, ValidationTestExtensions.InvalidContext(referenceId)); errors.ShouldBeEquivalentTo( - new[] { $" contains invalid reference '{referenceId}'" }); + new[] { $" contains invalid reference '{referenceId}'." }); } [Fact] @@ -220,6 +220,14 @@ namespace Squidex.Domain.Apps.Core.Schemas Assert.Same(token, result); } + [Fact] + public void Should_create_references_value_with_empty_list_when_null() + { + var value = new ReferencesValue(null); + + Assert.Equal(new List(), value.ContentIds); + } + private static JToken CreateValue(params Guid[] ids) { return ids == null ? JValue.CreateNull() : (JToken)new JArray(ids.OfType().ToArray()); diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/SchemaTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/SchemaTests.cs index c01f79149..54f27eb8c 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/SchemaTests.cs +++ b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/SchemaTests.cs @@ -29,6 +29,11 @@ namespace Squidex.Domain.Apps.Core.Schemas { return null; } + + public override T Visit(IFieldPropertiesVisitor visitor) + { + return default(T); + } } [Fact] @@ -150,6 +155,14 @@ namespace Squidex.Domain.Apps.Core.Schemas Assert.Equal("my-hints", sut.FieldsById[1].RawProperties.Hints); } + [Fact] + public void Should_throw_exception_if_updating_with_invalid_properties_type() + { + Add(); + + Assert.Throws(() => sut.UpdateField(1, new StringFieldProperties())); + } + [Fact] public void Should_publish_schema() { diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/StringFieldTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/StringFieldTests.cs index bed7efcc7..951ba27fe 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/StringFieldTests.cs +++ b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/StringFieldTests.cs @@ -53,7 +53,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue(null), errors); errors.ShouldBeEquivalentTo( - new[] { " is required" }); + new[] { " is required." }); } [Fact] @@ -64,7 +64,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue("123"), errors); errors.ShouldBeEquivalentTo( - new[] { " must have more than '10' characters" }); + new[] { " must have more than '10' characters." }); } [Fact] @@ -75,7 +75,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue("12345678"), errors); errors.ShouldBeEquivalentTo( - new[] { " must have less than '5' characters" }); + new[] { " must have less than '5' characters." }); } [Fact] @@ -86,7 +86,7 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue("Bar"), errors); errors.ShouldBeEquivalentTo( - new[] { " is not an allowed value" }); + new[] { " is not an allowed value." }); } [Fact] @@ -97,18 +97,18 @@ namespace Squidex.Domain.Apps.Core.Schemas await sut.ValidateAsync(CreateValue("abc"), errors); errors.ShouldBeEquivalentTo( - new[] { " is not valid" }); + new[] { " is not valid." }); } [Fact] public async Task Should_add_errors_if_number_is_not_valid_pattern_with_message() { - var sut = new StringField(1, "my-string", Partitioning.Invariant, new StringFieldProperties { Pattern = "[0-9]{3}", PatternMessage = "Custom Error Message" }); + var sut = new StringField(1, "my-string", Partitioning.Invariant, new StringFieldProperties { Pattern = "[0-9]{3}", PatternMessage = "Custom Error Message." }); await sut.ValidateAsync(CreateValue("abc"), errors); errors.ShouldBeEquivalentTo( - new[] { "Custom Error Message" }); + new[] { "Custom Error Message." }); } private static JValue CreateValue(object v) diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/AllowedValuesValidatorTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/AllowedValuesValidatorTests.cs index fa23a2d72..7c015be0f 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/AllowedValuesValidatorTests.cs +++ b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/AllowedValuesValidatorTests.cs @@ -45,7 +45,7 @@ namespace Squidex.Domain.Apps.Core.Schemas.Validators await sut.ValidateAsync(50, errors); errors.ShouldBeEquivalentTo( - new[] { " is not an allowed value" }); + new[] { " is not an allowed value." }); } } } \ No newline at end of file diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/PatternValidatorTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/PatternValidatorTests.cs index c4d35fca6..5224cdd4e 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/PatternValidatorTests.cs +++ b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/PatternValidatorTests.cs @@ -55,18 +55,18 @@ namespace Squidex.Domain.Apps.Core.Schemas.Validators await sut.ValidateAsync("foo", errors); errors.ShouldBeEquivalentTo( - new[] { " is not valid" }); + new[] { " is not valid." }); } [Fact] public async Task Should_add_error_with_custom_message_if_value_is_not_valid() { - var sut = new PatternValidator("[a-z]{3}:[0-9]{2}", "Custom Error Message"); + var sut = new PatternValidator("[a-z]{3}:[0-9]{2}", "Custom Error Message."); await sut.ValidateAsync("foo", errors); errors.ShouldBeEquivalentTo( - new[] { "Custom Error Message" }); + new[] { "Custom Error Message." }); } } } diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/RangeValidatorTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/RangeValidatorTests.cs index b2b5b39f1..3eba5cbb5 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/RangeValidatorTests.cs +++ b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/RangeValidatorTests.cs @@ -58,7 +58,7 @@ namespace Squidex.Domain.Apps.Core.Schemas.Validators await sut.ValidateAsync(1500, errors); errors.ShouldBeEquivalentTo( - new[] { " must be greater than '2000'" }); + new[] { " must be greater than '2000'." }); } [Fact] @@ -69,7 +69,7 @@ namespace Squidex.Domain.Apps.Core.Schemas.Validators await sut.ValidateAsync(1500, errors); errors.ShouldBeEquivalentTo( - new[] { " must be less than '1000'" }); + new[] { " must be less than '1000'." }); } } } diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/RequiredStringValidatorTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/RequiredStringValidatorTests.cs index cdd7fddce..b5a5373cd 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/RequiredStringValidatorTests.cs +++ b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/RequiredStringValidatorTests.cs @@ -59,7 +59,7 @@ namespace Squidex.Domain.Apps.Core.Schemas.Validators await sut.ValidateAsync(string.Empty, errors); errors.ShouldBeEquivalentTo( - new[] { " is required" }); + new[] { " is required." }); } [Fact] @@ -70,7 +70,7 @@ namespace Squidex.Domain.Apps.Core.Schemas.Validators await sut.ValidateAsync(null, errors); errors.ShouldBeEquivalentTo( - new[] { " is required" }); + new[] { " is required." }); } } } diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/RequiredValidatorTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/RequiredValidatorTests.cs index 119e65d47..96a1a6b10 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/RequiredValidatorTests.cs +++ b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/RequiredValidatorTests.cs @@ -55,7 +55,7 @@ namespace Squidex.Domain.Apps.Core.Schemas.Validators await sut.ValidateAsync(null, errors); errors.ShouldBeEquivalentTo( - new[] { " is required" }); + new[] { " is required." }); } } } diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/StringLengthValidatorTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/StringLengthValidatorTests.cs index e4e114222..bed46e3be 100644 --- a/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/StringLengthValidatorTests.cs +++ b/tests/Squidex.Domain.Apps.Core.Tests/Schemas/Validators/StringLengthValidatorTests.cs @@ -69,7 +69,7 @@ namespace Squidex.Domain.Apps.Core.Schemas.Validators await sut.ValidateAsync(CreateString(1500), errors); errors.ShouldBeEquivalentTo( - new[] { " must have more than '2000' characters" }); + new[] { " must have more than '2000' characters." }); } [Fact] @@ -80,7 +80,7 @@ namespace Squidex.Domain.Apps.Core.Schemas.Validators await sut.ValidateAsync(CreateString(1500), errors); errors.ShouldBeEquivalentTo( - new[] { " must have less than '1000' characters" }); + new[] { " must have less than '1000' characters." }); } private static string CreateString(int size) diff --git a/tests/Squidex.Domain.Apps.Read.Tests/Contents/GraphQLTests.cs b/tests/Squidex.Domain.Apps.Read.Tests/Contents/GraphQLTests.cs index dba7120e3..2a4419573 100644 --- a/tests/Squidex.Domain.Apps.Read.Tests/Contents/GraphQLTests.cs +++ b/tests/Squidex.Domain.Apps.Read.Tests/Contents/GraphQLTests.cs @@ -40,23 +40,23 @@ namespace Squidex.Domain.Apps.Read.Contents private readonly Schema schemaDef = Schema.Create("my-schema", new SchemaProperties()) - .Add(new JsonField(1, "my-json", Partitioning.Invariant, + .AddField(new JsonField(1, "my-json", Partitioning.Invariant, new JsonFieldProperties())) - .Add(new StringField(2, "my-string", Partitioning.Language, + .AddField(new StringField(2, "my-string", Partitioning.Language, new StringFieldProperties())) - .Add(new NumberField(3, "my-number", Partitioning.Invariant, + .AddField(new NumberField(3, "my-number", Partitioning.Invariant, new NumberFieldProperties())) - .Add(new AssetsField(4, "my-assets", Partitioning.Invariant, + .AddField(new AssetsField(4, "my-assets", Partitioning.Invariant, new AssetsFieldProperties())) - .Add(new BooleanField(5, "my-boolean", Partitioning.Invariant, + .AddField(new BooleanField(5, "my-boolean", Partitioning.Invariant, new BooleanFieldProperties())) - .Add(new DateTimeField(6, "my-datetime", Partitioning.Invariant, + .AddField(new DateTimeField(6, "my-datetime", Partitioning.Invariant, new DateTimeFieldProperties())) - .Add(new ReferencesField(7, "my-references", Partitioning.Invariant, + .AddField(new ReferencesField(7, "my-references", Partitioning.Invariant, new ReferencesFieldProperties { SchemaId = schemaId })) - .Add(new ReferencesField(9, "my-invalid", Partitioning.Invariant, + .AddField(new ReferencesField(9, "my-invalid", Partitioning.Invariant, new ReferencesFieldProperties { SchemaId = Guid.NewGuid() })) - .Add(new GeolocationField(9, "my-geolocation", Partitioning.Invariant, + .AddField(new GeolocationField(10, "my-geolocation", Partitioning.Invariant, new GeolocationFieldProperties())); private readonly IContentQueryService contentQuery = A.Fake(); @@ -611,21 +611,21 @@ namespace Squidex.Domain.Apps.Read.Contents data = data ?? new NamedContentData() - .Add("my-json", + .AddField("my-json", new ContentFieldData().AddValue("iv", JToken.FromObject(new { value = 1 }))) - .Add("my-string", + .AddField("my-string", new ContentFieldData().AddValue("iv", "value")) - .Add("my-assets", + .AddField("my-assets", new ContentFieldData().AddValue("iv", JToken.FromObject(new[] { assetId }))) - .Add("my-number", + .AddField("my-number", new ContentFieldData().AddValue("iv", 1)) - .Add("my-boolean", + .AddField("my-boolean", new ContentFieldData().AddValue("iv", true)) - .Add("my-datetime", + .AddField("my-datetime", new ContentFieldData().AddValue("iv", now.ToDateTimeUtc())) - .Add("my-references", + .AddField("my-references", new ContentFieldData().AddValue("iv", JToken.FromObject(new[] { refId }))) - .Add("my-geolocation", + .AddField("my-geolocation", new ContentFieldData().AddValue("iv", JToken.FromObject(new { latitude = 10, longitude = 20 }))); var content = new FakeContentEntity diff --git a/tests/Squidex.Domain.Apps.Read.Tests/Contents/ODataQueryTests.cs b/tests/Squidex.Domain.Apps.Read.Tests/Contents/ODataQueryTests.cs index 4cef51e1b..c34b87fbc 100644 --- a/tests/Squidex.Domain.Apps.Read.Tests/Contents/ODataQueryTests.cs +++ b/tests/Squidex.Domain.Apps.Read.Tests/Contents/ODataQueryTests.cs @@ -31,21 +31,21 @@ namespace Squidex.Domain.Apps.Read.Contents { private readonly Schema schemaDef = Schema.Create("user", new SchemaProperties { Hints = "The User" }) - .Add(new StringField(1, "firstName", Partitioning.Language, + .AddField(new StringField(1, "firstName", Partitioning.Language, new StringFieldProperties { Label = "FirstName", IsRequired = true, AllowedValues = new[] { "1", "2" }.ToImmutableList() })) - .Add(new StringField(2, "lastName", Partitioning.Language, + .AddField(new StringField(2, "lastName", Partitioning.Language, new StringFieldProperties { Hints = "Last Name", Editor = StringFieldEditor.Input })) - .Add(new BooleanField(3, "isAdmin", Partitioning.Invariant, + .AddField(new BooleanField(3, "isAdmin", Partitioning.Invariant, new BooleanFieldProperties())) - .Add(new NumberField(4, "age", Partitioning.Invariant, + .AddField(new NumberField(4, "age", Partitioning.Invariant, new NumberFieldProperties { MinValue = 1, MaxValue = 10 })) - .Add(new DateTimeField(5, "birthday", Partitioning.Invariant, + .AddField(new DateTimeField(5, "birthday", Partitioning.Invariant, new DateTimeFieldProperties())) - .Add(new AssetsField(6, "pictures", Partitioning.Invariant, + .AddField(new AssetsField(6, "pictures", Partitioning.Invariant, new AssetsFieldProperties())) - .Add(new ReferencesField(7, "friends", Partitioning.Invariant, + .AddField(new ReferencesField(7, "friends", Partitioning.Invariant, new ReferencesFieldProperties())) - .Add(new StringField(8, "dashed-field", Partitioning.Invariant, + .AddField(new StringField(8, "dashed-field", Partitioning.Invariant, new StringFieldProperties())); private readonly IBsonSerializerRegistry registry = BsonSerializer.SerializerRegistry; diff --git a/tests/Squidex.Domain.Apps.Write.Tests/Apps/AppDomainObjectTests.cs b/tests/Squidex.Domain.Apps.Write.Tests/Apps/AppDomainObjectTests.cs index 488040b06..3301ed7e8 100644 --- a/tests/Squidex.Domain.Apps.Write.Tests/Apps/AppDomainObjectTests.cs +++ b/tests/Squidex.Domain.Apps.Write.Tests/Apps/AppDomainObjectTests.cs @@ -137,7 +137,7 @@ namespace Squidex.Domain.Apps.Write.Apps { Assert.Throws(() => { - sut.AssignContributor(CreateCommand(new AssignContributor())); + sut.AssignContributor(CreateCommand(new AssignContributor { Permission = (AppContributorPermission)123 })); }); } diff --git a/tests/Squidex.Domain.Apps.Write.Tests/Contents/ContentCommandMiddlewareTests.cs b/tests/Squidex.Domain.Apps.Write.Tests/Contents/ContentCommandMiddlewareTests.cs index 97fc70475..47f591378 100644 --- a/tests/Squidex.Domain.Apps.Write.Tests/Contents/ContentCommandMiddlewareTests.cs +++ b/tests/Squidex.Domain.Apps.Write.Tests/Contents/ContentCommandMiddlewareTests.cs @@ -38,16 +38,23 @@ namespace Squidex.Domain.Apps.Write.Contents private readonly IAppProvider appProvider = A.Fake(); private readonly IAppEntity app = A.Fake(); private readonly ClaimsPrincipal user = new ClaimsPrincipal(); - private readonly NamedContentData invalidData = new NamedContentData().Add("my-field", new ContentFieldData().SetValue(null)); - private readonly NamedContentData data = new NamedContentData().Add("my-field", new ContentFieldData().SetValue(1)); private readonly LanguagesConfig languagesConfig = LanguagesConfig.Create(Language.DE); private readonly Guid contentId = Guid.NewGuid(); + private readonly NamedContentData invalidData = + new NamedContentData() + .AddField("my-field", new ContentFieldData() + .SetValue(null)); + private readonly NamedContentData data = + new NamedContentData() + .AddField("my-field", new ContentFieldData() + .SetValue(1)); + public ContentCommandMiddlewareTests() { var schemaDef = Schema.Create("my-schema", new SchemaProperties()) - .Add(new NumberField(1, "my-field", Partitioning.Invariant, + .AddField(new NumberField(1, "my-field", Partitioning.Invariant, new NumberFieldProperties { IsRequired = true })); content = new ContentDomainObject(contentId, -1); @@ -177,7 +184,7 @@ namespace Squidex.Domain.Apps.Write.Contents A.CallTo(() => scriptEngine.ExecuteAndTransform(A.Ignored, A.Ignored)) .Returns(data); - var patch = new NamedContentData().Add("my-field", new ContentFieldData().SetValue(3)); + var patch = new NamedContentData().AddField("my-field", new ContentFieldData().SetValue(3)); A.CallTo(() => scriptEngine.ExecuteAndTransform(A.Ignored, A.Ignored)).Returns(patch); diff --git a/tests/Squidex.Domain.Apps.Write.Tests/Contents/ContentDomainObjectTests.cs b/tests/Squidex.Domain.Apps.Write.Tests/Contents/ContentDomainObjectTests.cs index 03fe48213..1cbeecbac 100644 --- a/tests/Squidex.Domain.Apps.Write.Tests/Contents/ContentDomainObjectTests.cs +++ b/tests/Squidex.Domain.Apps.Write.Tests/Contents/ContentDomainObjectTests.cs @@ -23,12 +23,12 @@ namespace Squidex.Domain.Apps.Write.Contents private readonly ContentDomainObject sut; private readonly NamedContentData data = new NamedContentData() - .Add("field1", + .AddField("field1", new ContentFieldData() .AddValue("iv", 1)); private readonly NamedContentData otherData = new NamedContentData() - .Add("field2", + .AddField("field2", new ContentFieldData() .AddValue("iv", 2)); @@ -215,6 +215,18 @@ namespace Squidex.Domain.Apps.Write.Contents }); } + [Fact] + public void ChangeStatus_should_throw_exception_if_status_flow_not_valid() + { + CreateContent(); + ChangeStatus(Status.Archived); + + Assert.Throws(() => + { + sut.ChangeStatus(CreateContentCommand(new ChangeContentStatus { Status = Status.Published })); + }); + } + [Fact] public void ChangeStatus_should_refresh_properties_and_create_events() { diff --git a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/AssetsFieldPropertiesTests.cs b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/AssetsFieldPropertiesTests.cs index 9fa7493ec..99f5abbc9 100644 --- a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/AssetsFieldPropertiesTests.cs +++ b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/AssetsFieldPropertiesTests.cs @@ -22,7 +22,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldPro { var sut = new AssetsFieldProperties { MinItems = 10, MaxItems = 5 }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List diff --git a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/BooleanFieldPropertiesTests.cs b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/BooleanFieldPropertiesTests.cs index c1dfc0dac..4469a2dcf 100644 --- a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/BooleanFieldPropertiesTests.cs +++ b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/BooleanFieldPropertiesTests.cs @@ -22,7 +22,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new BooleanFieldProperties { Editor = (BooleanFieldEditor)123 }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List diff --git a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/DateTimeFieldPropertiesTests.cs b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/DateTimeFieldPropertiesTests.cs index ba14c1575..14bd29f42 100644 --- a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/DateTimeFieldPropertiesTests.cs +++ b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/DateTimeFieldPropertiesTests.cs @@ -29,7 +29,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties DefaultValue = FutureDays(15) }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); Assert.Empty(errors); } @@ -39,7 +39,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new DateTimeFieldProperties { MinValue = FutureDays(10), DefaultValue = FutureDays(5) }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List @@ -53,7 +53,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new DateTimeFieldProperties { MaxValue = FutureDays(10), DefaultValue = FutureDays(15) }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List @@ -67,7 +67,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new DateTimeFieldProperties { MinValue = FutureDays(10), MaxValue = FutureDays(5) }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List @@ -81,7 +81,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new DateTimeFieldProperties { Editor = (DateTimeFieldEditor)123 }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List @@ -95,7 +95,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new DateTimeFieldProperties { CalculatedDefaultValue = (DateTimeCalculatedDefaultValue)123 }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List @@ -109,7 +109,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new DateTimeFieldProperties { CalculatedDefaultValue = DateTimeCalculatedDefaultValue.Now, DefaultValue = FutureDays(10) }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List diff --git a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/GeolocationFieldPropertiesTests.cs b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/GeolocationFieldPropertiesTests.cs index 86dd4e822..8f3967ee3 100644 --- a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/GeolocationFieldPropertiesTests.cs +++ b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/GeolocationFieldPropertiesTests.cs @@ -22,7 +22,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new GeolocationFieldProperties { Editor = (GeolocationFieldEditor)123 }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List diff --git a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/NumberFieldPropertiesTests.cs b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/NumberFieldPropertiesTests.cs index 62e258708..727a934bd 100644 --- a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/NumberFieldPropertiesTests.cs +++ b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/NumberFieldPropertiesTests.cs @@ -28,7 +28,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties DefaultValue = 5 }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); Assert.Empty(errors); } @@ -38,7 +38,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new NumberFieldProperties { MinValue = 10, DefaultValue = 5 }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List @@ -52,7 +52,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new NumberFieldProperties { MaxValue = 0, DefaultValue = 5 }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List @@ -66,7 +66,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new NumberFieldProperties { MinValue = 10, MaxValue = 5 }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List @@ -80,7 +80,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new NumberFieldProperties { MaxValue = 10, AllowedValues = ImmutableList.Create(4) }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List @@ -94,7 +94,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new NumberFieldProperties { MinValue = 10, AllowedValues = ImmutableList.Create(4) }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List @@ -108,7 +108,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new NumberFieldProperties { Editor = NumberFieldEditor.Radio }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List @@ -122,7 +122,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new NumberFieldProperties { Editor = (NumberFieldEditor)123 }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List diff --git a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/ReferencesFieldPropertiesTests.cs b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/ReferencesFieldPropertiesTests.cs index fd35e49df..2f721bf05 100644 --- a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/ReferencesFieldPropertiesTests.cs +++ b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/ReferencesFieldPropertiesTests.cs @@ -22,7 +22,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new ReferencesFieldProperties { MinItems = 10, MaxItems = 5 }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List diff --git a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/StringFieldPropertiesTests.cs b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/StringFieldPropertiesTests.cs index 04573e437..19c306680 100644 --- a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/StringFieldPropertiesTests.cs +++ b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/FieldProperties/StringFieldPropertiesTests.cs @@ -23,7 +23,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new StringFieldProperties { MinLength = 10, MaxLength = 5 }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List @@ -37,7 +37,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new StringFieldProperties { MinLength = 10, AllowedValues = ImmutableList.Create("4") }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List @@ -51,7 +51,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new StringFieldProperties { MaxLength = 10, AllowedValues = ImmutableList.Create("4") }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List @@ -65,7 +65,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new StringFieldProperties { Editor = StringFieldEditor.Radio }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List @@ -79,7 +79,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new StringFieldProperties { Editor = (StringFieldEditor)123 }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List @@ -93,7 +93,7 @@ namespace Squidex.Domain.Apps.Write.Schemas.Guards.FieldProperties { var sut = new StringFieldProperties { Pattern = "[0-9{1}" }; - var errors = SchemaFieldGuard.ValidateProperties(sut).ToList(); + var errors = FieldPropertiesValidator.Validate(sut).ToList(); errors.ShouldBeEquivalentTo( new List diff --git a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/SchemaFieldGuardTests.cs b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/SchemaFieldGuardTests.cs new file mode 100644 index 000000000..bbfcb89f9 --- /dev/null +++ b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/SchemaFieldGuardTests.cs @@ -0,0 +1,169 @@ +// ========================================================================== +// SchemaFieldGuardTests.cs +// Squidex Headless CMS +// ========================================================================== +// Copyright (c) Squidex Group +// All rights reserved. +// ========================================================================== + +using Squidex.Domain.Apps.Core; +using Squidex.Domain.Apps.Core.Schemas; +using Squidex.Infrastructure; +using Xunit; + +namespace Squidex.Domain.Apps.Write.Schemas.Guards +{ + public class SchemaFieldGuardTests + { + private Schema schema = + Schema.Create("my-schema", new SchemaProperties()) + .AddField(new StringField(1, "field1", Partitioning.Invariant)) + .AddField(new StringField(2, "field2", Partitioning.Invariant)); + + [Fact] + public void Should_throw_exception_if_field_to_hide_already_hidden() + { + schema = schema.HideField(1); + + Assert.Throws(() => SchemaFieldGuard.GuardCanHide(schema, 1)); + } + + [Fact] + public void Should_throw_exception_if_field_to_hide_not_found() + { + Assert.Throws(() => SchemaFieldGuard.GuardCanHide(schema, 3)); + } + + [Fact] + public void Should_not_throw_exception_if_field_to_hide_shown() + { + SchemaFieldGuard.GuardCanHide(schema, 1); + } + + [Fact] + public void Should_throw_exception_if_field_to_disable_not_found() + { + Assert.Throws(() => SchemaFieldGuard.GuardCanDisable(schema, 3)); + } + + [Fact] + public void Should_throw_exception_if_field_to_disable_already_disabled() + { + schema = schema.DisableField(1); + + Assert.Throws(() => SchemaFieldGuard.GuardCanDisable(schema, 1)); + } + + [Fact] + public void Should_not_throw_exception_if_field_to_disable_shown() + { + SchemaFieldGuard.GuardCanDisable(schema, 1); + } + + [Fact] + public void Should_throw_exception_if_field_to_show_already_shown() + { + Assert.Throws(() => SchemaFieldGuard.GuardCanShow(schema, 1)); + } + + [Fact] + public void Should_throw_exception_if_field_to_show_not_found() + { + Assert.Throws(() => SchemaFieldGuard.GuardCanShow(schema, 3)); + } + + [Fact] + public void Should_not_throw_exception_if_field_to_show_hidden() + { + schema = schema.HideField(1); + + SchemaFieldGuard.GuardCanShow(schema, 1); + } + + [Fact] + public void Should_throw_exception_if_field_to_enable_already_enabled() + { + Assert.Throws(() => SchemaFieldGuard.GuardCanEnable(schema, 1)); + } + + [Fact] + public void Should_throw_exception_if_field_to_enable_not_found() + { + Assert.Throws(() => SchemaFieldGuard.GuardCanEnable(schema, 3)); + } + + [Fact] + public void Should_not_throw_exception_if_field_to_enable_disabled() + { + schema = schema.DisableField(1); + + SchemaFieldGuard.GuardCanEnable(schema, 1); + } + + [Fact] + public void Should_throw_exception_if_field_to_lock_already_locked() + { + schema = schema.LockField(1); + + Assert.Throws(() => SchemaFieldGuard.GuardCanLock(schema, 1)); + } + + [Fact] + public void Should_throw_exception_if_field_to_lock_not_found() + { + Assert.Throws(() => SchemaFieldGuard.GuardCanLock(schema, 3)); + } + + [Fact] + public void Should_not_throw_exception_if_field_to_lock_not_locked() + { + SchemaFieldGuard.GuardCanLock(schema, 1); + } + + [Fact] + public void Should_throw_exception_if_field_to_delete_not_found() + { + Assert.Throws(() => SchemaFieldGuard.GuardCanDelete(schema, 3)); + } + + [Fact] + public void Should_throw_exception_if_field_to_delete_is_locked() + { + schema = schema.LockField(1); + + Assert.Throws(() => SchemaFieldGuard.GuardCanDelete(schema, 1)); + } + + [Fact] + public void Should_throw_exception_if_field_to_update_not_locked() + { + SchemaFieldGuard.GuardCanUpdate(schema, 1); + } + + [Fact] + public void Should_throw_exception_if_field_to_update_is_locked() + { + schema = schema.LockField(1); + + Assert.Throws(() => SchemaFieldGuard.GuardCanUpdate(schema, 1)); + } + + [Fact] + public void Should_throw_exception_if_field_to_delete_not_locked() + { + SchemaFieldGuard.GuardCanDelete(schema, 1); + } + + [Fact] + public void Should_throw_exception_if_field_to_add_already_exists() + { + Assert.Throws(() => SchemaFieldGuard.GuardCanAdd(schema, "field1")); + } + + [Fact] + public void Should_not_throw_exception_if_field_to_add_not_exists() + { + SchemaFieldGuard.GuardCanAdd(schema, "field3"); + } + } +} diff --git a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/SchemaGuardTests.cs b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/SchemaGuardTests.cs new file mode 100644 index 000000000..2b60fe010 --- /dev/null +++ b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/Guards/SchemaGuardTests.cs @@ -0,0 +1,65 @@ +// ========================================================================== +// SchemaGuardTests.cs +// Squidex Headless CMS +// ========================================================================== +// Copyright (c) Squidex Group +// All rights reserved. +// ========================================================================== + +using System.Collections.Generic; +using Squidex.Domain.Apps.Core; +using Squidex.Domain.Apps.Core.Schemas; +using Squidex.Infrastructure; +using Xunit; + +namespace Squidex.Domain.Apps.Write.Schemas.Guards +{ + public class SchemaGuardTests + { + private Schema schema = + Schema.Create("my-schema", new SchemaProperties()) + .AddField(new StringField(1, "field1", Partitioning.Invariant)) + .AddField(new StringField(2, "field2", Partitioning.Invariant)); + + [Fact] + public void Should_throw_exception_if_schema_to_publish_already_published() + { + schema = schema.Publish(); + + Assert.Throws(() => SchemaGuard.GuardCanPublish(schema)); + } + + [Fact] + public void Should_not_throw_exception_if_schema_to_publish_not_published() + { + SchemaGuard.GuardCanPublish(schema); + } + + [Fact] + public void Should_throw_exception_if_schema_to_unpublish_already_unpublished() + { + Assert.Throws(() => SchemaGuard.GuardCanUnpublish(schema)); + } + + [Fact] + public void Should_not_throw_exception_if_schema_to_unpublish_published() + { + schema = schema.Publish(); + + SchemaGuard.GuardCanUnpublish(schema); + } + + [Fact] + public void Should_throw_excepotion_if_schema_fields_to_reorder_not_valid() + { + Assert.Throws(() => SchemaGuard.GuardCanReorder(schema, new List { 1 })); + Assert.Throws(() => SchemaGuard.GuardCanReorder(schema, new List { 1, 3 })); + } + + [Fact] + public void Should_not_throw_excepotion_if_schema_fields_to_reorder_are_valid() + { + SchemaGuard.GuardCanReorder(schema, new List { 1, 2 }); + } + } +} diff --git a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/SchemaCommandMiddlewareTests.cs b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/SchemaCommandMiddlewareTests.cs index d5063392f..78c4152c2 100644 --- a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/SchemaCommandMiddlewareTests.cs +++ b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/SchemaCommandMiddlewareTests.cs @@ -212,6 +212,8 @@ namespace Squidex.Domain.Apps.Write.Schemas CreateSchema(); CreateField(); + HideField(); + var context = CreateContextForCommand(new ShowField { FieldId = 1 }); await TestUpdate(schema, async _ => @@ -240,6 +242,8 @@ namespace Squidex.Domain.Apps.Write.Schemas CreateSchema(); CreateField(); + DisableField(); + var context = CreateContextForCommand(new EnableField { FieldId = 1 }); await TestUpdate(schema, async _ => @@ -276,5 +280,15 @@ namespace Squidex.Domain.Apps.Write.Schemas { schema.Add(CreateCommand(new AddField { Name = fieldName, Properties = new NumberFieldProperties() })); } + + private void HideField() + { + schema.HideField(CreateCommand(new HideField { FieldId = 1 })); + } + + private void DisableField() + { + schema.DisableField(CreateCommand(new DisableField { FieldId = 1 })); + } } } diff --git a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/SchemaDomainObjectTests.cs b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/SchemaDomainObjectTests.cs index 8c7a0239d..34a8d0f81 100644 --- a/tests/Squidex.Domain.Apps.Write.Tests/Schemas/SchemaDomainObjectTests.cs +++ b/tests/Squidex.Domain.Apps.Write.Tests/Schemas/SchemaDomainObjectTests.cs @@ -64,7 +64,40 @@ namespace Squidex.Domain.Apps.Write.Schemas { Name = null, Properties = null, - Partitioning = "invalid" + Partitioning = "invalid", + }, + new CreateSchemaField + { + Name = null, + Properties = InvalidProperties(), + Partitioning = "invalid", + } + }; + + Assert.Throws(() => + { + sut.Create(CreateCommand(new CreateSchema { Name = SchemaName, Properties = properties, Fields = fields })); + }); + } + + [Fact] + public void Create_should_throw_exception_if_fields_contain_duplicate_names() + { + var properties = new SchemaProperties(); + + var fields = new List + { + new CreateSchemaField + { + Name = "field1", + Properties = ValidProperties(), + Partitioning = "invariant" + }, + new CreateSchemaField + { + Name = "field1", + Properties = ValidProperties(), + Partitioning = "invariant" } }; @@ -96,8 +129,8 @@ namespace Squidex.Domain.Apps.Write.Schemas var fields = new List { - new CreateSchemaField { Name = "field1", Properties = new GeolocationFieldProperties() }, - new CreateSchemaField { Name = "field2", Properties = new StringFieldProperties() } + new CreateSchemaField { Name = "field1", Properties = ValidProperties() }, + new CreateSchemaField { Name = "field2", Properties = ValidProperties() } }; sut.Create(CreateCommand(new CreateSchema { Name = SchemaName, Properties = properties, Fields = fields })); @@ -244,8 +277,8 @@ namespace Squidex.Domain.Apps.Write.Schemas CreateSchema(); - sut.Add(new AddField { Name = "field1", Properties = new StringFieldProperties() }); - sut.Add(new AddField { Name = "field2", Properties = new StringFieldProperties() }); + sut.Add(new AddField { Name = "field1", Properties = ValidProperties() }); + sut.Add(new AddField { Name = "field2", Properties = ValidProperties() }); ((IAggregate)sut).ClearUncommittedEvents(); @@ -367,16 +400,16 @@ namespace Squidex.Domain.Apps.Write.Schemas } [Fact] - public void Add_should_throw_exception_if_not_created() + public void AddField_should_throw_exception_if_not_created() { Assert.Throws(() => { - sut.Add(CreateCommand(new AddField { Name = fieldName, Properties = new NumberFieldProperties() })); + sut.Add(CreateCommand(new AddField { Name = fieldName, Properties = ValidProperties() })); }); } [Fact] - public void Add_should_throw_exception_if_command_is_not_valid() + public void AddField_should_throw_exception_if_command_is_not_valid() { Assert.Throws(() => { @@ -385,16 +418,25 @@ namespace Squidex.Domain.Apps.Write.Schemas } [Fact] - public void Add_should_throw_exception_if_command_contains_invalid_partitioning() + public void AddField_should_throw_exception_if_command_contains_invalid_partitioning() + { + Assert.Throws(() => + { + sut.Add(CreateCommand(new AddField { Name = fieldName, Partitioning = "invalid", Properties = ValidProperties() })); + }); + } + + [Fact] + public void AddField_should_throw_exception_if_command_contains_invalid_properties() { Assert.Throws(() => { - sut.Add(CreateCommand(new AddField { Name = fieldName, Partitioning = "invalid", Properties = new NumberFieldProperties() })); + sut.Add(CreateCommand(new AddField { Name = fieldName, Properties = InvalidProperties() })); }); } [Fact] - public void Add_should_throw_exception_if_schema_is_deleted() + public void AddField_should_throw_exception_if_schema_is_deleted() { CreateSchema(); DeleteSchema(); @@ -787,5 +829,15 @@ namespace Squidex.Domain.Apps.Write.Schemas ((IAggregate)sut).ClearUncommittedEvents(); } + + private static StringFieldProperties ValidProperties() + { + return new StringFieldProperties { MinLength = 10, MaxLength = 20 }; + } + + private static StringFieldProperties InvalidProperties() + { + return new StringFieldProperties { MinLength = 20, MaxLength = 10 }; + } } }