Ejemplo n.º 1
0
        public void SuppliesAppropriateParametersToMessageTemplate()
        {
            EnumConversionValidator validator = new EnumConversionValidator(typeof(MockEnumValidator));

            validator.MessageTemplate = "{0}|{1}|{2}|{3}";
            validator.Tag             = "tag";
            object target = "blah";
            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.IsTrue(match.Groups["param0"].Success);
            Assert.AreEqual(target, match.Groups["param0"].Value);
            Assert.IsTrue(match.Groups["param1"].Success);
            Assert.AreEqual(key, match.Groups["param1"].Value);
            Assert.IsTrue(match.Groups["param2"].Success);
            Assert.AreEqual(validator.Tag, match.Groups["param2"].Value);
            Assert.IsTrue(match.Groups["param3"].Success);
            Assert.AreEqual(typeof(MockEnumValidator).Name, match.Groups["param3"].Value);
        }
Ejemplo n.º 2
0
        public void ConstructorWithEnumTypeAndNegatedCreatesCorrectInstance()
        {
            EnumConversionValidator validator = new EnumConversionValidator(typeof(MockEnumValidator), true);

            Assert.AreEqual(typeof(MockEnumValidator), validator.EnumType);
            Assert.AreEqual(true, validator.Negated);
        }
        public void ConstructorWithEnumTypeAndNegatedCreatesCorrectInstance()
        {
            EnumConversionValidator validator = new EnumConversionValidator(typeof(MockEnumValidator), true);

            Assert.AreEqual(typeof(MockEnumValidator), validator.EnumType);
            Assert.AreEqual(true, validator.Negated);
        }
Ejemplo n.º 4
0
        public void CreatingInstanceWithNonNegated()
        {
            EnumConversionValidator validator = new EnumConversionValidator(typeof(MockEnumValidator), false);

            Assert.AreEqual(Resources.EnumConversionNonNegatedDefaultMessageTemplate, validator.MessageTemplate);
            Assert.AreEqual(false, validator.Negated);
            Assert.AreEqual(typeof(MockEnumValidator), validator.EnumType);
        }
Ejemplo n.º 5
0
        public void CreatingInstanceWithMessageTemplate()
        {
            EnumConversionValidator validator = new EnumConversionValidator(typeof(MockEnumValidator), "my message template");

            Assert.AreEqual("my message template", validator.MessageTemplate);
            Assert.AreEqual(false, validator.Negated);
            Assert.AreEqual(typeof(MockEnumValidator), validator.EnumType);
        }
Ejemplo n.º 6
0
        public void NonNegatedRejectsStringWithoutEnumValue()
        {
            EnumConversionValidator validator = new EnumConversionValidator(typeof(MockEnumValidator), false);

            ValidationResults results = validator.Validate("xyz");

            Assert.IsFalse(results.IsValid);
        }
        public void CreatingInstanceWithNonNegated()
        {
            EnumConversionValidator validator = new EnumConversionValidator(typeof(MockEnumValidator), false);

            Assert.AreEqual(Resources.EnumConversionNonNegatedDefaultMessageTemplate, validator.MessageTemplate);
            Assert.AreEqual(false, validator.Negated);
            Assert.AreEqual(typeof(MockEnumValidator), validator.EnumType);
        }
        public void CreatingInstanceWithMessageTemplate()
        {
            EnumConversionValidator validator = new EnumConversionValidator(typeof(MockEnumValidator), "my message template");

            Assert.AreEqual("my message template", validator.MessageTemplate);
            Assert.AreEqual(false, validator.Negated);
            Assert.AreEqual(typeof(MockEnumValidator), validator.EnumType);
        }
Ejemplo n.º 9
0
        public void NonNegatedRejectsNull()
        {
            EnumConversionValidator validator = new EnumConversionValidator(typeof(MockEnumValidator), false);

            ValidationResults results = validator.Validate(null);

            Assert.IsFalse(results.IsValid);
        }
Ejemplo n.º 10
0
        public void NonNegatedAcceptsStringWithEnumValue()
        {
            EnumConversionValidator validator = new EnumConversionValidator(typeof(MockEnumValidator), false);

            ValidationResults results = validator.Validate("MyEnumValue");

            Assert.IsTrue(results.IsValid);
        }
Ejemplo n.º 11
0
        public void AttributeWithEnumTypeCreatesValidator()
        {
            ValidatorAttribute attribute = new EnumConversionValidatorAttribute(typeof(MockEnumValidator));

            Validator validator = ((IValidatorDescriptor)attribute).CreateValidator(null, null, null, null);

            Assert.IsNotNull(validator);

            EnumConversionValidator typedValidator = validator as EnumConversionValidator;

            Assert.IsNotNull(typedValidator);

            Assert.AreEqual(Resources.EnumConversionNonNegatedDefaultMessageTemplate, validator.MessageTemplate);
            Assert.AreEqual(typeof(MockEnumValidator), typedValidator.EnumType);
            Assert.AreEqual(false, typedValidator.Negated);
        }
