Moved to .NET Core with support for .NET 3.5, .NET Core

Author: Tynamix

ObjectFiller.Core.Test/AddressFillingTest.cs

@@ -0,0 +1,125 @@
+using Xunit;
+using ObjectFiller.Test.TestPoco.Person;
+using Tynamix.ObjectFiller;
+
+namespace ObjectFiller.Test
+{
+    using System.Linq;
+
+
+    public class AddressFillingTest
+    {
+        [Fact]
+        public void FillAllAddressProperties()
+        {
+            Filler<Address> addressFiller = new Filler<Address>();
+            Address a = addressFiller.Create();
+
+            Assert.NotNull(a.City);
+            Assert.NotNull(a.Country);
+            Assert.NotEqual(0, a.HouseNumber);
+            Assert.NotNull(a.PostalCode);
+            Assert.NotNull(a.Street);
+        }
+
+        [Fact]
+        public void IgnoreCountry()
+        {
+            Filler<Address> addressFiller = new Filler<Address>();
+            addressFiller.Setup()
+                    .OnProperty(x => x.Country).IgnoreIt();
+            Address a = addressFiller.Create();
+
+            Assert.NotNull(a.City);
+            Assert.Null(a.Country);
+            Assert.NotEqual(0, a.HouseNumber);
+            Assert.NotNull(a.PostalCode);
+            Assert.NotNull(a.Street);
+        }
+
+        [Fact]
+        public void IgnoreCountryAndCity()
+        {
+            Filler<Address> addressFiller = new Filler<Address>();
+            addressFiller.Setup()
+                .OnProperty(x => x.Country, x => x.City).IgnoreIt();
+            Address a = addressFiller.Create();
+
+            Assert.Null(a.City);
+            Assert.Null(a.Country);
+            Assert.NotEqual(0, a.HouseNumber);
+            Assert.NotNull(a.PostalCode);
+            Assert.NotNull(a.Street);
+        }
+
+        [Fact]
+        public void SetupCityPropertyWithConstantValue()
+        {
+            Filler<Address> addressFiller = new Filler<Address>();
+            addressFiller.Setup()
+                .OnProperty(ad => ad.City).Use(() => "City");
+            Address a = addressFiller.Create();
+
+            Assert.Equal("City", a.City);
+            Assert.NotNull(a.Country);
+            Assert.NotEqual(0, a.HouseNumber);
+            Assert.NotNull(a.PostalCode);
+            Assert.NotNull(a.Street);
+        }
+
+        [Fact]
+        public void SetupCityAndCountryPropertyWithConstantValue()
+        {
+            Filler<Address> addressFiller = new Filler<Address>();
+            addressFiller.Setup()
+                .OnProperty(ad => ad.City, ad => ad.Country).Use(() => "CityCountry");
+            Address a = addressFiller.Create();
+
+            Assert.Equal("CityCountry", a.City);
+            Assert.NotNull(a.Country);
+            Assert.NotEqual(0, a.HouseNumber);
+            Assert.NotNull(a.PostalCode);
+            Assert.NotNull(a.Street);
+        }
+
+        [Fact]
+        public void SetupTheAdressWithStaticValues()
+        {
+            Filler<Address> addressFiller = new Filler<Address>();
+            addressFiller.Setup()
+                .OnType<int>().Use(10)
+                .OnProperty(x => x.City).Use("Dresden")
+                .OnProperty(x => x.Country).Use("Germany")
+                .OnProperty(x => x.PostalCode).Use(() => "0011100");
+
+            var address = addressFiller.Create();
+            Assert.Equal("Dresden", address.City);
+            Assert.Equal("Germany", address.Country);
+            Assert.Equal("0011100", address.PostalCode);
+            Assert.Equal(10, address.HouseNumber);
+        }
+
+        [Fact]
+        public void RandomListPluginShallReturnDifferentValues()
+        {
+            Filler<Address> addressFiller = new Filler<Address>();
+
+            addressFiller.Setup().OnProperty(x => x.City).Use(new RandomListItem<string>("Test1", "Test2"));
+
+            var addresses = addressFiller.Create(1000);
+
+            Assert.True(addresses.Any(x => x.City == "Test2"));
+
+            addressFiller = new Filler<Address>();
+
+            addressFiller.Setup().OnProperty(x => x.City).Use(new RandomListItem<string>("Test1"));
+
+            addresses = addressFiller.Create(1000);
+
+            Assert.True(addresses.All(x => x.City == "Test1"));
+
+        }
+
+
+    }
+}

