public async Task EvaluateAsync_MatchingCondition_ReturnsValidResult()
        {
            var rule   = new ConfigurableValidationRule <string>(p => Task.FromResult(true), "foo");
            var result = await rule.EvaluateAsync("bar");

            Assert.True(result.IsValid);
        }
        public IConfigurableValidationRule MatchAsync(Func <TMember, Task <bool> > condition)
        {
            if (condition == null)
            {
                throw new ArgumentNullException(nameof(condition));
            }

            var rule = new ConfigurableValidationRule <TMember>(condition, this.name);

            return(this.SetConfigurableRule(rule));
        }
        public async Task EvaluateAsync_NotMatchingCondition_ReturnsErrorResult()
        {
            var expectedError      = "error";
            var expectedMemberName = "foo";

            var rule = new ConfigurableValidationRule <string>(p => Task.FromResult(false), expectedMemberName, expectedError);

            var result = await rule.EvaluateAsync("bar");

            Assert.False(result.IsValid);
            Assert.Equal(expectedError, result.Errors.Single().Message);
            Assert.Equal(expectedMemberName, result.Errors.Single().MemberName);
        }
        public async Task EvaluateAsync_EvaluatesCondition()
        {
            var    expectedValue = "bar";
            string actualValue   = null;

            var validationRule = new ConfigurableValidationRule <string>(value =>
            {
                actualValue = value;
                return(Task.FromResult(true));
            }, "foo");

            var result = await validationRule.EvaluateAsync(expectedValue);

            Assert.Equal(expectedValue, actualValue);
        }