/// <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 );
}