ObjectFiller.Core.Test/CityNamesPluginTest.cs

@@ -0,0 +1,19 @@
+namespace ObjectFiller.Test
+{
+    using Xunit;
+
+    using Tynamix.ObjectFiller;
+
+
+    public class CityNamesPluginTest
+    {
+        [Fact]
+        public void RandomNameIsReturned()
+        {
+            var sut = new CityName();
+            var value = sut.GetValue();
+
+            Assert.False(string.IsNullOrEmpty(value));
+        }
+    }
+}

ObjectFiller.Core.Test/CopyConstructorTest.cs

@@ -0,0 +1,62 @@
+using System;
+using Xunit;
+using Tynamix.ObjectFiller;
+
+namespace ObjectFiller.Test
+{
+
+    public class CopyConstructorTest
+    {
+
+        [Fact]
+        public void WhenClassWithCopyConstructorIsCreatedNoExceptionShallBeThrown()
+        {
+            var f = new Filler<ClassWithCopyConstructorAndNormalConstructor>();
+            var cc = f.Create();
+
+            Assert.NotNull(cc);
+        }
+
+        [Fact]
+        public void WhenClassWithJustCopyConstructorIsCreatedAExceptionShallBeThrown()
+        {
+            var f = new Filler<ClassWithCopyConstructor>();
+            Assert.Throws<InvalidOperationException>(() => f.Create());
+
+        }
+    }
+
+    public class ClassWithCopyConstructor
+    {
+
+        public ClassWithCopyConstructor(ClassWithCopyConstructor constructor)
+        {
+            Count1 = constructor.Count1;
+            Count2 = constructor.Count2;
+        }
+
+        public int Count1 { get; set; }
+
+        public int Count2 { get; set; }
+    }
+
+
+    public class ClassWithCopyConstructorAndNormalConstructor
+    {
+        public ClassWithCopyConstructorAndNormalConstructor(int count1, int count2)
+        {
+            Count1 = count1;
+            Count2 = count2;
+        }
+
+        public ClassWithCopyConstructorAndNormalConstructor(ClassWithCopyConstructorAndNormalConstructor constructor)
+            : this(constructor.Count1, constructor.Count2)
+        {
+
+        }
+
+        public int Count1 { get; set; }
+
+        public int Count2 { get; set; }
+    }
+}

ObjectFiller.Core.Test/CountryNamesPlugin.cs

@@ -0,0 +1,19 @@
+namespace ObjectFiller.Test
+{
+        using Xunit;
+
+    using Tynamix.ObjectFiller;
+
+
+    public class CountryNamesPlugin
+    {
+        [Fact]
+        public void RandomNameIsReturned()
+        {
+            var sut = new CountryName();
+            var value = sut.GetValue();
+
+            Assert.False(string.IsNullOrEmpty(value));
+        }
+    }
+}

ObjectFiller.Core.Test/CreateInstanceTest.cs

