Example #1
0
        public void HasHigherPriorityThanDateTimeValueGenerator()
        {
            var sut   = new Wrapper();
            var other = new DateTimeValueGenerator();

            sut.Priority.Should().BeGreaterThan(other.Priority);
        }
        public void GenerateCanReturnNullAndRandomValuesTest(Type targetType)
        {
            var nullFound = false;
            var valueFound = false;

            var target = new DateTimeValueGenerator();

            for (var index = 0; index < 1000; index++)
            {
                var value = target.Generate(targetType, null, null);

                if (value == null)
                {
                    nullFound = true;
                }
                else
                {
                    valueFound = true;
                }

                if (nullFound && valueFound)
                {
                    break;
                }
            }

            nullFound.Should().BeTrue();
            valueFound.Should().BeTrue();
        }
        public void AllowNullDeterminesWhetherNullCanBeReturned(bool allowNull)
        {
            var nullFound = false;

            var executeStrategy = Substitute.For <IExecuteStrategy>();

            var buildChain = new BuildHistory();

            executeStrategy.BuildChain.Returns(buildChain);

            var sut = new DateTimeValueGenerator
            {
                AllowNull = allowNull
            };

            for (var index = 0; index < 10000; index++)
            {
                var value = sut.Generate(executeStrategy, typeof(DateTime?));

                if (value == null)
                {
                    nullFound = true;

                    break;
                }
            }

            nullFound.Should().Be(allowNull);
        }
        public void GenerateReturnsRandomDateTimeValueTest()
        {
            var target = new DateTimeValueGenerator();

            var first = target.Generate(typeof(DateTime), null, null);

            first.Should().BeOfType<DateTime>();
            first.As<DateTime>().Kind.Should().Be(DateTimeKind.Utc);

            var second = target.Generate(typeof(DateTime), null, null);

            first.Should().NotBe(second);
        }
        public void GenerateReturnsRandomDateTimeOffsetValueTest()
        {
            var target = new DateTimeValueGenerator();

            var first = target.Generate(typeof(DateTimeOffset), null, null);

            first.Should().BeOfType<DateTimeOffset>();
            first.As<DateTimeOffset>().Offset.Should().Be(TimeSpan.Zero);

            var second = target.Generate(typeof(DateTimeOffset), null, null);

            first.Should().NotBe(second);
        }
        public void GenerateAlwaysReturnsFutureValuesWithin10YearsTest()
        {
            var target = new DateTimeValueGenerator();

            for (var index = 0; index < 1000; index++)
            {
                var value = (DateTime?)target.Generate(typeof(DateTime?), null, null);

                if (value == null)
                {
                    continue;
                }

                value.Should().BeAfter(DateTime.UtcNow);
                value.Should().BeBefore(DateTime.UtcNow.AddYears(10));
            }
        }
        public void HasHigherPriorityThanDateTimeValueGeneratorTest()
        {
            var target = new DateOfBirthValueGenerator();
            var other = new DateTimeValueGenerator();

            target.Priority.Should().BeGreaterThan(other.Priority);
        }
        public void AllowNullReturnsFalseByDefault()
        {
            var sut = new DateTimeValueGenerator();

            sut.AllowNull.Should().BeFalse();
        }
        public void GenerateReturnsRandomTimeSpanValueTest()
        {
            var target = new DateTimeValueGenerator();

            var first = (TimeSpan)target.Generate(typeof(TimeSpan), null, null);
            var second = (TimeSpan)target.Generate(typeof(TimeSpan), null, null);

            first.Should().NotBe(second);
        }
        public void IsSupportedThrowsExceptionWithNullTypeTest()
        {
            var target = new DateTimeValueGenerator();

            Action action = () => target.IsSupported(null, null, null);

            action.ShouldThrow<ArgumentNullException>();
        }
        public void IsSupportedTest(Type type, bool expected)
        {
            var target = new DateTimeValueGenerator();

            var actual = target.IsSupported(type, null, null);

            actual.Should().Be(expected);
        }
        public void GenerateThrowsExceptionWithInvalidParametersTest(Type type)
        {
            var target = new DateTimeValueGenerator();

            Action action = () => target.Generate(type, null, null);

            action.ShouldThrow<NotSupportedException>();
        }