public void SetUp() { theStep = new ValidationStep(typeof(string), typeof(ConfiguredValidationSource), new IValidationRule[] { new Rule1(), new Rule2() }); theDescription = Description.For(theStep); theRuleList = theDescription.BulletLists.Single(); }
public void ExecutionExtension_ValidationSummary() { string msg1 = "message1", msg2 = "message2", msg3 = "message3"; var er = new ExecutionResult("ss", null); er.Add(new[] { ValidationStep.BuildValidationResponseStep(true, msg1), ValidationStep.BuildValidationResponseStep(false, msg2), ValidationStep.BuildValidationResponseStep(false, msg3) }); var vs1 = er.ValidationSummary(); vs1.Count().ShouldBe(3); vs1.Contains(msg1).ShouldBeTrue(); vs1.Contains(msg2).ShouldBeTrue(); vs1.Contains(msg3).ShouldBeTrue(); var vs2 = er.ValidationSummary(true); vs2.Count().ShouldBe(1); vs2.Contains(msg1).ShouldBeTrue(); var vs3 = er.ValidationSummary(false); vs3.Count().ShouldBe(2); vs3.Contains(msg2).ShouldBeTrue(); vs3.Contains(msg3).ShouldBeTrue(); }
public void ExecutionExtension_AddValidationStep() { var er1 = new ExecutionResult("ss", null); er1.Add(ValidationStep.BuildValidationResponseStep(false, "message")); er1.ValidationSteps.Any().ShouldBeTrue(); }
// Token: 0x06001C34 RID: 7220 RVA: 0x00084970 File Offset: 0x00082B70 internal override bool Validate(object value, ValidationStep validationStep) { if (value == Binding.DoNothing) { return(true); } if (value == DependencyProperty.UnsetValue) { base.SetStatus(BindingStatusInternal.UpdateSourceError); return(false); } bool result = base.Validate(value, validationStep); if (validationStep != ValidationStep.RawProposedValue) { object[] array = value as object[]; int num = this.MutableBindingExpressions.Count; if (array.Length < num) { num = array.Length; } for (int i = 0; i < num; i++) { value = array[i]; if (value != DependencyProperty.UnsetValue && value != Binding.DoNothing && !this.MutableBindingExpressions[i].Validate(value, validationStep)) { array[i] = DependencyProperty.UnsetValue; } } } return(result); }
public ValidationRequest( ValidationStep step, IViewModel vm ) : this(step, Path.Empty.Prepend(vm)) { Check.NotNull(vm, nameof(vm)); }
protected ValidationArgs(ValidationStep step, IValidator validator) { Check.NotNull(validator, nameof(validator)); Step = step; Validator = validator; Result = ValidationResult.Valid; }
public ValidationRequest( ValidationStep step, Path targetPath ) { Check.NotNull(targetPath, nameof(targetPath)); Step = step; TargetPath = targetPath; }
public CommitStage() { Name = "1-Integration-Build-hosted"; Artifacts = new[] { new SourceRepository() }; Validations = new ValidationStep[] { new PrivateBuild(), new ContinuousIntegrationBuild() }; }
public StagingStage() { Name = "3-Promote to Staging"; Artifacts = new[] { new ReleasePackages() }; Validations = new ValidationStep[] { new InPlaceUpgrade(), new SmokeTestSuite() }; }
/// <summary> /// Run validation rules for the given step /// <summary> internal override bool Validate(object value, ValidationStep validationStep) { BindingExpressionBase bindExpr = ActiveBindingExpression; if (bindExpr != null) { return(bindExpr.Validate(value, validationStep)); } return(true); }
public ValidationRequest( ValidationStep step, IViewModel vm, IVMPropertyDescriptor property ) : this(step, Path.Empty.Prepend(property).Prepend(vm)) { Check.NotNull(vm, nameof(vm)); Check.NotNull(property, nameof(property)); }
/// <summary> /// Run validation rules for the given step, and inform the binding group /// <summary> internal override bool CheckValidationRules(BindingGroup bindingGroup, ValidationStep validationStep) { BindingExpressionBase bindExpr = ActiveBindingExpression; if (bindExpr != null) { return(bindExpr.CheckValidationRules(bindingGroup, validationStep)); } return(true); }
/// <summary>Performs validation checks on a value.</summary> /// <param name="value">The value from the binding target to check.</param> /// <param name="cultureInfo">The culture to use in this rule.</param> /// <param name="owner">The binding expression that uses the validation rule.</param> /// <returns>A <see cref="T:System.Windows.Controls.ValidationResult" /> object.</returns> // Token: 0x0600599F RID: 22943 RVA: 0x0018B870 File Offset: 0x00189A70 public virtual ValidationResult Validate(object value, CultureInfo cultureInfo, BindingExpressionBase owner) { ValidationStep validationStep = this._validationStep; if (validationStep - ValidationStep.UpdatedValue <= 1) { value = owner; } return(this.Validate(value, cultureInfo)); }
public void finds_the_rules() { var r1 = new StubRule(); var r2 = new StubRule(); var r3 = new ClassFieldValidationRules(); var src = new ConfiguredValidationSource(new IValidationRule[] { r1, r2, r3 }); var step = ValidationStep.FromSource(typeof(object), src); step.FindRules <StubRule>().ShouldHaveTheSameElementsAs(r1, r2); }
public ProductionStage() { Name = "3-Promote to Production"; Artifacts = new[] { new ReleasePackages() }; Validations = new ValidationStep[] { new SuccessfulBackup(), new InPlaceUpgrade(), new SmokeTestSuite() }; }
public AcceptanceStage() { Name = "2-Deploy to Test"; Artifacts = new[] { new ReleasePackages() }; Validations = new ValidationStep[] { new SmokeTestSuite(), new AcceptanceTestSuite(), new SystemIntegrationTestSuite(), new CapacityTestSuite() }; }
public void ExecutionExtension_AddValidationStepCollection() { var er1 = new ExecutionResult("ss", null); er1.Add(new[] { ValidationStep.BuildValidationResponseStep(false, "message"), ValidationStep.BuildValidationResponseStep(false, "message"), ValidationStep.BuildValidationResponseStep(false, "message") }); er1.ValidationSteps.Count.ShouldBe(3); }
public void InvalidCollectionResults( ValidationStep step, IViewModel item, IVMPropertyDescriptor property ) { _cachedCollectionResults.RemoveAll(res => res.Target.Step == step && res.Target.Property == property && item.Kernel.OwnerCollections.Contains(res.Target.Collection) ); }
public override ValidationResult Validate(object value, System.Globalization.CultureInfo cultureInfo) { StringBuilder buidler = new StringBuilder(); Debug.WriteLine(buidler.Append("TraceValidationRule for '") .Append(PropertyName) .Append("' called. ValidationStep='") .Append(ValidationStep.ToString()) .Append("'").ToString()); return(ValidationResult.ValidResult); // Don't stop the validation process by reporting an error. }
public static IInstanceValidationTarget ForInstance( ValidationStep step, IViewModel vm, IVMPropertyDescriptor property = null ) { Check.NotNull(vm, nameof(vm)); return(new ValidationTarget(step) { VM = vm, Property = property }); }
public static ICollectionValidationTarget ForCollection( ValidationStep step, IVMCollection collection, IVMPropertyDescriptor property = null ) { Check.NotNull(collection, nameof(collection)); return(new ValidationTarget(step) { Collection = collection, Property = property }); }
public void SetUp() { theModel = new SimpleModel(); r1 = MockRepository.GenerateStub<IValidationRule>(); r2 = MockRepository.GenerateStub<IValidationRule>(); theSource = typeof(ConfiguredValidationSource); theContext = ValidationContext.For(theModel); theStep = new ValidationStep(theModel.GetType(), theSource, new[] { r1, r2 }); }
public void SetUp() { theModel = new SimpleModel(); r1 = MockRepository.GenerateStub <IValidationRule>(); r2 = MockRepository.GenerateStub <IValidationRule>(); theSource = typeof(ConfiguredValidationSource); theContext = ValidationContext.For(theModel); theStep = new ValidationStep(theModel.GetType(), theSource, new[] { r1, r2 }); }
public void PushValidatorBuildActions( IValidator validator, ValidationStep step ) { PushGeneralBuildAction( BuildActionOrder.Validator, () => ActionArgs.Push(validator) ); PushConditionBuildAction( BuildActionOrder.PredefinedConditions, new ValidationStepCondition(step) ); }
public PropertyValidationArgs( IValidator validator, ValidationStep step, TOwnerVM owner, TTargetVM target, IVMPropertyDescriptor <TValue> targetProperty ) : base(step, validator, owner) { Check.NotNull(target, nameof(target)); Check.NotNull(targetProperty, nameof(targetProperty)); Target = target; TargetProperty = targetProperty; }
public ValidationResult GetResult( ValidationStep step, IViewModel target, IVMPropertyDescriptor targetProperty = null ) { var t = ValidationTarget.ForInstance(step, target, targetProperty); var request = t.CreateValidationRequest(); var result = t.VM.ExecuteValidationRequest(request); var collectionResult = GetCollectionItemResults(t); return(ValidationResult.Join(result, collectionResult)); }
public static IValidationErrorTarget ForError( ValidationStep step, IViewModel vm, IVMCollection collection = null, IVMPropertyDescriptor property = null ) { Check.NotNull(vm, nameof(vm)); return(new ValidationTarget(step) { VM = vm, Collection = collection, Property = property }); }
private void AssertStandardValidators( IVMDescriptor descriptor, ValidationStep step, PathDefinition targetPath, IValidator validator, Func <ValidatorConditionArgs <EmployeeVM, IViewModel <ProjectVMDescriptor> >, bool> condition1 = null, Func <ValidatorConditionArgs <EmployeeVM, IViewModel <ProjectVMDescriptor> >, bool> condition2 = null ) { IValidator expectedValidator = validator; if (condition2 != null) { expectedValidator = new ConditionalValidator( new DelegateValidatorCondition <EmployeeVM, IViewModel <ProjectVMDescriptor> >(condition2, 0), expectedValidator ); } if (condition1 != null) { expectedValidator = new ConditionalValidator( new DelegateValidatorCondition <EmployeeVM, IViewModel <ProjectVMDescriptor> >(condition1, 0), expectedValidator ); } expectedValidator = new ConditionalValidator( new ValidationStepCondition(step), new ConditionalValidator( new ValidationTargetCondition(targetPath), expectedValidator ) ); ValidatorExecutorBehavior expectedBehavior = new ValidatorExecutorBehavior(); expectedBehavior.AddValidator(expectedValidator); Assert.AreEqual( expectedBehavior.ToString(), descriptor .Behaviors .GetNextBehavior <ValidatorExecutorBehavior>() .ToString() ); }
public void finds_the_rules_from_all_steps() { var r1 = new StubRule(); var r2 = new StubRule(); var r3 = new ClassFieldValidationRules(); var r4 = new ClassFieldValidationRules(); var src1 = new ConfiguredValidationSource(new IValidationRule[] { r1, r3 }); var src2 = new ConfiguredValidationSource(new IValidationRule[] { r2, r4 }); var step1 = ValidationStep.FromSource(typeof(object), src1); var step2 = ValidationStep.FromSource(typeof(object), src2); var plan = new ValidationPlan(typeof(object), new[] { step1, step2 }); plan.FindRules <StubRule>().ShouldHaveTheSameElementsAs(r1, r2); }
private static CollectionValidationArgs <IViewModel, EmployeeVM, string> CreateArgsWithProperty( EmployeeListVM owner, ValidationStep step = ValidationStep.Value, IValidator validator = null ) { validator = validator ?? Mock <IValidator>(); var path = Path.Empty .Append(owner) .Append(owner.GetValue(x => x.Employees)) .Append(EmployeeVM.ClassDescriptor.Name); return(CollectionValidationArgs <IViewModel, EmployeeVM, string> .Create( validator, new ValidationRequest(step, path) )); }
public void ExecutionResult_Errors() { var er1 = new ExecutionResult("ss", null); er1.ExecutionResultSteps.Add(ExecutionResultStep.Build(ExecutionStatus.Passed, "message")); er1.HasErrors.ShouldBeFalse(); er1.HasExecutionErrors.ShouldBeFalse(); er1.HasValidationErrors.ShouldBeFalse(); er1.ExecutionResultSteps.Add(ExecutionResultStep.Build(ExecutionStatus.Failed, "message")); er1.HasErrors.ShouldBeTrue(); er1.HasExecutionErrors.ShouldBeTrue(); er1.HasValidationErrors.ShouldBeFalse(); var er2 = new ExecutionResult("ss", null); er2.ValidationSteps.Add(ValidationStep.BuildValidationResponseStep(false, "message")); er2.HasErrors.ShouldBeTrue(); er2.HasExecutionErrors.ShouldBeFalse(); er2.HasValidationErrors.ShouldBeTrue(); }
/// <summary> /// Run validation rules for the given step /// <summary> internal override bool Validate(object value, ValidationStep validationStep) { // run rules attached to this binding bool result = base.Validate(value, validationStep); if (validationStep == ValidationStep.UpdatedValue) { if (result && ParentBinding.ValidatesOnDataErrors) { // remember the old validation error, if it came from the implicit DataError rule ValidationError oldValidationError = GetValidationErrors(validationStep); if (oldValidationError != null && oldValidationError.RuleInError != DataErrorValidationRule.Instance) { oldValidationError = null; } // run the DataError rule, even though it doesn't appear in the // ValidationRules collection ValidationError error = RunValidationRule(DataErrorValidationRule.Instance, this, GetCulture()); if (error != null) { UpdateValidationError(error); result = false; } else if (oldValidationError != null) { // the implicit rule is now valid - clear the old error UpdateValidationError(null); } } } else if (validationStep == ValidationStep.CommittedValue) { if (result) { NeedsValidation = false; } } return result; }
/// <summary> /// Run validation rules for the given step, and inform the binding group /// <summary> internal override bool CheckValidationRules(BindingGroup bindingGroup, ValidationStep validationStep) { if (!NeedsValidation) return true; object value; switch (validationStep) { case ValidationStep.RawProposedValue: value = GetRawProposedValue(); break; case ValidationStep.ConvertedProposedValue: value = bindingGroup.GetValue(this); break; case ValidationStep.UpdatedValue: case ValidationStep.CommittedValue: value = this; break; default: throw new InvalidOperationException(SR.Get(SRID.ValidationRule_UnknownStep, validationStep, bindingGroup)); } return Validate(value, validationStep); }
// get all errors raised at the given step, in preparation for running // the rules at that step internal ValidationError GetValidationErrors(ValidationStep validationStep) { ValidationError validationError = BaseValidationError; if (validationError == null || validationError.RuleInError.ValidationStep != validationStep) return null; return validationError; }
/// <summary> /// Initialize a new instance of ValidationRule with the given validation /// step and target-update behavior. /// </summary> protected ValidationRule(ValidationStep validationStep, bool validatesOnTargetUpdated) { _validationStep = validationStep; _validatesOnTargetUpdated = validatesOnTargetUpdated; }
/// <summary> /// Run validation rules for the given step, and inform the binding group /// <summary> internal abstract bool CheckValidationRules(BindingGroup bindingGroup, ValidationStep validationStep);
// get all errors raised at the given step, in preparation for running // the rules at that step internal ValidationError GetValidationErrors(ValidationStep validationStep) { if (_validationError == null || _validationError.RuleInError.ValidationStep != validationStep) return null; return _validationError; }
protected ValidationRule(ValidationStep validationStep, bool validatesOnTargetUpdated) { }
/// <summary> /// Run validation rules for the given step /// <summary> internal virtual bool Validate(object value, ValidationStep validationStep) { if (value == Binding.DoNothing) return true; if (value == DependencyProperty.UnsetValue) { SetStatus(BindingStatus.UpdateSourceError); return false; } // get old errors from this step - we're about to reevaluate those rules. ValidationError oldValidationError = GetValidationErrors(validationStep); // ignore an error from the implicit DataError rule - this is checked // separately (in BindingExpression.Validate). [Dev10 575988] if (oldValidationError != null && oldValidationError.RuleInError == DataErrorValidationRule.Instance) { oldValidationError = null; } Collection<ValidationRule> validationRules = ParentBindingBase.ValidationRulesInternal; if (validationRules != null) { CultureInfo culture = GetCulture(); switch (validationStep) { case ValidationStep.UpdatedValue: case ValidationStep.CommittedValue: // rules at these steps get passed the rule owner value = this; break; } foreach (ValidationRule validationRule in validationRules) { if (validationRule.ValidationStep == validationStep) { ValidationResult validationResult = validationRule.Validate(value, culture); if (!validationResult.IsValid) { if (TraceData.IsExtendedTraceEnabled(this, TraceDataLevel.Update)) { TraceData.Trace(TraceEventType.Warning, TraceData.ValidationRuleFailed( TraceData.Identify(this), TraceData.Identify(validationRule))); } UpdateValidationError( new ValidationError(validationRule, this, validationResult.ErrorContent, null)); return false; // kenlai: } } } } // this step is now valid - clear the old error (if any) if (oldValidationError != null && oldValidationError == GetValidationErrors(validationStep)) { UpdateValidationError(null); } return true; }
/// <summary> /// Run validation rules for the given step /// <summary> internal override bool Validate(object value, ValidationStep validationStep) { BindingExpressionBase bindExpr = ActiveBindingExpression; if (bindExpr != null) { return bindExpr.Validate(value, validationStep); } return true; }
public KorValidation(ValidationStep validationStep, bool validatesOnTargetUpdated) : base(validationStep, validatesOnTargetUpdated) { }
/// <summary> /// Run validation rules for the given step, and inform the binding group /// <summary> internal override bool CheckValidationRules(BindingGroup bindingGroup, ValidationStep validationStep) { BindingExpressionBase bindExpr = ActiveBindingExpression; if (bindExpr != null) { return bindExpr.CheckValidationRules(bindingGroup, validationStep); } return true; }
/// <summary> /// Run validation rules for the given step /// <summary> internal override bool Validate(object value, ValidationStep validationStep) { if (value == Binding.DoNothing) return true; if (value == DependencyProperty.UnsetValue) { SetStatus(BindingStatusInternal.UpdateSourceError); return false; } // run rules attached to this multibinding bool result = base.Validate(value, validationStep); // run rules attached to the child bindings switch (validationStep) { case ValidationStep.RawProposedValue: // the child bindings don't get raw values until the Convert step break; default: object[] values = value as object[]; int count = MutableBindingExpressions.Count; if (values.Length < count) count = values.Length; for (int i=0; i<count; ++i) { value = values[i]; if (value == DependencyProperty.UnsetValue) { // an unset value means the binding failed validation at an earlier step, // typically at Raw step, evaluated during the MultiBinding's ConvertValue //result = false; // COMPAT: This should mean the MultiBinding as a whole fails validation, but // in 3.5 this didn't happen. Instead the process continued, writing back // values to child bindings that succeeded, and simply not writing back // to child bindings that didn't. } else if (value != Binding.DoNothing) { if (!MutableBindingExpressions[i].Validate(value, validationStep)) { values[i] = DependencyProperty.UnsetValue; // prevent writing an invalid value //result = false; // COMPAT: as above, preserve v3.5 behavior by not failing when a // child binding fails to validate } } } break; } return result; }