@@ -0,0 +1,78 @@
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+using Tynamix.ObjectFiller;
+
+namespace ObjectFiller.Test
+{
+
+    public abstract class Parent
+    {
+        public Parent(int id)
+        {
+            Id = id;
+        }
+
+        public int Id { get; set; }
+
+    }
+
+    public class ChildOne : Parent
+    {
+        public ChildOne(int id)
+            : base(id)
+        {
+        }
+
+        public string Name { get; set; }
+    }
+
+    public class ChildTwo : Parent
+    {
+        public ChildTwo(int id)
+            : base(id)
+        {
+        }
+
+        public string OtherName { get; set; }
+    }
+
+    public class ParentOfParent
+    {
+        public ParentOfParent()
+        {
+            Parents = new List<Parent>();
+        }
+
+        public List<Parent> Parents { get; private set; }
+
+    }
+
+
+
+    public class CreateInstanceTest
+    {
+
+        [Fact]
+        public void TestCreateInstanceOfChildOne()
+        {
+            Filler<ParentOfParent> p = new Filler<ParentOfParent>();
+
+            p.Setup().OnType<Parent>().CreateInstanceOf<ChildOne>()
+                .SetupFor<ChildOne>()
+                .OnProperty(x => x.Name).Use(() => "TEST");
+
+            var pop = p.Create();
+
+            Assert.NotNull(pop);
+            Assert.NotNull(pop.Parents);
+            Assert.True(pop.Parents.All(x => x is ChildOne));
+            Assert.False(pop.Parents.Any(x => x is ChildTwo));
+
+            Assert.True(pop.Parents.Cast<ChildOne>().All(x => x.Name == "TEST"));
+
+
+        }
+
+    }
+}

ObjectFiller.Core.Test/DateTimeRangeTest.cs

@@ -0,0 +1,72 @@
+namespace ObjectFiller.Test
+{
+    using System;
+    using System.Linq;
+
+    using Xunit;
+
+    using Tynamix.ObjectFiller;
+
+    public class DateRangeTestClass
+    {
+        public DateTime Date { get; set; }
+    }
+
+
+    public class DateTimeRangeTest
+    {
+        [Fact]
+        public void WhenGettingDatesBetweenNowAnd31DaysAgo()
+        {
+            Filler<DateRangeTestClass> filler = new Filler<DateRangeTestClass>();
+
+            filler.Setup().OnType<DateTime>().Use(
+                new DateTimeRange(DateTime.Now.AddDays(-31)));
+
+            var d = filler.Create(1000);
+
+            Assert.True(d.All(x => x.Date < DateTime.Now && x.Date > DateTime.Now.AddDays(-31)));
+        }
+
+        [Fact]
+        public void WhenStartDateIsBiggerThenEndDateTheDatesShouldBeSwitched()
+        {
+            Filler<DateRangeTestClass> filler = new Filler<DateRangeTestClass>();
+
+            filler.Setup().OnType<DateTime>().Use(
+                new DateTimeRange(DateTime.Now, DateTime.Now.AddDays(-31)));
+
+            var d = filler.Create(1000);
+
+            Assert.True(d.All(x => x.Date < DateTime.Now && x.Date > DateTime.Now.AddDays(-31)));
+        }
+
+        [Fact]
+        public void WhenStartDateAndEndDateIsSetItShouldFindOnlyDatesInBetweenThisTwoDates()
+        {
+            var startDate = new DateTime(2000, 11, 10);
+            var endDate = new DateTime(2006, 1, 30);
+
+            Filler<DateRangeTestClass> filler = new Filler<DateRangeTestClass>();
+
+            filler.Setup().OnType<DateTime>().Use(new DateTimeRange(startDate, endDate));
+
+            var d = filler.Create(1000);
+            d.ToList().ForEach(x => Console.WriteLine(x.Date));
+            Assert.True(d.All(x => x.Date < endDate && x.Date > startDate));
+        }
+
+        [Fact]
+        public void WhenConstructorWithDateTimeNowWillBeCalledNoExceptionShouldBeThrown()
+        {
+            Filler<DateRangeTestClass> filler = new Filler<DateRangeTestClass>();
+
+            filler.Setup().OnProperty(x => x.Date).Use(new DateTimeRange(DateTime.Now));
+
+            var dateTime = filler.Create();
+
+            Assert.True(dateTime.Date > DateTime.MinValue);
+            Assert.True(dateTime.Date < DateTime.MaxValue);
+        }
+    }
+}