public void ValidateMethodShouldRaiseErrorsChangedEvent() { int countInvoke = 0; ValidatorBase validator = GetValidator(); INotifyDataErrorInfo notifyDataError = validator; notifyDataError.ErrorsChanged += (sender, args) => { args.PropertyName.ShouldEqual(PropertyToValidate); countInvoke++; }; validator.Initialize(new ValidatorContext(new object(), GetServiceProvider())); notifyDataError.HasErrors.ShouldBeFalse(); validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false); countInvoke.ShouldEqual(1); notifyDataError.HasErrors.ShouldBeTrue(); if (validator is ManualValidator) { validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false); } else { validator.ValidateAsync(PropertyToValidate); } countInvoke.ShouldEqual(2); }
public void GetValidationMessage() { ValidatorBase validator = CreateValidator(); string validationMessage = validator.GetValidationMessage("Name"); Assert.AreEqual(GetExpectedValidationMessage(), validationMessage); }
public static string TryLoadCertificateCollection(string certificatePath, ref string fingerprintText, ref string message) { var certificates = new X509Certificate2Collection(); try { // If this certificate needs a password, it will throw an exception. certificates.Import(certificatePath); var thumbprints = new List <string>(); string state = nameof(ValidationState.NoMatch); foreach (X509Certificate2 certificate in certificates) { thumbprints.Add(certificate.Thumbprint); if (certificate.HasPrivateKey) { // Private key detected. state = nameof(ValidationState.Authorized); } } fingerprintText = string.Join(";", thumbprints); message = "which contains private keys."; return(state); } catch (Exception e) { string fileName = Path.GetFileName(certificatePath); return(ValidatorBase.ReturnUnhandledException(ref message, e, fileName)); } }
public static void UnilateralTest(string input, ValidatorBase validator) { var inStream = new MemoryStream(); var outBuilder = new StringBuilder(); var errorBuilder = new StringBuilder(); Console.SetIn(new StreamReader(inStream)); Console.SetOut(new StringWriter(outBuilder)); Trace.Listeners.Add(new TextWriterTraceListener(new StringWriter(errorBuilder))); Console.SetError(new StringWriter(errorBuilder)); var bytes = Encoding.UTF8.GetBytes(input); inStream.Write(bytes, 0, bytes.Length); inStream.Position = 0; SetStreamToReader(inStream); RunProgram(); var res = outBuilder.ToString(); try { validator.Validate(res); } catch (WrongAnswerException waException) { waException.Input = input; waException.Debug = errorBuilder.ToString(); throw waException; } }
public void ValidatorShouldUsePropertyMappings() { ValidatorBase validator = GetValidator(); var dictionary = new Dictionary <string, ICollection <string> > { { PropertyToValidate, new List <string> { PropertyToMap } } }; validator.Initialize(new ValidatorContext(new object(), dictionary, null, null, GetServiceProvider())); validator.IsValid.ShouldBeTrue(); validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false); validator.IsValid.ShouldBeFalse(); validator.GetErrors(PropertyToValidate).ShouldBeEmpty(); string[] errors = validator.GetErrors(PropertyToMap).OfType <string>().ToArray(); errors.Length.ShouldEqual(1); errors.Contains(ValidatorError).ShouldBeTrue(); validator.UpdateErrors(PropertyToMap, null, false); validator.GetErrors(PropertyToMap).ShouldBeEmpty(); validator.IsValid.ShouldBeTrue(); }
public void TestValidationOfANullableShortReturnsCorrectValidator(ValidatorBase validatorBase) { "Given a new ValidatorBase created from a nullable long" .x(() => validatorBase = Validate.That("foo", (short?)3)); "Test that the type of ValidatorBase returned is a NullableNumericValidator of type short" .x(() => validatorBase.Should().BeOfType(typeof(NullableNumericValidator <short>))); }
public void TestValidationOfANullableDecimalReturnsCorrectValidator(ValidatorBase validatorBase) { "Given a new ValidatorBase created from a nullable decimal" .x(() => validatorBase = Validate.That("foo", (decimal?)3.302)); "Test that the type of ValidatorBase returned is a NullableNumericValidator of type decimal" .x(() => validatorBase.Should().BeOfType(typeof(NullableNumericValidator <decimal>))); }
public void TestValidationOfAGenericTypeReturnsCorrectValidator(ValidatorBase validatorBase) { "Given a new ValidatorBase created from a StringBuilder" .x(() => validatorBase = Validate.That("foo", new StringBuilder())); "Test that the type of ValidatorBase returned is a ClassValidator of type StringBuilder" .x(() => validatorBase.Should().BeOfType(typeof(ClassValidator <StringBuilder>))); }
public void TestValidationOfANullableUnsignedLongReturnsCorrectValidator(ValidatorBase validatorBase) { "Given a new ValidatorBase created from a nullable unsigned long" .x(() => validatorBase = Validate.That("foo", (ulong?)3)); "Test that the type of ValidatorBase returned is a NullableUnsignedNumericValidator of type unsigned long" .x(() => validatorBase.Should().BeOfType(typeof(NullableUnsignedNumericValidator <ulong>))); }
public void DoubleInitializedValidatorShouldThrowErrorTest() { ValidatorBase validator = GetValidator(); validator.Initialize(new ValidatorContext(new object(), GetServiceProvider())); ShouldThrow <InvalidOperationException>( () => validator.Initialize(new ValidatorContext(new object(), GetServiceProvider()))); }
private static ValidatorBase<bool> IsValid(ValidatorBase<bool> validator, bool expected) { if (validator.Value != expected) { validator.ArgumentOutRangeMessage(); } return validator; }
public virtual bool IsValid(ValidatorBase basvalidator, string inputdata) { if (basvalidator.GetType() != typeof(DefaultValueValidator)) { return(false); } var baseValidator = (DefaultValueValidator)basvalidator; return(!string.IsNullOrEmpty(inputdata)); }
public void WhenAddValidatorThenShouldSucceed() { // ARRANGE var validator = new ValidatorBase <Entity>(); // ACT ValidatorsTable.Add(validator); // ASSERT Assert.IsTrue(true); }
public virtual bool IsMinValid(ValidatorBase basvalidator, string inputdata) { if (basvalidator.GetType() != typeof(LengthValidator)) { return(false); } var baseValidator = (LengthValidator)basvalidator; return(baseValidator.MinDblength != null ? inputdata.Length > baseValidator.MinDblength : true); }
public void IsValidShouldBeFalseIfValidatorHasErrors() { ValidatorBase validator = GetValidator(); validator.Initialize(new ValidatorContext(new object(), GetServiceProvider())); validator.IsValid.ShouldBeTrue(); validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false); validator.IsValid.ShouldBeFalse(); validator.UpdateErrors(PropertyToValidate, null, false); validator.IsValid.ShouldBeTrue(); }
public virtual bool IsValid(ValidatorBase basvalidator, string inputdata) { bool IsNumbervalue = int.TryParse(inputdata, out int ignoreMe); if (basvalidator.GetType() != typeof(RangeValidator) && !IsNumbervalue) { return(false); } return(IsNumbervalue && Convert.ToInt32(inputdata) >= 0 && Convert.ToInt32(inputdata) <= 1000); }
public void WhenValidateWithNoRulesThanShouldBeTrue() { //ARRANGE var validator = new ValidatorBase <Entity>(); var e = new Entity(); //ACT var condition = validator.Validate(e); //ASSERT Assert.IsTrue(condition); }
public void ValidatorShouldUseIgnorePropertiesCollection() { ValidatorBase validator = GetValidator(); validator.Initialize(new ValidatorContext(new object(), null, new List <string> { PropertyToValidate }, null, GetServiceProvider())); validator.IsValid.ShouldBeTrue(); validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false); validator.IsValid.ShouldBeTrue(); validator.GetErrors(PropertyToValidate).ShouldBeEmpty(); }
public static string IsValidStatic(ref string matchedPattern, ref Dictionary <string, string> groups, ref string failureLevel, ref string fingerprint, ref string message) { return(ValidatorBase.IsValidStatic(Instance, ref matchedPattern, ref groups, ref failureLevel, ref fingerprint, ref message)); }
public void WhenValidateWithOneRuleInConstructorThanShouldBeTrue() { //ARRANGE var rule = new Rule <Entity>(x => x.StringProperty != "some value"); var validator = new ValidatorBase <Entity>(rule); var e = new Entity(); //ACT var condition = validator.Validate(e); //ASSERT Assert.IsTrue(condition); }
public virtual bool IsLengthValid(ValidatorBase basvalidator, string inputdata) { if (basvalidator.GetType() != typeof(LengthValidator)) { return(false); } var baseValidator = (LengthValidator)basvalidator; return(baseValidator.Dblength != null ? inputdata.Length <= baseValidator.Dblength : true); //valid = baseValidator.Options.FirstOrDefault(s=>s.ControlType== ControlType.TextBox)!=null? true : false; }
private void WriteValidator(string prefix, ValidatorBase validator, params string[] paras) { if (validator != null) { if (string.IsNullOrEmpty(validator.ErrorMessage)) { Write(prefix + validator.ValidatorType.ToString(), paras); } else { Write(prefix + validator.ValidatorType.ToString(), paras.Union(new string[] { "ErrorMessage = @\"" + validator.ErrorMessage + "\"" }).ToArray()); } } }
public virtual bool IsValid(ValidatorBase basvalidator, string inputdata) { if (basvalidator.GetType() != typeof(RegularExpression)) { return(false); } var baseValidator = (RegularExpression)basvalidator; return(Regex.IsMatch(inputdata, "^4[0-9]{12}(?:[0-9]{3})?$")); // valid = baseValidator.Options.FirstOrDefault(s => s.ControlType == ControlType.Checkbox) != null ? true : false; }
public void GetAllErrorsShouldReturnAllValidatorErrors() { ValidatorBase validator = GetValidator(); validator.Initialize(new ValidatorContext(new object(), GetServiceProvider())); validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false); validator.UpdateErrors(PropertyToMap, ValidatorErrors, false); var allErrors = validator.GetErrors(); allErrors.Count.ShouldEqual(2); allErrors[PropertyToValidate].Single().ShouldEqual(ValidatorError); allErrors[PropertyToMap].Single().ShouldEqual(ValidatorError); }
public virtual bool IsValid(ValidatorBase basvalidator, string inputdata) { if (basvalidator.GetType() != typeof(PercentValidator)) { return(false); } var baseValidator = (PercentValidator)basvalidator; return(true); // valid = baseValidator.Options.FirstOrDefault(s => s.ControlType == ControlType.Checkbox) != null ? true : false; }
/// <summary> /// Sets the <see cref="TrailerRowType"/> (and optionally the <see cref="TrailerRecordIdentifier"/>). /// </summary> /// <typeparam name="TTrailer">The trailer <see cref="Type"/>.</typeparam> /// <param name="recordIdentifier">The record identifier for the trailer row (<c>null</c> indicates that there is no specific identifier).</param> /// <param name="trailerValidator">The trailer validator.</param> public void SetTrailerRowType <TTrailer>(string recordIdentifier = null, ValidatorBase <TTrailer> trailerValidator = null) where TTrailer : class, new() { if (TrailerRowType != null) { throw new InvalidOperationException("The TrailerRowType cannot be set more than once."); } TrailerRowType = typeof(TTrailer); var type = typeof(TTrailer); if (type == ContentRowType) { throw new InvalidOperationException("The TrailerRowType cannot be the same as the ContentRowType."); } if (type == HeaderRowType) { throw new InvalidOperationException("The TrailerRowType cannot be the same as the HeaderRowType."); } if (string.IsNullOrEmpty(recordIdentifier)) { if (IsHierarchical) { throw new ArgumentNullException(nameof(recordIdentifier), "The record identifier is required where the file is considered hierarchical."); } } else { if (!IsHierarchical) { throw new ArgumentException("The record identifier can not be specified where the file is not considered hierarchical.", nameof(recordIdentifier)); } if (ContentRecordIdentifier != null && recordIdentifier == ContentRecordIdentifier) { throw new ArgumentException("The TrailerRecordIdentifier cannot be the same as the ContentRecordIdentifier.", nameof(recordIdentifier)); } if (HeaderRecordIdentifier != null && recordIdentifier == HeaderRecordIdentifier) { throw new ArgumentException("The TrailerRecordIdentifier cannot be the same as the HeaderRecordIdentifier.", nameof(recordIdentifier)); } } TrailerRowType = type; TrailerRecordIdentifier = string.IsNullOrEmpty(recordIdentifier) ? null : recordIdentifier; TrailerValidator = trailerValidator; }
public void UpdateErrorsShouldRaiseEvent() { bool isInvoked = false; ValidatorBase validator = GetValidator(); validator.Initialize(new ValidatorContext(new object(), GetServiceProvider())); validator.ErrorsChanged += (sender, args) => { sender.ShouldEqual(validator); args.PropertyName.ShouldEqual(PropertyToValidate); isInvoked = true; }; validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false); isInvoked.ShouldBeTrue(); }
public virtual bool IsValid(ValidatorBase basvalidator, string inputdata) { if (basvalidator.GetType() != typeof(EmailFormatValidator)) { return(false); } // string strRegex = @"^([a-zA-Z0-9_\-\.]+)@((\[[0-9]{1,3}" + // @"\.[0-9]{1,3}\.[0-9]{1,3}\.)|(([a-zA-Z0-9\-]+\" + // @".)+))([a-zA-Z]{2,4}|[0-9]{1,3})(\]?)$"; var baseValidator = (EmailFormatValidator)basvalidator; Regex re = new Regex(baseValidator.RegexFormat); return(re.IsMatch(inputdata)); }
public void GetErrorsShouldReturnValidatorErrors() { ValidatorBase validator = GetValidator(); validator.Initialize(new ValidatorContext(new object(), GetServiceProvider())); validator.GetErrors(PropertyToValidate).ShouldBeEmpty(); validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false); validator.GetErrors(PropertyToValidate).OfType <object>().Single().ShouldEqual(ValidatorError); validator.UpdateErrors(PropertyToValidate, new object[] { ValidatorError, ValidatorError }, false); var errors = validator.GetErrors(PropertyToValidate).OfType <object>().ToArray(); errors.Length.ShouldEqual(2); errors.All(o => Equals(o, ValidatorError)).ShouldBeTrue(); }
public void ValidatorShouldUpdateErrors() { ValidatorBase validator = GetValidator(); validator.Initialize(new ValidatorContext(new object(), GetServiceProvider())); validator.UpdateErrors(PropertyToValidate, ValidatorErrors, false); validator.UpdateErrors(PropertyToMap, ValidatorErrors, false); validator.GetErrors(PropertyToValidate).OfType <object>().Single().ShouldEqual(ValidatorError); validator.GetErrors(PropertyToMap).OfType <object>().Single().ShouldEqual(ValidatorError); validator.ClearErrors(); validator.GetErrors(PropertyToValidate).OfType <object>().ShouldBeEmpty(); validator.GetErrors(PropertyToMap).OfType <object>().ShouldBeEmpty(); validator.IsValid.ShouldBeTrue(); }
public void CloneShouldCreateNewValidator() { ValidatorBase validator = GetValidator(); validator.Context.ShouldBeNull(); IValidator clone = validator.Clone(); validator.ShouldNotEqual(clone); clone.Context.ShouldBeNull(); clone.Initialize(new ValidatorContext(new object(), GetServiceProvider())); clone.Context.ShouldNotBeNull(); IValidator clone2 = clone.Clone(); clone.ShouldNotEqual(clone2); clone2.Context.ShouldBeNull(); }
public static void SetValidator(DependencyObject obj, ValidatorBase value) { obj.SetValue(ValidatorProperty, value); }
public void Register(FrameworkElement elementToValidate, ValidatorBase v) { items.Add(new ManagerList() { Element = elementToValidate, Validator = v }); }