public void WithPortugueseTranslation_Should_AddTranslation() { var settings = new ValidatorSettings(); settings.WithPortugueseTranslation(); TranslationTestHelpers.ShouldContainSingleTranslation(settings.Translations, "Portuguese", Translation.Portuguese); }
public void Should_PassAllEntries() { var validatorSettings = new ValidatorSettings(); var dictionary = new Dictionary <string, string>() { ["k1"] = "v1", ["k2"] = "v2", ["k3"] = "v3", ["k4"] = "v4", }; validatorSettings.WithTranslation("name", dictionary); validatorSettings.Translations.ShouldBeLikeTranslations( new Dictionary <string, IReadOnlyDictionary <string, string> >() { ["name"] = new Dictionary <string, string>() { ["k1"] = "v1", ["k2"] = "v2", ["k3"] = "v3", ["k4"] = "v4", }, }); }
public Validator(ValidatorSettings settings = null) { _expressionValidator = new ClassValidatorExpression(); _errors = new Dictionary <string, List <string> >(); _settings = settings ?? new ValidatorSettings(); }
public void Should_ThrowException_When_NullEntryInDictionary() { var validatorSettings = new ValidatorSettings(); var dictionary = new Dictionary <string, IReadOnlyDictionary <string, string> >() { ["name1"] = new Dictionary <string, string>() { ["k11"] = "v11", ["k12"] = "v12", ["k13"] = null, ["k14"] = "v14", }, ["name2"] = new Dictionary <string, string>() { ["k21"] = "v21", ["k22"] = "v22", ["k23"] = "v23", ["k24"] = "v24", } }; Action action = () => validatorSettings.WithTranslation(dictionary); action.Should().ThrowExactly <ArgumentNullException>(); }
public void WithEnglishTranslation_Should_AddTranslation() { var settings = new ValidatorSettings(); settings.WithEnglishTranslation(); ShouldAddSingleTranslation(settings.Translations, "English", Translation.English); }
public static ValidatorSettings WithTranslation(this ValidatorSettings @this, ITranslationHolder translationHolder) { ThrowHelper.NullArgument(@this, nameof(@this)); ThrowHelper.NullArgument(translationHolder, nameof(translationHolder)); return(@this.WithTranslation(translationHolder.Translations)); }
/// <summary> /// Creates instance of <see cref="IValidator{T}"/> that can validate objects of type <typeparamref name="T"/> against the specification provided in the <paramref name="specificationHolder"/>. /// </summary> /// <param name="specificationHolder">Object that provides specification used to validate models (its member <see cref="ISpecificationHolder{T}.Specification"/>) and, optionally, settings (<see cref="ISettingsHolder.Settings"/>, if it implements also <see cref="ISettingsHolder"/>.</param> /// <param name="settings">Settings builder that helps adjust the created <see cref="IValidator{T}"/>'s settings. If not present, the default values are provided. Overrides translations delivered by <paramref name="specificationHolder"/>, if it implements also <see cref="ISettingsHolder"/>.</param> /// <typeparam name="T">Type of the models that this instance of <see cref="IValidator{T}"/> can validate.</typeparam> /// <returns>Instance of <see cref="IValidator{T}"/>, fully initialized and ready to work.</returns> /// <exception cref="ArgumentNullException">Thrown if <paramref name="specificationHolder"/> is null.</exception> /// <exception cref="InvalidOperationException">Thrown if <paramref name="specificationHolder"/>'s <see cref="ISettingsHolder.Settings"/> is null.</exception> public IValidator <T> Create <T>(ISpecificationHolder <T> specificationHolder, Func <ValidatorSettings, ValidatorSettings> settings = null) { if (specificationHolder is null) { throw new ArgumentNullException(nameof(specificationHolder)); } var validatorSettings = ValidatorSettings.GetDefault(); if (specificationHolder is ISettingsHolder validatorSettingsHolder) { if (validatorSettingsHolder.Settings is null) { throw new ArgumentException($"{nameof(ISettingsHolder)} can't have null {nameof(ISettingsHolder.Settings)}", nameof(specificationHolder)); } validatorSettings = GetResolvedSettings(validatorSettings, validatorSettingsHolder.Settings); } validatorSettings = GetResolvedSettings(validatorSettings, settings); var modelScheme = ModelSchemeFactory.Create(specificationHolder.Specification); SetReferenceLoopProtection(validatorSettings, modelScheme.IsReferenceLoopPossible); return(Create(specificationHolder.Specification, validatorSettings)); }
private static void AddRule(ValidatorSettings settings, string filePath) => settings.rules.Add(new RuleItem { Name = RuleUtility.FilePath2RuleName(filePath), Enabled = true, FilePath = filePath, });
public void WithRussianTranslation_Should_AddTranslation() { var settings = new ValidatorSettings(); settings.WithRussianTranslation(); TranslationTestHelpers.ShouldContainSingleTranslation(settings.Translations, "Russian", Translation.Russian); }
private static void FetchRules(ValidatorSettings settings = null) { if (settings == null) { settings = GetOrCreateSettings(); } var currentRuleFilePaths = RuleUtility.GetRuleFilePaths().ToArray(); var settingsFilePaths = settings.rules.Select(rule => rule.FilePath).ToArray(); // 現在の設定にないものを追加する foreach (var filePath in currentRuleFilePaths) { if (!settingsFilePaths.Contains(filePath)) { AddRule(settings, filePath); } } // 現在の設定に余分にあるものを削除する var deleteRuleIndices = new List <int>(); foreach (var filePath in settingsFilePaths) { if (!currentRuleFilePaths.Contains(filePath)) { var index = Array.IndexOf(currentRuleFilePaths, filePath); deleteRuleIndices.Add(index); } } foreach (int index in deleteRuleIndices.OrderByDescending(x => x)) { settings.rules.RemoveAt(index); } }
public void Should_PassAllEntries() { var validatorSettings = new ValidatorSettings(); var holder = new ValidatorSettingsTests.WithTranslation.TestTranslationHolder() { Translations = new Dictionary <string, IReadOnlyDictionary <string, string> >() { ["name"] = new Dictionary <string, string>() { ["k1"] = "v1", ["k2"] = "v2", ["k3"] = "v3", ["k4"] = "v4", } } }; validatorSettings.WithTranslation(holder); validatorSettings.Translations.ShouldBeLikeTranslations( new Dictionary <string, IReadOnlyDictionary <string, string> >() { ["name"] = new Dictionary <string, string>() { ["k1"] = "v1", ["k2"] = "v2", ["k3"] = "v3", ["k4"] = "v4", }, }); }
private static IInputValidator CreateValidator(string validatorType) { if (validatorType.Equals("custom", StringComparison.InvariantCultureIgnoreCase)) { validatorSettings = Config.GetSection("custom").Get <ValidatorSettings>(); } else { validatorSettings = Config.GetSection("default").Get <ValidatorSettings>(); } validator = new InputValidator(); validator.FirstNameMinLength = validatorSettings.FirstName.Min; validator.FirstNameMaxLength = validatorSettings.FirstName.Max; validator.LastNameMinLength = validatorSettings.LastName.Min; validator.LastNameMaxLength = validatorSettings.LastName.Max; validator.MinDate = validatorSettings.DateOfBirth.From; validator.MaxDate = validatorSettings.DateOfBirth.To; validator.Gender = validatorSettings.Gender.ToList(); validator.MinOffice = validatorSettings.Office.Min; validator.MaxOffice = validatorSettings.Office.Max; validator.MinSalary = validatorSettings.Salary.Min; validator.MaxSalary = validatorSettings.Salary.Max; return(validator); }
public void WithSpanishTranslation_Should_AddTranslation() { var settings = new ValidatorSettings(); settings.WithSpanishTranslation(); TranslationTestHelpers.ShouldContainSingleTranslation(settings.Translations, "Spanish", Translation.Spanish); }
public void Should_ThrowException_When_NullName() { var validatorSettings = new ValidatorSettings(); Action action = () => validatorSettings.WithTranslation(null, new Dictionary <string, string>()); action.Should().ThrowExactly <ArgumentNullException>(); }
public void Should_ReturnSelf() { var validatorSettings = new ValidatorSettings(); var result = validatorSettings.WithTranslation("name", new Dictionary <string, string>()); result.Should().BeSameAs(validatorSettings); }
public void Should_ThrowException_When_NullHolder() { var validatorSettings = new ValidatorSettings(); Action action = () => validatorSettings.WithTranslation(null as ITranslationHolder); action.Should().ThrowExactly <ArgumentNullException>(); }
public void Should_ThrowException_When_NullDictionary() { var validatorSettings = new ValidatorSettings(); Action action = () => validatorSettings.WithTranslation("name", null); action.Should().ThrowExactly <ArgumentNullException>(); }
public void Should_Initialize_WithDefaultValues() { var validatorSettings = new ValidatorSettings(); validatorSettings.Translations.Should().BeEmpty(); validatorSettings.ReferenceLoopProtectionEnabled.Should().BeNull(); validatorSettings.IsLocked.Should().BeFalse(); }
public void Should_WithReferenceLoopProtectionDisabled_Set_ReferenceLoopProtection_To_False() { var validatorSettings = new ValidatorSettings(); validatorSettings.WithReferenceLoopProtectionDisabled(); validatorSettings.ReferenceLoopProtection.Should().BeFalse(); }
public void Should_WithReferenceLoopProtection_Set_ReferenceLoopProtection_To_True() { var validatorSettings = new ValidatorSettings(); validatorSettings.WithReferenceLoopProtection(); validatorSettings.ReferenceLoopProtection.Should().BeTrue(); }
public void Should_WithReferenceLoopProtectionDisabled_ReturnSelf() { var validatorSettings = new ValidatorSettings(); var result = validatorSettings.WithReferenceLoopProtectionDisabled(); result.Should().BeSameAs(validatorSettings); }
public void Should_ReturnSelf() { var validatorSettings = new ValidatorSettings(); var result = validatorSettings.WithTranslation("name", "key", "translation"); result.Should().BeSameAs(validatorSettings); }
public void Should_ThrowException_When_NullArgument(string name, string key, string translation) { var validatorSettings = new ValidatorSettings(); Action action = () => validatorSettings.WithTranslation(name, key, translation); action.Should().ThrowExactly <ArgumentNullException>(); }
private static void SetReferenceLoopProtection(ValidatorSettings settings, bool isReferenceLoopPossible) { if (!settings.ReferenceLoopProtectionEnabled.HasValue) { _ = isReferenceLoopPossible ? settings.WithReferenceLoopProtection() : settings.WithReferenceLoopProtectionDisabled(); } }
public void CreateValidatorNoDefaultPhaseSpecified() { XDocument xSchema = Resources.Provider.LoadXmlDocument("GoodSchemas.no_default_phase.xml"); ValidatorSettings settings = new ValidatorSettings() { Phase = "#DEFAULT" }; Assert.Throws <ArgumentException>(() => Validator.Create(xSchema, settings)); }
public void CreateValidatorGoodSchemaWithBadSettings() { XDocument xSchema = Resources.Provider.LoadXmlDocument(PHASES_SCHEMA); ValidatorSettings settings = new ValidatorSettings() { Phase = null }; Assert.Throws <ArgumentNullException>(() => Validator.Create(xSchema, settings)); }
public void Settings_ModificationViaMethod() { var settings = new ValidatorSettings(); settings.ReferenceLoopProtection.Should().BeNull(); settings.WithReferenceLoopProtection(); settings.ReferenceLoopProtection.Should().BeTrue(); }
public static ValidatorSettings WithYodaEnglish(this ValidatorSettings @this) { var dictionary = new Dictionary <string, string>() { ["Global.Required"] = "Exist, it must.", ["Numbers.LessThan"] = "Greater than {max}, the number must, be not." }; return(@this.WithTranslation("YodaEnglish", dictionary)); }
public void Should_LockSettingsAfterPassingToValidator() { var settings = new ValidatorSettings(); settings.IsLocked.Should().BeFalse(); _ = new Validator <object>(_ => _, settings); settings.IsLocked.Should().BeTrue(); }
public void Should_LockSettingsAfterPassingToFactory_ExternalSettings() { var settings = new ValidatorSettings(); settings.IsLocked.Should().BeFalse(); _ = Validator.Factory.Create <object>(s => s, s => settings); settings.IsLocked.Should().BeTrue(); }
private Validator CreateValidator(string phase, XDocument schema) { ValidatorSettings validatorSettings = new ValidatorSettings(); if (!string.IsNullOrWhiteSpace(phase)) { validatorSettings.Phase = phase; } if (isProcessingVerbose) { System.Console.WriteLine(string.Format( "Creating the validator with phase '{0}'.", validatorSettings.Phase)); } Validator validator = Validator.Create(schema, validatorSettings); return validator; }