Data sources, random/sequential generators, Equivalence classes

.gitignore

@@ -9,4 +9,6 @@ _ReSharper.*
 *~
 *.log
 packages
-*.DotSettings
+*.DotSettings
+*.ncrunchproject
+*.ncrunchsolution

NTestDataBuilder.Tests/DataSources/DataSourceTests.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using NTestDataBuilder.DataSources;
+using NTestDataBuilder.DataSources.Generators;
+using Shouldly;
+using Xunit;
+
+namespace NTestDataBuilder.Tests.DataSources
+{
+    public class DataSourceTests
+    {
+        [Fact]
+        public void WhenCreatingADataSource_ThenListShouldContainAllTheValues()
+        {
+            var sut = new DummyDataSource();
+
+            var result = sut.List;
+
+            result.Count.ShouldBe(3);
+            result.ShouldBe(new List<string> { "Value 1", "Value 2", "Value 3" });
+        }
+
+        [Fact]
+        public void WhenGeneratingValuesFromDefaultDataSource_ThenShouldGenerateItemFromList()
+        {
+            var sut = new DummyDataSource();
+            var result = sut.Next();
+            sut.List.ShouldContain(result);
+        }
+
+        [Fact]
+        public void WhenGeneratingValuesFromDefaultDataSource_ThenShouldGenerateRandomItemsFromList()
+        {
+            var sut = new DummyDataSource();
+
+            var results = new List<string>();
+            for (int i = 0; i < 10; i++)
+            {
+                results.Add(sut.Next());
+            }
+
+            foreach (var item in sut.List)
+            {
+                results.ShouldContain(item);
+            }
+        }
+
+        [Fact]
+        public void WhenGeneratingValuesFromSequentialDataSource_ThenShouldGenerateSequentialItems()
+        {
+            var sut = new DummyDataSource(new SequentialGenerator());
+
+            sut.Next().ShouldBe(sut.List[0]);
+            sut.Next().ShouldBe(sut.List[1]);
+            sut.Next().ShouldBe(sut.List[2]);
+            sut.Next().ShouldBe(sut.List[0]);
+        }
+
+        [Fact]
+        public void WhenGeneratingValuesFromUniqueSequentialDataSource_ThenShouldThrowWhenCollectionExceeded()
+        {
+            var sut = new DummyDataSource(new SequentialGenerator(0,1,true));
+
+            sut.Next().ShouldBe(sut.List[0]);
+            sut.Next().ShouldBe(sut.List[1]);
+            sut.Next().ShouldBe(sut.List[2]);
+            Should.Throw<InvalidOperationException>(() => sut.Next());
+        }
+
+        [Fact]
+        public void WhenGeneratingValuesFromPersonDataSource_ThenShouldHave500Records()
+        {
+            new FirstNameSource().List.Count.ShouldBe(500);
+            new LastNameSource().List.Count.ShouldBe(500);
+            new FullNameSource().List.Count.ShouldBe(500);
+        }
+    }
+
+    public class DummyDataSource : DataSource<string>
+    {
+        public DummyDataSource(IGenerator generator)
+            : base(generator) { }
+
+        public DummyDataSource() 
+            : this(new RandomGenerator()) { }
+
+        protected override IList<string> InitializeList()
+        {
+            return new List<string>{"Value 1", "Value 2", "Value 3"};
+        }
+    }
+}

NTestDataBuilder.Tests/DataSources/Generators/RandomGeneratorTests.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Collections.Generic;
+using NTestDataBuilder.DataSources.Generators;
+using Shouldly;
+using Xunit;
+using Xunit.Extensions;
+
+namespace NTestDataBuilder.Tests.DataSources.Generators
+{
+    public class RandomGeneratorTests
+    {
+        [Theory,
+        InlineData(5,4),
+        InlineData(5,5)]
+        public void WhenCreatingRandomGenerator_ThenStartIndexMustBeLessThanListSize(int startIndex, int listSize)
+        {
+            Action factory = () => new RandomGenerator(startIndex, listSize);
+            Should.Throw<ArgumentException>(factory)
+                .Message.ShouldBe(string.Format("startIndex must be less than listSize"));
+        }
+
+        [Fact]
+        public void WhenGeneratingRandomIntegers_ThenShouldAlwaysGenerateIntegerBetweenStartIndexAndListSize()
+        {
+            var random = new Random();
+            for (int i = 0; i < 10; i++)
+            {
+                int minimumValue = random.Next(0,10);
+                int maximumValue = random.Next(20,30);
+                var sut = new RandomGenerator(minimumValue, maximumValue);
+
+                var result = sut.Generate();
+
+                result.ShouldBeGreaterThanOrEqualTo(minimumValue);
+                result.ShouldBeLessThanOrEqualTo(maximumValue);
+            }
+        }
+
+        [Fact]
+        public void WhenGeneratingRandomIntegers_ThenShouldBeAbleToGenerateLowerBoundaryValue()
+        {
+            var results = new List<int>();
+            var sut = new RandomGenerator(0, 3);
+            for (int i = 0; i < 10; i++)
+            {
+                results.Add(sut.Generate());
+            }
+            results.ShouldContain(0);
+        }
+
+        [Fact]
+        public void WhenGeneratingRandomIntegers_ThenShouldBeAbleToGenerateUpperBoundaryValue()
+        {
+            var results = new List<int>();
+            var sut = new RandomGenerator(0, 3);
+            for (int i = 0; i < 10; i++)
+            {
+                results.Add(sut.Generate());
+            }
+            results.ShouldContain(2);
+            results.ShouldNotContain(3);
+        }
+
+
+    }
+}