Ejemplo n.º 12
0
        public void AttributeWithEnumTypeAndMessageTemplateCreatesValidator()
        {
            ValidatorAttribute attribute = new EnumConversionValidatorAttribute(typeof(MockEnumValidator));

            attribute.MessageTemplate = "my message template";

            Validator validator = ((IValidatorDescriptor)attribute).CreateValidator(null, null, null, null);

            Assert.IsNotNull(validator);

            EnumConversionValidator typedValidator = validator as EnumConversionValidator;

            Assert.IsNotNull(typedValidator);

            Assert.AreEqual("my message template", validator.MessageTemplate);
            Assert.AreEqual(typeof(MockEnumValidator), typedValidator.EnumType);
            Assert.AreEqual(false, typedValidator.Negated);
        }
Ejemplo n.º 13
0
        public void Validate(ValidationResults results)
        {
            string msg = string.Empty;

            // Rules that cannot be validated using Data Annotations.

            var enumConverterValidator = new EnumConversionValidator(typeof(ProductType), "Product type must be a value from the '{3}' enumeration.");

            enumConverterValidator.DoValidate(ProductType, this, "ProductType", results);


            if (DateDue.HasValue)
            {
                if (DateDue.Value < DateTime.Today ||
                    DateDue.Value > DateTime.Today.AddMonths(6))
                {
                    msg = "Date due must be between today and six months time.";
                    results.AddResult(new ValidationResult(msg, this, "DateDue", "", null));
                }
            }

            if (!DateDue.HasValue)
            {
                if (OnOrder > 0)
                {
                    msg = "Must provide a delivery due date for stock on back order.";
                    results.AddResult(new ValidationResult(msg, this, "ProductSelfValidation", "", null));
                }
            }
            else
            {
                if (OnOrder == 0)
                {
                    msg = "Can specify delivery due date only when stock is on back order.";
                    results.AddResult(new ValidationResult(msg, this, "ProductSelfValidation", "", null));
                }
            }

            if (InStock + OnOrder > 100)
            {
                msg = "Total inventory (in stock and on order) cannot exceed 100 items.";
                results.AddResult(new ValidationResult(msg, this, "ProductSelfValidation", "", null));
            }
        }
Ejemplo n.º 14
0
        public void Validate(ValidationResults results)
        {
            string msg = string.Empty;

            // Rules that cannot be validated using Data Annotations.

						var enumConverterValidator = new EnumConversionValidator(typeof(ProductType), "Product type must be a value from the '{3}' enumeration.");
            enumConverterValidator.DoValidate(ProductType, this, "ProductType", results);


						if (DateDue.HasValue)
            {
                if (DateDue.Value < DateTime.Today ||
                    DateDue.Value > DateTime.Today.AddMonths(6))
                {
                    msg = "Date due must be between today and six months time.";
                    results.AddResult(new ValidationResult(msg, this, "DateDue", "", null));
                }
            }

            if (!DateDue.HasValue)
            {
                if (OnOrder > 0)
                {
                    msg = "Must provide a delivery due date for stock on back order.";
                    results.AddResult(new ValidationResult(msg, this, "ProductSelfValidation", "", null));
                }
            }
            else
            {
                if (OnOrder == 0)
                {
                    msg = "Can specify delivery due date only when stock is on back order.";
                    results.AddResult(new ValidationResult(msg, this, "ProductSelfValidation", "", null));
                }
            }

            if (InStock + OnOrder > 100)
            {
                msg = "Total inventory (in stock and on order) cannot exceed 100 items.";
                results.AddResult(new ValidationResult(msg, this, "ProductSelfValidation", "", null));
            }
        }
Ejemplo n.º 15
0
        public void SuppliesAppropriateParametersToDefaultNegatedMessage()
        {
            EnumConversionValidator validator = new EnumConversionValidator(typeof(MockEnumValidator), true);

            validator.Tag = "tag";
            object target = MockEnumValidator.MyEnumValue.ToString();
            string key    = "key";

            ValidationResults validationResults = new ValidationResults();

            validator.DoValidate(target, null, key, validationResults);

            Assert.IsFalse(validationResults.IsValid);
            ValidationResult validationResult = ValidationTestHelper.GetResultsList(validationResults)[0];

            System.Text.RegularExpressions.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(typeof(MockEnumValidator).Name, match.Groups["param3"].Value);
        }
        public void NonNegatedRejectsNull()
        {
            EnumConversionValidator validator = new EnumConversionValidator(typeof(MockEnumValidator), false);

            ValidationResults results = validator.Validate(null);

            Assert.IsFalse(results.IsValid);
        }
        public void NegatedAcceptsStringWithoutEnumValue()
        {
            EnumConversionValidator validator = new EnumConversionValidator(typeof(MockEnumValidator), true);

            ValidationResults results = validator.Validate("xyz");

            Assert.IsTrue(results.IsValid);
        }
        public void NonNegatedRejectsStringWithoutEnumValue()
        {
            EnumConversionValidator validator = new EnumConversionValidator(typeof(MockEnumValidator), false);

            ValidationResults results = validator.Validate("xyz");

            Assert.IsFalse(results.IsValid);
        }
        public void SuppliesAppropriateParametersToDefaultNegatedMessage()
        {
            EnumConversionValidator validator = new EnumConversionValidator(typeof(MockEnumValidator), true);
            validator.Tag = "tag";
            object target = MockEnumValidator.MyEnumValue.ToString();
            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(typeof(MockEnumValidator).Name, match.Groups["param3"].Value);
        }