/// <summary> /// Validates that the specified string is not empty or null. /// </summary> /// <param name="name">A user-friendly name identifying the value that is missing.</param> /// <param name="value">The value to validate.</param> public static ValidationResult Validate(string name, string value) { return (string.IsNullOrWhiteSpace(value) ? RequiredRule.GetFailedResult(name) : ValidationResult.Success); }
/// <summary> /// Validates that the specified object is not null. /// </summary> /// <param name="name">A user-friendly name identifying the value that is missing.</param> /// <param name="value">The value to validate.</param> public static ValidationResult Validate(string name, object value) { return (value == null ? RequiredRule.GetFailedResult(name) : ValidationResult.Success); }
public void GivenValidatingRequiredValue_WhenValueIsSet_ValidationIsSuccessful() { var value = 42; var result = new RequiredRule().Validate(value.ToString()); result.IsSuccess.Should().BeTrue(); }
public void GetPropertyNamesReferencedThrowsExceptionIfPropertyNameNotSet() { // Arrange var r = new RequiredRule("ARuleName"); // Act var pNames = r.GetPropertyNamesReferenced(); }
/// <summary> /// 验证必须输入 /// </summary> /// <param name="box">验证框</param> /// <param name="errorMessage">提示信息</param> /// <returns></returns> public static ValidBox Required(this ValidBox box, string errorMessage) { var newBox = new RequiredRule { ErrorMessage = errorMessage }.ToValidBox(); return(ValidBox.Merge(box, newBox)); }
private void TestPropertyWithNullEquivalent(string Value) { // Arrange var r = new RequiredRule("Test Rule Name"); // Act r.Property(Value); }
public void GivenValidatingRequiredValueWithAllowedWhitespace_WhenValueIsWhiteSpace_ValidationFails() { var value = " "; var result = new RequiredRule().AllowWhiteSpace().Validate(value); result.IsSuccess.Should().BeTrue(); }
public void PropertyThrowsExceptionIfPropertyNameIsAlreadySet() { // Arrange var pName = "APropertyName"; var r = new RequiredRule("ARuleName").Property(pName); // Act r.Property(pName); }
public void GivenValidatingRequiredValue_WhenValueIsEmpty_ValidationFails() { var value = string.Empty; var result = new RequiredRule().Validate(value); result.IsSuccess.Should().BeFalse(); result.Error.Should().Be("Value is required"); }
public void GivenValidatingRequiredValue_WhenValueIsNotSet_ValidationFails() { double?value = null; var result = new RequiredRule().Validate(value.ToString()); result.IsSuccess.Should().BeFalse(); result.Error.Should().Be("Value is required"); }
public void GivenValidatingRequiredValueWithoutAllowedWhitespace_WhenValueIsWhiteSpace_ValidationFails() { var value = " "; var result = new RequiredRule().Validate(value); result.IsSuccess.Should().BeFalse(); result.Error.Should().Be("Value is required"); }
public IParsingRule GetRule() { var requireRule = new RequiredRule(); if (_allowWhiteSpace) { requireRule.AllowWhiteSpace(); } return(requireRule); }
public void IsValidThrowsExceptionIfPropertyNameIsNotSet() { // Arrange var r = new RequiredRule("ARuleName"); // Act r.IsValid(new Dictionary <string, string>() { { "AProperty", "Blah" } }); }
public void GetPropertyNamesReferencedReturnsValues() { // Arrange var r = new RequiredRule("ARuleName").Property("ARequiredProperty"); // Act var pNames = r.GetPropertyNamesReferenced(); // Assert Assert.IsNotNull(pNames); Assert.AreEqual(1, pNames.Count); Assert.AreEqual("ARequiredProperty", pNames[0]); }
public void EvaluateShouldReturnSuccessForNonNullValue() { // arrange var rule = new RequiredRule<object>(); var property = new Property<object>( "Object", new object() ); var expected = ValidationResult.Success; // act var actual = rule.Evaluate( property ); // assert Assert.Equal( expected, actual ); }
public void EvaluateShouldReturnSuccessForEmptyString() { // arrange var rule = new RequiredRule<string>() { AllowEmptyStrings = true }; var property = new Property<string>( "Text", "" ); var expected = ValidationResult.Success; // act var actual = rule.Evaluate( property ); // assert Assert.Equal( expected, actual ); }
public void PropertySetsPropertyName() { // Arrange var pName = "PropertyName"; var r = new RequiredRule("TestRule"); // Act var returnedRule = r.Property(pName); // Assert Assert.AreSame(r, returnedRule); Assert.AreEqual(pName, r.PropertyName); }
public void EvaluateShouldReturnExpectedResultForNullValue() { // arrange var rule = new RequiredRule<object>(); var property = new Property<object>( "Object", null ); // act var actual = rule.Evaluate( property ); // assert Assert.Equal( "The Object field is required.", actual.ErrorMessage ); Assert.Equal( 1, actual.MemberNames.Count() ); Assert.Equal( "Object", actual.MemberNames.Single() ); }
public void ConstructorReturnsRequiredRule() { // Arrange var ruleName = "Required Rule Name"; // Act var r = new RequiredRule(ruleName); // Assert Assert.IsNotNull(r); Assert.AreEqual(ruleName, r.RuleName); Assert.IsNull(r.PropertyName); Assert.IsNull(r.ErrorMessage); }
public void IsValidReturnsTrueWithNonNullString() { // Arrange var r = new RequiredRule("ARuleName").Property("APropertyName"); // Act var result = r.IsValid(new Dictionary <string, string>(1) { { "APropertyName", "This is not a null string." } }); // Assert Assert.IsTrue(result); Assert.IsNull(r.ErrorMessage); }
protected override void OnInitialized() { Form.Items.Add(this); var validation = Form.Validations.FirstOrDefault(x => x.Name == Name); if (validation != null) { Rules = validation.Rules; } if (IsRequired && !Rules.OfType <RequiredRule>().Any()) { var requiredRule = new RequiredRule(); requiredRule.ErrorMessage = $"请确认{Label}"; Rules.Add(requiredRule); } }
private void TestIsValidWithNullEquivalent(string Value) { // Arrange var r = new RequiredRule("ARuleName").Property("APropertyName"); // Act var result = r.IsValid(new Dictionary <string, string>(1) { { "APropertyName", Value } }); // Assert Assert.IsFalse(result); Assert.AreEqual("APropertyName is required, but is null, an empty string, or whitespace.", r.ErrorMessage); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void testRequiredRuleByDefaultPlanItemControl() public virtual void testRequiredRuleByDefaultPlanItemControl() { // given PlanItemControl defaultControl = createElement(decisionTask, "ItemControl_1", typeof(DefaultControl)); RequiredRule requiredRule = createElement(defaultControl, "RequiredRule_1", typeof(RequiredRule)); ConditionExpression expression = createElement(requiredRule, "Expression_1", typeof(ConditionExpression)); expression.Text = "${true}"; Cmmn.validateModel(modelInstance); // when CmmnActivity newActivity = handler.handleElement(planItem, context); // then object rule = newActivity.getProperty(PROPERTY_REQUIRED_RULE); assertNotNull(rule); assertTrue(rule is CaseControlRule); }
protected internal virtual void initializeRequiredRule(CmmnElement element, CmmnActivity activity, CmmnHandlerContext context) { PlanItemControl itemControl = getItemControl(element); PlanItemControl defaultControl = getDefaultControl(element); RequiredRule requiredRule = null; if (itemControl != null) { requiredRule = itemControl.RequiredRule; } if (requiredRule == null && defaultControl != null) { requiredRule = defaultControl.RequiredRule; } if (requiredRule != null) { CaseControlRule caseRule = initializeCaseControlRule(requiredRule.Condition, context); activity.setProperty(PROPERTY_REQUIRED_RULE, caseRule); } }
public void ConstructorThrowsExceptionIfRuleNameIsNull() { // Act var r = new RequiredRule(null); }
public static Rule CreateRule(RuleTypeEnum ruleType) { Rule rule = null; switch (ruleType) { case RuleTypeEnum.MAX_LENGTH_RULE: rule = new MaxLengthRule(); break; case RuleTypeEnum.MIN_LENGTH_RULE: rule = new MinLengthRule(); break; case RuleTypeEnum.MAX_VALUE_RULE: rule = new MaxValueRule(); break; case RuleTypeEnum.MIN_VALUE_RULE: rule = new MinValueRule(); break; case RuleTypeEnum.MAX_INPUT_NUM_RULE: rule = new MaxInputNumRule(); break; case RuleTypeEnum.MIN_INPUT_NUM_RULE: rule = new MinInputNumRule(); break; case RuleTypeEnum.VALUE_TYPE_RULE: rule = new ValueTypeRule(); break; case RuleTypeEnum.REQUIRED_RULE: rule = new RequiredRule(); break; case RuleTypeEnum.DISABLE_RULE: rule = new DisableRule(); break; case RuleTypeEnum.MAX_DECIMAL_DIGITS_RULE: rule = new MaxDecimalDigitsRule(); break; case RuleTypeEnum.MIN_DECIMAL_DIGITS_RULE: rule = new MinDecimalDigitsRule(); break; case RuleTypeEnum.REGEX_RULE: rule = new RegexRule(); break; case RuleTypeEnum.SET_RULE: rule = new SetRule(); break; case RuleTypeEnum.TIP_RULE: rule = new TipRule(); break; case RuleTypeEnum.DEV_TIP_RULE: rule = new DevTipRule(); break; case RuleTypeEnum.READ_ONLY_RULE: rule = new ReadOnlyRule(); break; case RuleTypeEnum.MAX_TARGET_SIZE_RULE: rule = new MaxTargetSizeRule(); break; case RuleTypeEnum.MIN_TARGET_SIZE_RULE: rule = new MinTargetSizeRule(); break; case RuleTypeEnum.MAX_IMAGE_SIZE_RULE: rule = new MaxImageSizeRule(); break; case RuleTypeEnum.MIN_IMAGE_SIZE_RULE: rule = new MinImageSizeRule(); break; } return(rule); }
/// <summary> /// 验证必须输入 /// </summary> /// <param name="box">验证框</param> /// <returns></returns> public static ValidBox Required(this ValidBox box) { var newBox = new RequiredRule().ToValidBox(); return(ValidBox.Merge(box, newBox)); }
public void EvaluateShouldReturnExpectedResultForNullOrEmptyString( string value ) { // arrange var rule = new RequiredRule<string>(); var property = new Property<string>( "Text", value ); // act var actual = rule.Evaluate( property ); // assert Assert.Equal( "The Text field is required.", actual.ErrorMessage ); Assert.Equal( 1, actual.MemberNames.Count() ); Assert.Equal( "Text", actual.MemberNames.Single() ); }
public void ConstructorThrowsExceptionIfRuleNameIsEmptyString() { // Act var r = new RequiredRule(string.Empty); }
public void ConstructorThrowsExceptionIfRuleNameIsWhiteSpace() { // Act var r = new RequiredRule(" "); }
public void EvaluateShouldReturnResultWithCustomErrorMessageForString() { // arrange var expected = "Invalid"; var rule = new RequiredRule<string>( expected ); var property = new Property<string>( "Text", null ); // act var actual = rule.Evaluate( property ); // assert Assert.Equal( expected, actual.ErrorMessage ); }