NTestDataBuilder.Tests/DataSources/Generators/SequentiaGeneratorTests.cs

@@ -0,0 +1,77 @@
+using System;
+using NTestDataBuilder.DataSources.Generators;
+using Shouldly;
+using Xunit;
+using Xunit.Extensions;
+
+namespace NTestDataBuilder.Tests.DataSources.Generators
+{
+    public class SequentiaGeneratorTests
+    {
+        [Theory,
+        InlineData(5, 4),
+        InlineData(5, 5)]
+        public void WhenCreatingRandomGenerator_ThenStartIndexMustBeLessThanListSize(int startIndex, int listSize)
+        {
+            Action factory = () => new SequentialGenerator(startIndex, listSize);
+            Should.Throw<ArgumentException>(factory)
+                .Message.ShouldBe(string.Format("startIndex must be less than listSize"));
+        }
+
+        [Fact]
+        public void WhenCreatingRandomGenerator_ThenStartIndexMustBeZeroOrMore()
+        {
+            Action factory = () => new SequentialGenerator(-1, 1);
+            Should.Throw<ArgumentException>(factory)
+                .Message.ShouldBe(string.Format("startIndex must be zero or more"));
+        }
+
+        [Theory,
+        InlineData(0, 0),
+        InlineData(0, -1)]
+        public void WhenCreatingRandomGenerator_ThenListSizeMustBeGreaterThanZero(int startIndex, int listSize)
+        {
+            Action factory = () => new SequentialGenerator(startIndex, listSize);
+            Should.Throw<ArgumentException>(factory)
+                .Message.ShouldBe(string.Format("listSize must be greater than zero"));
+        }
+
+
+        [Fact]
+        public void WhenGeneratingIntegers_ThenShouldBeSequential()
+        {
+            var sut = new SequentialGenerator(0, 11);
+            for (int index = sut.StartIndex; index < sut.ListSize; index++)
+            {
+                sut.Generate().ShouldBe(index);
+            }
+        }
+
+        [Fact]
+        public void GivenGeneratorIsNotUnique_WhenGeneratingIntegers_ThenShouldResetAtEndOfList()
+        {
+            var sut = new SequentialGenerator(0, 2);
+            for (int index = sut.StartIndex; index < sut.ListSize; index++)
+            {
+                sut.Generate().ShouldBe(index);
+            }
+
+            sut.Generate().ShouldBe(sut.StartIndex);
+        }
+
+        [Fact]
+        public void GivenGeneratorIsUnique_WhenGeneratingIntegers_ThenShouldResetAtEndOfList()
+        {
+            var sut = new SequentialGenerator(0, 2, true);
+            for (int index = sut.StartIndex; index < sut.ListSize; index++)
+            {
+                sut.Generate().ShouldBe(index);
+            }
+
+            Should.Throw<InvalidOperationException>(()=>sut.Generate())
+                .Message.ShouldBe("There are not enough elements in the data source to continue adding items");
+        }
+
+
+    }
+}

NTestDataBuilder.Tests/EquivalenceClasses/CompanyEquivalenceClassTests.cs

@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+using System.Linq;
+using NTestDataBuilder.DataSources;
+using NTestDataBuilder.EquivalenceClasses;
+using Shouldly;
+using Xunit;
+
+namespace NTestDataBuilder.Tests.EquivalenceClasses
+{
+    public class CompanyEquivalenceClassTests
+    {
+        public AnonymousValueFixture Any { get; private set; }
+
+        public CompanyEquivalenceClassTests()
+        {
+            Any = new AnonymousValueFixture();
+        }
+
+        [Fact]
+        public void WhenGettingAnyCountry_ThenReturnRandomCompanyWhichIsReasonablyUnique()
+        {
+            var companySource = new CompanySource();
+
+            var results = new List<string>();
+            for (int i = 0; i < 10; i++)
+            {
+                results.Add(Any.Company());
+            }
+
+            foreach (var result in results)
+            {
+                result.ShouldBeOfType<string>();
+                result.ShouldNotBeNullOrEmpty();
+                companySource.List.ShouldContain(result);
+            }
+            var unique = results.Distinct().Count();
+            unique.ShouldBeGreaterThan(5);
+        }
+    }
+}

NTestDataBuilder.Tests/NTestDataBuilder.Tests.csproj

@@ -47,8 +47,15 @@
     <Reference Include="xunit">
       <HintPath>..\packages\xunit.1.9.2\lib\net20\xunit.dll</HintPath>
     </Reference>
+    <Reference Include="xunit.extensions">
+      <HintPath>..\packages\xunit.extensions.1.9.2\lib\net20\xunit.extensions.dll</HintPath>
+    </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="DataSources\DataSourceTests.cs" />
+    <Compile Include="DataSources\Generators\RandomGeneratorTests.cs" />
+    <Compile Include="DataSources\Generators\SequentiaGeneratorTests.cs" />
+    <Compile Include="EquivalenceClasses\CompanyEquivalenceClassTests.cs" />
     <Compile Include="EquivalenceClasses\StringEquivalenceClassesTests.cs" />
     <Compile Include="AsProxyTests.cs" />
     <Compile Include="BuildListTests.cs" />

NTestDataBuilder.Tests/packages.config

@@ -4,4 +4,5 @@
   <package id="NSubstitute" version="1.7.2.0" targetFramework="net40" />
   <package id="Shouldly" version="2.2.0" targetFramework="net40" />
   <package id="xunit" version="1.9.2" targetFramework="net40" />
+  <package id="xunit.extensions" version="1.9.2" targetFramework="net40" />
 </packages>