public void NegatedReturnsFailureForStringShorterThanMaxLengthForMaxLengthOnlyValidator() { Validator<string> validator = new StringLengthValidator(10, true); ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 5).ToString()); Assert.IsFalse(validationResults.IsValid); }
public void ReturnFailureForNullStringThroughNonGenericInterface() { Validator<string> validator = new StringLengthValidator(1, 10); ValidationResults validationResults = validator.Validate(null); Assert.IsFalse(validationResults.IsValid); }
public void ReturnsSuccessForStringAsLongAsMaxLengthForMaxLengthOnlyValidator() { Validator<string> validator = new StringLengthValidator(10); ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 10).ToString()); Assert.IsTrue(validationResults.IsValid); }
public void ConstructorWithBoundsAndBoundTypesAndMessageOverrideAndNegatedInitializesAppropriateInstance() { StringLengthValidator validator = new StringLengthValidator(5, RangeBoundaryType.Exclusive, 10, RangeBoundaryType.Exclusive, "message template override", true); Assert.AreEqual(5, validator.LowerBound); Assert.AreEqual(RangeBoundaryType.Exclusive, validator.LowerBoundType); Assert.AreEqual(10, validator.UpperBound); Assert.AreEqual(RangeBoundaryType.Exclusive, validator.UpperBoundType); Assert.AreEqual("message template override", validator.MessageTemplate); Assert.AreEqual(true, validator.Negated); }
public void ConstructorWithBoundsAndBoundTypesAndNullMessageOverrideInitializesAndNegatedAppropriateInstanceWithDefaultMessage() { StringLengthValidator validator = new StringLengthValidator(5, RangeBoundaryType.Exclusive, 10, RangeBoundaryType.Exclusive, null, true); Assert.AreEqual(5, validator.LowerBound); Assert.AreEqual(RangeBoundaryType.Exclusive, validator.LowerBoundType); Assert.AreEqual(10, validator.UpperBound); Assert.AreEqual(RangeBoundaryType.Exclusive, validator.UpperBoundType); Assert.AreEqual(Resources.StringLengthValidatorNegatedDefaultMessageTemplate, validator.MessageTemplate); Assert.AreEqual(true, validator.Negated); }
public void StringLengthValidator_WhenStringIsLongerThanMaxLength_IsValid() { const string INPUT = "a test string"; const bool EXPECTED = false; StringLengthValidator validator = new StringLengthValidator(10); bool result = validator.IsValid(INPUT); Assert.AreEqual(EXPECTED, result); }
public void ReturnsFailureForStringLongerThanMaxLengthForMaxLengthOnlyValidator() { Validator <string> validator = new StringLengthValidator(10); ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 11).ToString()); Assert.IsFalse(validationResults.IsValid); IList <ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults); Assert.AreEqual(1, resultsList.Count); Assert.IsTrue(TemplateStringTester.IsMatch(Resources.StringLengthValidatorNonNegatedDefaultMessageTemplate, resultsList[0].Message)); }
public void StringLengthValidator_WhenStringIsSmaller_IsValid() { const string INPUT = "a test"; const bool EXPECTED = true; const int MAX_LENGTH = 13; StringLengthValidator validator = new StringLengthValidator(MAX_LENGTH); bool result = validator.IsValid(INPUT); Assert.AreEqual(EXPECTED, result); }
public void GetErrors_returns_error_for_length_greater_than_max() { var validator = new StringLengthValidator(10); var errors = validator.GetErrors("12345678901").ToArray(); Assert.Equal(1, errors.Length); var error = errors[0]; Assert.IsType <StringLengthValidationError>(error); Assert.Equal(10, ((StringLengthValidationError)error).MaxLength); }
public int TestValidation(string value, int minimumLength, int maximumLength) { // Arrange. var validator = new StringLengthValidator<TestEntity>(minimumLength, maximumLength) { AllowNull = true }; var instance = new TestEntity(); var context = DocumentValidationContext<TestEntity>.Create(instance, SaveType.Any); // Act. return validator.Validate(value, context).Count(); }
public int TestValidation(string value, int minimumLength, int maximumLength) { // Arrange. var validator = new StringLengthValidator <TestEntity>(minimumLength, maximumLength) { AllowNull = true }; var instance = new TestEntity(); var context = DocumentValidationContext <TestEntity> .Create(instance, SaveType.Any); // Act. return(validator.Validate(value, context).Count()); }
public void Should_Return_Valid_When_String_Is_Forty_Character_Long() { // Arrange var validator = new StringLengthValidator(40); // Act var result = validator.IsValid(new string('A', 40)); // Assert result.ShouldNotBeNull(); result.Valid.ShouldBeTrue(); result.ErrorMessages.ShouldNotBeNull(); result.ErrorMessages.ShouldBeEmpty(); }
public IActionResult Index(StringLengthValidator model, string btnAction) { if (btnAction == "Submit") { if (ModelState.IsValid) { ViewBag.comment = model.comment; } } if (btnAction == "Reset") { ModelState.Clear(); } return(View()); }
public void Should_Return_Invalid_When_String_Lenghts_Dont_Match() { // Arrange var validator = new StringLengthValidator(40); // Act var result = validator.IsValid(new string('A', 39)); // Assert result.ShouldNotBeNull(); result.Valid.ShouldBeFalse(); result.ErrorMessages.ShouldNotBeNull(); result.ErrorMessages.Count.ShouldEqual(1); result.ErrorMessages.Single().ParamName.ShouldEqual("input"); result.ErrorMessages.Single().Message.ShouldEqual("Length of input string does not match expected. Expected: 40. Actual: 39."); }
/// <summary> /// String Length /// </summary> /// <typeparam name="T">DataType</typeparam> /// <param name="maxLength">max length</param> /// <param name="minLength">min length</param> /// <param name="fields">fields</param> public static void StringLength <T>(int maxLength, int minLength = 0, params ValidationField <T>[] fields) { string validatorKey = string.Format("{0}/{1}_{2}", typeof(StringLengthValidator).FullName, maxLength, minLength); DataValidator validator = null; if (_validatorList.ContainsKey(validatorKey)) { validator = _validatorList[validatorKey]; } else { validator = new StringLengthValidator(maxLength, minLength); _validatorList.Add(validatorKey, validator); } SetValidation <T>(validator, fields); }
public void AttributeWithUpperBoundOnlyCreatesAppropriateValidator() { ValidatorAttribute attribute = new StringLengthValidatorAttribute(20); Validator validator = ((IValidatorDescriptor)attribute).CreateValidator(null, null, null, null); Assert.IsNotNull(validator); StringLengthValidator stringLengthValidator = validator as StringLengthValidator; Assert.IsNotNull(stringLengthValidator); Assert.AreEqual(RangeBoundaryType.Ignore, stringLengthValidator.LowerBoundType); Assert.AreEqual(20, stringLengthValidator.UpperBound); Assert.AreEqual(RangeBoundaryType.Inclusive, stringLengthValidator.UpperBoundType); Assert.AreEqual(Resources.StringLengthValidatorNonNegatedDefaultMessageTemplate, stringLengthValidator.MessageTemplate); Assert.AreEqual(false, stringLengthValidator.Negated); }
public async Task InternValidators() { await _emTask; var vr2 = new RequiredValidator().Intern(); var vr3 = new RequiredValidator().Intern(); Assert.IsTrue(vr2 == vr3); Assert.IsTrue(vr2.Equals(vr3)); var mlVr2 = new MaxLengthValidator(17).Intern(); var mlVr3 = new MaxLengthValidator(17).Intern(); Assert.IsTrue(mlVr2 == mlVr3); Assert.IsTrue(mlVr2.Equals(mlVr3)); var slVr2 = new StringLengthValidator(3, 12).Intern(); var slVr3 = new StringLengthValidator(3, 12).Intern(); Assert.IsTrue(slVr2 == slVr3); Assert.IsTrue(slVr2.Equals(slVr3)); }
public StringLengthValidatorOperation( string keyToValidate, string resultKey, int lowerBound, RangeBoundaryType lowerBoundaryType, int upperBound, RangeBoundaryType upperBoundaryType, bool negated) : base(keyToValidate, resultKey) { Validator = new StringLengthValidator( lowerBound, lowerBoundaryType, upperBound, upperBoundaryType, string.Empty, negated ); }
public StringLengthValidatorOperation( string keyToValidate, string resultKey, int lowerBound, RangeBoundaryType lowerBoundaryType, int upperBound, RangeBoundaryType upperBoundaryType, bool negated) : base(keyToValidate, resultKey) { Validator = new StringLengthValidator( lowerBound, lowerBoundaryType, upperBound, upperBoundaryType, string.Empty, negated ); }
public void AttributeWithLowerAndUpperBoundsAndBoundTypesAndMessageTemplateCreatesAppropriateValidator() { ValidatorAttribute attribute = new StringLengthValidatorAttribute(10, RangeBoundaryType.Exclusive, 0, RangeBoundaryType.Ignore); attribute.MessageTemplate = "my message template"; Validator validator = ((IValidatorDescriptor)attribute).CreateValidator(null, null, null, null); Assert.IsNotNull(validator); StringLengthValidator stringLengthValidator = validator as StringLengthValidator; Assert.IsNotNull(stringLengthValidator); Assert.AreEqual(10, stringLengthValidator.LowerBound); Assert.AreEqual(RangeBoundaryType.Exclusive, stringLengthValidator.LowerBoundType); Assert.AreEqual(0, stringLengthValidator.UpperBound); Assert.AreEqual(RangeBoundaryType.Ignore, stringLengthValidator.UpperBoundType); Assert.AreEqual("my message template", stringLengthValidator.MessageTemplate); Assert.AreEqual(false, stringLengthValidator.Negated); }
public void AttributeWithLowerAndUpperBoundsOnlyAndNegatedCreatesAppropriateValidator() { ValueValidatorAttribute attribute = new StringLengthValidatorAttribute(10, 20); attribute.Negated = true; Validator validator = ((IValidatorDescriptor)attribute).CreateValidator(null, null, null, null); Assert.IsNotNull(validator); StringLengthValidator stringLengthValidator = validator as StringLengthValidator; Assert.IsNotNull(stringLengthValidator); Assert.AreEqual(10, stringLengthValidator.LowerBound); Assert.AreEqual(RangeBoundaryType.Inclusive, stringLengthValidator.LowerBoundType); Assert.AreEqual(20, stringLengthValidator.UpperBound); Assert.AreEqual(RangeBoundaryType.Inclusive, stringLengthValidator.UpperBoundType); Assert.AreEqual(Resources.StringLengthValidatorNegatedDefaultMessageTemplate, stringLengthValidator.MessageTemplate); Assert.AreEqual(true, stringLengthValidator.Negated); }
public void CreateColumn() { var finalMember = Member.FinalMemberInfo; Column = new Column() { Table = DataType.Table, Name = Member.Expression.Replace('.', '_'), DbType = Sql.DbTypeMapper.Parse(MemberExpression.GetReturnType(finalMember)), IsNullable = !RequiredValidator.IsRequired(finalMember), IsPrimaryKey = IsPrimaryKey(finalMember), }; Column.IsAutoNumber = Column.IsNumeric && Column.IsPrimaryKey && DataType.BaseDataType == null; if (Column.IsString) { Column.Length = StringLengthValidator.GetMaxLength(finalMember); } DataType.Table.Columns.Add(Column); }
public async Task InternValidators() { var em1 = await TestFns.NewEm(_serviceName); var vr2 = new RequiredValidator().Intern(); var vr3 = new RequiredValidator().Intern(); Assert.IsTrue(vr2 == vr3); Assert.IsTrue(vr2.Equals(vr3)); var mlVr2 = new MaxLengthValidator(17).Intern(); var mlVr3 = new MaxLengthValidator(17).Intern(); Assert.IsTrue(mlVr2 == mlVr3); Assert.IsTrue(mlVr2.Equals(mlVr3)); var slVr2 = new StringLengthValidator(3, 12).Intern(); var slVr3 = new StringLengthValidator(3, 12).Intern(); Assert.IsTrue(slVr2 == slVr3); Assert.IsTrue(slVr2.Equals(slVr3)); }
public void NegatedReturnsSuccessForValidationForNonStringTargetThroughNonGenericInterface() { Validator validator = new StringLengthValidator(5, RangeBoundaryType.Inclusive, 10, RangeBoundaryType.Inclusive, true); Assert.IsFalse(validator.Validate(3).IsValid); }
public void ConstructorWithBoundsAndBoundTypesAndNullMessageOverrideInitializesAndNegatedAppropriateInstanceWithDefaultMessage() { StringLengthValidator validator = new StringLengthValidator(5, RangeBoundaryType.Exclusive, 10, RangeBoundaryType.Exclusive, null, true); Assert.AreEqual(5, validator.LowerBound); Assert.AreEqual(RangeBoundaryType.Exclusive, validator.LowerBoundType); Assert.AreEqual(10, validator.UpperBound); Assert.AreEqual(RangeBoundaryType.Exclusive, validator.UpperBoundType); Assert.AreEqual(Resources.StringLengthValidatorNegatedDefaultMessageTemplate, validator.MessageTemplate); Assert.AreEqual(true, validator.Negated); }
/// <summary> /// Creates a field for a DataMember /// </summary> public FormField AddField(MemberInfo member) { //if there's no values defined, exit if (member == null) { throw new ArgumentNullException(nameof(member)); } //field FormField field; Type returnType = MemberExpression.GetReturnType(member); //String if (returnType.Equals(typeof(string))) { field = new StringField(); //set max lenght, if defined int maxLenght = (int)StringLengthValidator.GetMaxLength(member); if (maxLenght == 0) { field.TableWide = true; } else { ((StringField)field).MaxLenght = maxLenght; } //set regular expression validation, if defined var regex = member.CustomAttributes.Where(att => att.AttributeType.Equals(typeof(RegexValidator))).SingleOrDefault(); if (regex != null) { ((StringField)field).RegularExpression = (string)regex.ConstructorArguments[0].Value; } } //DataType else if (returnType.Equals(typeof(DataType))) { field = new DataTypeField(); } //otherwise delegate to the static method to create the field from the return type else { field = CreateField(returnType); } field.Name = member.Name; field.Container = this; field.Required = RequiredValidator.IsRequired(member); field.CaptionControl.Text = Translator.Translate(member); //if (member.Column.IsPrimaryKey) field.SortOrder = 0; //add to fields collection Fields.Add(field); return(field); }
public void NegatedReturnsFailureForStringShorterThanLowerBound() { Validator<string> validator = new StringLengthValidator(5, RangeBoundaryType.Inclusive, 10, RangeBoundaryType.Inclusive, true); ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 3).ToString()); Assert.IsTrue(validationResults.IsValid); }
public void CreateValidationMetadata(ValidationMetadataProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } if (context.Key.ContainerType != null && !context.Key.ContainerType.IsValueType) { var viewConfig = ServiceLocator.GetViewConfigure(context.Key.ContainerType); if (viewConfig != null && context.Key.Name.IsNotNullAndWhiteSpace()) { var descriptor = viewConfig.GetViewPortDescriptor(context.Key.Name); if (descriptor != null) { descriptor.Validator.Each(v => { if (v.DisplayName == null) { v.DisplayName = () => descriptor.DisplayName; } string encodeError = Convert.ToBase64String(JsonConvert.SerializeObject(new Mapping(v.Name, v.Property)).ToByte()); if (v is RangeValidator) { RangeValidator valid = (RangeValidator)v; RangeAttribute range = new RangeAttribute(valid.Min, valid.Max); range.ErrorMessage = encodeError; context.ValidationMetadata.ValidatorMetadata.Add(range); } else if (v is RegularValidator) { RegularValidator valid = (RegularValidator)v; RegularExpressionAttribute regular = new RegularExpressionAttribute(valid.Expression); regular.ErrorMessage = encodeError; context.ValidationMetadata.ValidatorMetadata.Add(regular); } else if (v is RemoteValidator) { RemoteValidator valid = (RemoteValidator)v; RemoteAttribute remote = new RemoteAttribute(valid.Action, valid.Controller, valid.Area); remote.ErrorMessage = encodeError; context.ValidationMetadata.ValidatorMetadata.Add(remote); } else if (v is RequiredValidator) { RequiredValidator valid = (RequiredValidator)v; RequiredAttribute required = new RequiredAttribute(); required.ErrorMessage = encodeError; context.ValidationMetadata.ValidatorMetadata.Add(required); } else if (v is StringLengthValidator) { StringLengthValidator valid = (StringLengthValidator)v; StringLengthAttribute stringLength = new StringLengthAttribute(valid.Max); stringLength.ErrorMessage = encodeError; context.ValidationMetadata.ValidatorMetadata.Add(stringLength); } }); } } } }
public void ReturnsSuccessForStringWithLengthOneShoterThanLowerBoundIfLUpperBoundIsInclusive() { Validator<string> validator = new StringLengthValidator(5, RangeBoundaryType.Inclusive, 10, RangeBoundaryType.Inclusive); ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 9).ToString()); Assert.IsTrue(validationResults.IsValid); }
public void ConstructorWithBoundsAndBoundTypesAndMessageOverrideAndNegatedInitializesAppropriateInstance() { StringLengthValidator validator = new StringLengthValidator(5, RangeBoundaryType.Exclusive, 10, RangeBoundaryType.Exclusive, "message template override", true); Assert.AreEqual(5, validator.LowerBound); Assert.AreEqual(RangeBoundaryType.Exclusive, validator.LowerBoundType); Assert.AreEqual(10, validator.UpperBound); Assert.AreEqual(RangeBoundaryType.Exclusive, validator.UpperBoundType); Assert.AreEqual("message template override", validator.MessageTemplate); Assert.AreEqual(true, validator.Negated); }
public void ConstructorWithBoundsAndBoundTypesInitializesAppropriateInstance() { StringLengthValidator validator = new StringLengthValidator(5, RangeBoundaryType.Exclusive, 10, RangeBoundaryType.Exclusive); Assert.AreEqual(5, validator.LowerBound); Assert.AreEqual(RangeBoundaryType.Exclusive, validator.LowerBoundType); Assert.AreEqual(10, validator.UpperBound); Assert.AreEqual(RangeBoundaryType.Exclusive, validator.UpperBoundType); Assert.AreEqual(false, validator.Negated); }
public StringLengthModelValidator(EasyModelMetaData metadata, ControllerContext context, StringLengthValidator stringlengthvalidator) : base(metadata, context) { minLength = stringlengthvalidator.Min; this.Attribute = new StringLengthAttribute(stringlengthvalidator.Max); //this.Attribute.ErrorMessageResourceType = Metadata.ContainerType; //this.Attribute.ErrorMessageResourceName = Metadata.PropertyName; this.Attribute.ErrorMessage = stringlengthvalidator.ErrorMessage; }
public void SuppliesAppropriateParametersToDefaultNegatedMessage() { StringLengthValidator validator = new StringLengthValidator(10, RangeBoundaryType.Exclusive, 20, RangeBoundaryType.Inclusive, true); validator.Tag = "tag"; object target = "not so short"; string key = "key"; ValidationResults validationResults = new ValidationResults(); validator.DoValidate(target, null, key, validationResults); Assert.IsFalse(validationResults.IsValid); ValidationResult validationResult = ValidationTestHelper.GetResultsList(validationResults)[0]; Match match = TemplateStringTester.Match(validator.MessageTemplate, validationResult.Message); Assert.IsTrue(match.Success); Assert.IsFalse(match.Groups["param0"].Success); Assert.IsFalse(match.Groups["param1"].Success); Assert.IsFalse(match.Groups["param2"].Success); Assert.IsTrue(match.Groups["param3"].Success); Assert.AreEqual("10", match.Groups["param3"].Value); Assert.IsTrue(match.Groups["param4"].Success); Assert.AreEqual("Exclusive", match.Groups["param4"].Value); Assert.IsTrue(match.Groups["param5"].Success); Assert.AreEqual("20", match.Groups["param5"].Value); Assert.IsTrue(match.Groups["param6"].Success); Assert.AreEqual("Inclusive", match.Groups["param6"].Value); }
public void NegatedReturnsFailureForStringAsLongAsMinLengthForMinAndMaxLengthValidator() { Validator<string> validator = new StringLengthValidator(5, 10, true); ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 5).ToString()); Assert.IsFalse(validationResults.IsValid); }
public void NegatedReturnsSuccessForValidationForNonStringTargetThroughNonGenericInterface() { Validator validator = new StringLengthValidator(5, RangeBoundaryType.Inclusive, 10, RangeBoundaryType.Inclusive, true); Assert.IsFalse(validator.Validate(3).IsValid); }
public void ReturnsFailureForStringWithLengthOneLongerThanUpperBoundIfUpperBoundIsExclusive() { Validator<string> validator = new StringLengthValidator(5, RangeBoundaryType.Inclusive, 10, RangeBoundaryType.Exclusive); ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 11).ToString()); Assert.IsFalse(validationResults.IsValid); }
/// <summary> /// Creates a list of new DataTypes, creating as well a list of new Tables with all members of type as columns /// </summary> public static IEnumerable <DataType> DefaultMap(IEnumerable <Type> types) { //we will store here all types that are actually persistent List <DataType> persistentTypes = new List <DataType>(); Random random = new Random(); //map primary keys first, so we allow to foreign keys and inheritance to be correctly mapped foreach (Type type in types) { //skip enums and interfaces if (type.GetTypeInfo().IsEnum || type.GetTypeInfo().IsInterface) { continue; } //ignore types with no primary key var pk = GetMappableMembers(type).Where(m => DataMember.IsPrimaryKey(m)); if (pk.Count() == 0) { continue; } DataType dtype = new DataType(type); AllDataTypes.Add(dtype); foreach (var memberInfo in pk) { //create datamember dtype.AddMember(memberInfo.Name); } persistentTypes.Add(dtype); } foreach (DataType dtype in persistentTypes) { //create inheritance foreign keys if (dtype.BaseDataType != null) { ForeignKey foreignKey = new ForeignKey(); foreignKey.Table = dtype.Table; foreignKey.RemoteTable = dtype.BaseDataType.Table; foreignKey.Name = "FK_" + dtype.Name + "_" + dtype.BaseDataType.Name + "_" + random.Next(); //we asume that primary keys on parent and child tables have the same number and order of related columns for (int i = 0; i < dtype.PrimaryKey.Count(); i++) { DataMember pk = dtype.PrimaryKey.ToArray()[i]; DataMember basePk = dtype.BaseDataType.PrimaryKey.ToArray()[i]; foreignKey.Columns.Add(new Tuple <Column, Column>(pk.Column, basePk.Column)); } dtype.Table.ForeignKeys.Add(foreignKey); } //map non primary key members now foreach (var memberInfo in GetMappableMembers(dtype.InnerType).Where(m => !DataMember.IsPrimaryKey(m))) { Type returnType = MemberExpression.GetReturnType(memberInfo); //is this a collection of a mapped type? if so, ignore since this must be a 1-1, 1-many or many-many relationship and must be mapped somewhere else if (DataType.IsCollection(returnType) && IsMapped(returnType.GetCollectionItemType())) { continue; } //its a persistent type, with it's own table, map as a foreign key with one or more columns for the primary key if (IsMapped(returnType)) { //we asume this datatype is already mapped along with it's primery key DataType returnDataType = returnType; ForeignKey foreignKey = new ForeignKey(); foreignKey.Table = dtype.Table; foreignKey.RemoteTable = returnDataType.Table; foreignKey.Name = "FK_" + dtype.Name + "_" + memberInfo.Name + "_" + random.Next(); foreach (DataMember pk in returnDataType.PrimaryKey.ToList()) { Column column = new Column(); column.Name = memberInfo.Name + "_" + pk.Member.Expression.Replace('.', '_'); column.Table = dtype.Table; column.IsPrimaryKey = false; column.IsNullable = !RequiredValidator.IsRequired(memberInfo); column.DbType = DbTypeMapper.Parse(pk.Member.ReturnType); if (column.IsString) { column.Length = StringLengthValidator.GetMaxLength(pk.Member.FinalMemberInfo); } dtype.Table.Columns.Add(column); foreignKey.Columns.Add(new Tuple <Column, Column>(column, pk.Column)); //create datamember dtype.AddMember(memberInfo.Name + "." + pk.Member, column); } dtype.Table.ForeignKeys.Add(foreignKey); } //just map as a atomic value else { Column column = new Column(); column.Name = memberInfo.Name; column.Table = dtype.Table; column.IsNullable = !RequiredValidator.IsRequired(memberInfo); column.IsPrimaryKey = false; //create datamember DataMember dmember = dtype.AddMember(memberInfo.Name, column); //is this a regular atomic value? if (DbTypeMapper.DbTypeMap.ContainsValue(returnType) && returnType != typeof(object)) { column.DbType = DbTypeMapper.Parse(returnType); } else if (returnType.GetTypeInfo().IsEnum) { column.DbType = DbType.Int32; } //this is an non-atomic object, but its not mapped as a DataType, so we serialize it as json else { column.DbType = DbType.String; dmember.Converter = new Conversions.Json <object>(); } if (column.IsString) { column.Length = Data.Validation.StringLengthValidator.GetMaxLength(memberInfo); } dtype.Table.Columns.Add(column); } } yield return(dtype); } }
static void Main(string[] args) { var lengthValidator = new StringLengthValidator(18); var regexValidator = new RegexStringValidator("^[A-Z ]+$"); var rangeRaceMarginValidator = new RangeDecimalValidator(110, 140); var numOfRunnersValidator = new RangeIntValidator(4, 16); int capacity; ValidateResult rangeResult; do { Console.WriteLine("How many runners do you want for the race [4-16]:"); var numOfRunners = Console.ReadLine(); int.TryParse(numOfRunners, out capacity); rangeResult = numOfRunnersValidator.Validate(capacity); if (!rangeResult.Succeeded) { Console.WriteLine(string.Concat(rangeResult.Errors.Select(e => e))); Console.WriteLine(); } } while (capacity == 0 || !rangeResult.Succeeded); var runners = new IRunner[capacity]; Console.WriteLine(); for (int i = 0; i < capacity; i++) { var currentRunnerId = i + 1; ValidateResult lengthResult; ValidateResult regexResult; var runnerName = string.Empty; do { Console.WriteLine($"Please give me the name of runner{currentRunnerId}:"); runnerName = Console.ReadLine(); lengthResult = lengthValidator.Validate(runnerName); regexResult = regexValidator.Validate(runnerName); if (!lengthResult.Succeeded) { Console.WriteLine(string.Concat(lengthResult.Errors.Select(e => e))); } if (!regexResult.Succeeded) { Console.WriteLine(string.Concat(regexResult.Errors.Select(e => e))); } Console.WriteLine(); } while (!lengthResult.Succeeded || !regexResult.Succeeded); var fractionIsValid = true; do { Console.WriteLine($"Please give me the fractional odd for runner{currentRunnerId}:"); var fractionalOdd = Console.ReadLine(); try { var fraction = new Fraction(fractionalOdd); var runner = new Runner(runnerName, fraction); runners[i] = runner; fractionIsValid = true; } catch (InvalidFractionException ex) { fractionIsValid = false; Console.WriteLine(ex.Message); Console.WriteLine(); } } while (fractionIsValid == false); Console.WriteLine(); } var calculator = new RaceMarginCalculator(); IRace race = new Race(runners, calculator); var raceMargin = race.CalculateRaceMargin(); Console.WriteLine(raceMargin); ValidateResult raceMarginResult = rangeRaceMarginValidator.Validate(raceMargin); if (!raceMarginResult.Succeeded) { Console.WriteLine(string.Concat(raceMarginResult.Errors.Select(e => e))); } Console.WriteLine(); race.CalculateRunnersWinningPercentage(); var appearances = new List <RunnerAppearance>(); foreach (var runner in runners) { appearances.Add(new RunnerAppearance(runner.Name, runner.WinningPercentage, 0)); } string menuOption; do { Console.WriteLine(); Console.WriteLine("============Menu=============="); Console.WriteLine(); Console.WriteLine("Choose P to pick a winner (P)"); Console.WriteLine("Choose A to display the number of appearances for each runner based on winning percentage (A)"); Console.WriteLine("Choose W to display the winning percentage for each runner (A)"); Console.WriteLine("Choose Q to exit (Q)"); Console.WriteLine(); Console.WriteLine("Select an option:"); menuOption = Console.ReadLine(); var rnd = new Random(); switch (menuOption) { case "P": Console.WriteLine(); Console.WriteLine("Please select how many iterations do you want ?"); Console.WriteLine(); Console.WriteLine("Select 1 for 1 iteration (1):"); Console.WriteLine("Select 10 for 10 iterations (10):"); Console.WriteLine("Select 100 for 100 iterations (100):"); Console.WriteLine("Select 1,000 for 1,000 iterations (1,000):"); Console.WriteLine("Select 10,000 for 10,000 iterations (10,000):"); Console.WriteLine("Select 100,000 for 100,000 iterations (100,000):"); Console.WriteLine("Select 1,000,000 for 1,000,000 iterations (1,000,000):"); menuOption = Console.ReadLine(); int.TryParse(menuOption, out int iterations); switch (menuOption) { case "1": case "10": case "100": case "1000": case "10000": case "100000": case "1000000": for (int i = 0; i < iterations; i++) { var randomNum = rnd.Next(1, 101); PickWinner(randomNum, race, appearances); } break; default: break; } break; case "A": DisplayRunnerAppearances(appearances); break; case "W": DisplayWinningPercentages(runners); break; case "Q": break; } } while (menuOption != null && !menuOption.Equals("Q")); Environment.Exit(0); Console.ReadKey(); }
public void NegatedReturnsFailureForStringWithLengthEqualToLowerBoundIfLowerBoundIsInclusive() { Validator<string> validator = new StringLengthValidator(5, RangeBoundaryType.Inclusive, 10, RangeBoundaryType.Inclusive, true); ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 5).ToString()); Assert.IsFalse(validationResults.IsValid); }
private string ToHtmlString(bool widthLabel) { if (string.IsNullOrEmpty(this.DisplayName)) { this.DisplayName = this.Name; } string val = this.Value == null ? "" : this.Value.ToString().HtmlEncode(); StringBuilder builder = new StringBuilder(); if (widthLabel && this.TagType != HTMLEnumerate.HTMLTagTypes.Hidden && !this.IsHidden && !this.IsIgnore) { builder.AppendFormat("<span class=\"input-group-addon {1}\">{0}</span>", this.DisplayName, this.IsRequired ? "required" : ""); } if (this.TagType == HTMLEnumerate.HTMLTagTypes.File) { builder.AppendFormat("<input type=\"hidden\" name=\"{0}{1}\" id=\"{0}{1}\" value=\"{2}\" />", this.NamePreFix, this.Name, val); } builder.Append(StartStr); switch (this.TagType) { case HTMLEnumerate.HTMLTagTypes.PassWord: case HTMLEnumerate.HTMLTagTypes.Input: case HTMLEnumerate.HTMLTagTypes.Hidden: builder.AppendFormat(" value=\"{0}\" ", val); break; case HTMLEnumerate.HTMLTagTypes.CheckBox: { bool check = false; if (val == "") { check = false; } else { check = Convert.ToBoolean(val); } builder.AppendFormat(" {0} ", check ? "checked=\"checked\"" : ""); builder.Append(" value=\"true\" "); break; } } builder.AppendFormat(" id=\"{1}{0}\" name=\"{1}{0}\"", this.Name, this.NamePreFix); if (Validator.Count > 0) { this.AddProperty("data-val", "true"); } foreach (ValidatorBase item in Validator) { item.DisplayName = this.DisplayName; if (item is RequiredValidator) { this.AddProperty("data-val-required", item.ErrorMessage); this.AddClass("required"); } else if (item is RegularValidator) { this.AddProperty("data-val-regex", item.ErrorMessage); this.AddProperty("data-val-regex-pattern", (item as RegularValidator).Expression); } else if (item is RemoteValidator) { RemoteValidator temp = item as RemoteValidator; this.AddProperty("data-val-remote", temp.ErrorMessage); this.AddProperty("data-val-remote-additionalfields", temp.AdditionalFields); this.AddProperty("data-val-remote-type", ""); this.AddProperty("data-val-remote-url", temp.Url); } else if (item is RangeValidator) { RangeValidator temp = item as RangeValidator; this.AddProperty("data-val-range", temp.ErrorMessage); this.AddProperty("data-val-range-max", temp.Max.ToString()); this.AddProperty("data-val-range-min", temp.Min.ToString()); } else if (item is StringLengthValidator) { StringLengthValidator temp = item as StringLengthValidator; this.AddProperty("data-val-length", temp.ErrorMessage); this.AddProperty("data-val-length-max", temp.Max.ToString()); } } foreach (var item in this.Properties) { builder.AppendFormat(" {0}=\"{1}\"", item.Key, item.Value); } if (Styles.Count > 0) { builder.Append(" style=\""); foreach (var item in Styles) { builder.AppendFormat("{0}:{1};", item.Key, item.Value); } builder.Append("\""); } if (Classes.Count > 0) { builder.Append(" class=\""); int i = 0; foreach (var item in Classes) { if (i == 0) { builder.AppendFormat("{0}", item); } else { builder.AppendFormat(" {0}", item); } i++; } builder.Append("\""); } builder.Append(EndStr); if (!this.IsHidden && this.TagType != HTMLEnumerate.HTMLTagTypes.Hidden) { builder.AppendFormat(errorMsgPlace, this.Name); } return(builder.ToString()); }
public void ConstructorWithUpperBoundOnlyInitializesAppropriateInstance() { StringLengthValidator validator = new StringLengthValidator(10); Assert.AreEqual(0, validator.LowerBound); Assert.AreEqual(RangeBoundaryType.Ignore, validator.LowerBoundType); Assert.AreEqual(10, validator.UpperBound); Assert.AreEqual(RangeBoundaryType.Inclusive, validator.UpperBoundType); Assert.AreEqual(false, validator.Negated); }
public void ReturnsFailureForStringLongerThanMaxLengthForMaxLengthOnlyValidator() { Validator<string> validator = new StringLengthValidator(10); ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 11).ToString()); Assert.IsFalse(validationResults.IsValid); IList<ValidationResult> resultsList = ValidationTestHelper.GetResultsList(validationResults); Assert.AreEqual(1, resultsList.Count); Assert.IsTrue(TemplateStringTester.IsMatch(Resources.StringLengthValidatorNonNegatedDefaultMessageTemplate, resultsList[0].Message)); }
public void ConstructorWithLowerAndUpperBoundAndNegatedInitializesAppropriateInstance() { StringLengthValidator validator = new StringLengthValidator(5, 10, true); Assert.AreEqual(5, validator.LowerBound); Assert.AreEqual(RangeBoundaryType.Inclusive, validator.LowerBoundType); Assert.AreEqual(10, validator.UpperBound); Assert.AreEqual(RangeBoundaryType.Inclusive, validator.UpperBoundType); Assert.AreEqual(true, validator.Negated); }
public async Task InternValidators() { var em1 = await TestFns.NewEm(_serviceName); var vr2 = new RequiredValidator().Intern(); var vr3 = new RequiredValidator().Intern(); Assert.IsTrue(vr2 == vr3); Assert.IsTrue(vr2.Equals(vr3)); var mlVr2 = new MaxLengthValidator(17).Intern(); var mlVr3 = new MaxLengthValidator(17).Intern(); Assert.IsTrue(mlVr2 == mlVr3); Assert.IsTrue(mlVr2.Equals(mlVr3)); var slVr2 = new StringLengthValidator(3, 12).Intern(); var slVr3 = new StringLengthValidator(3, 12).Intern(); Assert.IsTrue(slVr2 == slVr3); Assert.IsTrue(slVr2.Equals(slVr3)); }
public void ReturnsSuccessForStringLongerThanUpperBoundIfUpperBoundIsIgnored() { Validator<string> validator = new StringLengthValidator(5, RangeBoundaryType.Inclusive, 10, RangeBoundaryType.Ignore); ValidationResults validationResults = validator.Validate(new StringBuilder().Append('a', 12).ToString()); Assert.IsTrue(validationResults.IsValid); }