public void ShouldNotBePossibleEvaluateRuleWithBetweenConstraintWhenPropertyHasOtherType()
        {
            var data       = ObjectHelper.ToDictionary(new { Age = "Older" });
            var constraint = new BetweenConstraint("Age", 12, 18);

            Assert.False(constraint.Evaluate(data));
        }
        public void ShouldNotBePossibleEvaluateRuleWithBetweenConstraintWhenPropertyIsNull()
        {
            var data       = ObjectHelper.ToDictionary(new { Age = (int?)null });
            var constraint = new BetweenConstraint("Age", 12, 18);

            Assert.False(constraint.Evaluate(data));
        }
        public void ShouldNotBePossibleEvaluateRuleWithBetweenConstraintAndPropertyMissing()
        {
            var data       = ObjectHelper.ToDictionary(new { });
            var constraint = new BetweenConstraint("Age", 12, 18);

            Assert.False(constraint.Evaluate(data));
        }
Esempio n. 4
0
        public void ShouldBeAbleToAddUpperUsingAnd()
        {
            uniqueRandomGenerator.Next(lower, upper).Returns(2);

            var constraint = new BetweenConstraint(uniqueRandomGenerator, lower);

            constraint.And(upper);

            constraint.GetEnd();
        }
Esempio n. 5
0
        public void ShouldBeAbleToUseBetweenPickerConstraint()
        {
            lower = 1;
            upper = 5;
            uniqueRandomGenerator.Next(lower, upper).Returns(2);
            var constraint = new BetweenConstraint(uniqueRandomGenerator, lower, upper);

            int end = constraint.GetEnd();

            Assert.That(end, Is.EqualTo(2));
        }
        public void ShouldNotBePossibleEvaluateRuleWithBetweenConstraintAndValueOutOfRange()
        {
            var data = ObjectHelper.ToDictionary(new
            {
                Age = 19
            });

            var constraint = new BetweenConstraint("Age", 12, 18);

            Assert.False(constraint.Evaluate(data));
        }
        public void ShouldBeAbleToAddUpperUsingAnd()
        {
            using (mocks.Record())
            {
                uniqueRandomGenerator.Expect(x => x.Next(lower, upper)).Return(2);
            }

            var constraint = new BetweenConstraint(uniqueRandomGenerator, lower);
            constraint.And(upper);

            using (mocks.Playback())
            {
                constraint.GetEnd();
            }
        }
        public void ShouldBeAbleToAddUpperUsingAnd()
        {
            using (mocks.Record())
            {
                uniqueRandomGenerator.Expect(x => x.Next(lower, upper)).Return(2);
            }

            var constraint = new BetweenConstraint(uniqueRandomGenerator, lower);

            constraint.And(upper);

            using (mocks.Playback())
            {
                constraint.GetEnd();
            }
        }
        public void ShouldBeAbleToUseBetweenPickerConstraint()
        {
            lower = 1;
            upper = 5;
            var constraint = new BetweenConstraint(uniqueRandomGenerator, lower, upper);

            using (mocks.Record())
            {
                uniqueRandomGenerator.Expect(x => x.Next(lower, upper)).Return(2);
            }

            using (mocks.Ordered())
            {
                int end = constraint.GetEnd();

                Assert.That(end, Is.EqualTo(2));
            }
        }
        public void ShouldBeAbleToUseBetweenPickerConstraint()
        {
            lower = 1;
            upper = 5;
            var constraint = new BetweenConstraint(uniqueRandomGenerator, lower, upper);

            using (mocks.Record())
            {
                uniqueRandomGenerator.Expect(x => x.Next(lower, upper)).Return(2);
            }

            using (mocks.Ordered())
            {
                int end = constraint.GetEnd();

                Assert.That(end, Is.EqualTo(2));
            }
        }