Added remaining Person data sources

NTestDataBuilder.Tests/DataSources/DataSourceTests.cs

@@ -34,7 +34,7 @@ public void WhenGeneratingValuesFromDefaultDataSource_ThenShouldGenerateRandomIt
             var sut = new DummyDataSource();
 
             var results = new List<string>();
-            for (int i = 0; i < 10; i++)
+            for (int i = 0; i < 20; i++)
             {
                 results.Add(sut.Next());
             }
@@ -66,14 +66,6 @@ public void WhenGeneratingValuesFromUniqueSequentialDataSource_ThenShouldThrowWh
             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>

NTestDataBuilder.Tests/DataSources/Generators/RandomGeneratorTests.cs

@@ -41,7 +41,7 @@ public void WhenGeneratingRandomIntegers_ThenShouldBeAbleToGenerateLowerBoundary
         {
             var results = new List<int>();
             var sut = new RandomGenerator(0, 3);
-            for (int i = 0; i < 10; i++)
+            for (int i = 0; i < 20; i++)
             {
                 results.Add(sut.Generate());
             }
@@ -53,7 +53,7 @@ public void WhenGeneratingRandomIntegers_ThenShouldBeAbleToGenerateUpperBoundary
         {
             var results = new List<int>();
             var sut = new RandomGenerator(0, 3);
-            for (int i = 0; i < 10; i++)
+            for (int i = 0; i < 20; i++)
             {
                 results.Add(sut.Generate());
             }

NTestDataBuilder.Tests/DataSources/Generators/SequentiaGeneratorTests.cs

@@ -11,15 +11,15 @@ public class SequentiaGeneratorTests
         [Theory,
         InlineData(5, 4),
         InlineData(5, 5)]
-        public void WhenCreatingRandomGenerator_ThenStartIndexMustBeLessThanListSize(int startIndex, int listSize)
+        public void WhenCreatingSequentialGenerator_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()
+        public void WhenCreatingSequentialGenerator_ThenStartIndexMustBeZeroOrMore()
         {
             Action factory = () => new SequentialGenerator(-1, 1);
             Should.Throw<ArgumentException>(factory)
@@ -29,7 +29,7 @@ public void WhenCreatingRandomGenerator_ThenStartIndexMustBeZeroOrMore()
         [Theory,
         InlineData(0, 0),
         InlineData(0, -1)]
-        public void WhenCreatingRandomGenerator_ThenListSizeMustBeGreaterThanZero(int startIndex, int listSize)
+        public void WhenCreatingSequentialGenerator_ThenListSizeMustBeGreaterThanZero(int startIndex, int listSize)
         {
             Action factory = () => new SequentialGenerator(startIndex, listSize);
             Should.Throw<ArgumentException>(factory)
@@ -60,7 +60,7 @@ public void GivenGeneratorIsNotUnique_WhenGeneratingIntegers_ThenShouldResetAtEn
         }
 
         [Fact]
-        public void GivenGeneratorIsUnique_WhenGeneratingIntegers_ThenShouldResetAtEndOfList()
+        public void GivenGeneratorIsUnique_WhenGeneratingIntegers_ThenShouldThrowAtEndOfList()
         {
             var sut = new SequentialGenerator(0, 2, true);
             for (int index = sut.StartIndex; index < sut.ListSize; index++)

NTestDataBuilder.Tests/DataSources/PersonSourceTests.cs

@@ -0,0 +1,40 @@
+using System.Collections.Generic;
+using System.Linq;
+using NTestDataBuilder.DataSources;
+using Shouldly;
+using Xunit.Extensions;
+
+namespace NTestDataBuilder.Tests.DataSources
+{
+    public class PersonSourceTests
+    {
+        [Theory]
+        [PropertyData("TestCases")]
+        public void PersonSourceSpec(DataSource<string> sut, int expectedCount)
+        {
+            var collection = sut.List.ToList();
+            collection.Count.ShouldBe(expectedCount);
+            collection.Count.ShouldBe(sut.List.Distinct().ToList().Count);
+            collection.ForEach(item => item.ShouldNotBeNullOrEmpty());
+        }
+
+        public static IEnumerable<object[]> TestCases
+        {
+            get
+            {
+                yield return new object[] { new FirstNameSource(), 479 };
+                yield return new object[] { new LastNameSource(), 498 };
+                yield return new object[] { new FullNameSource(), 500 };
+                yield return new object[] { new CompanySource(), 496 };
+                yield return new object[] { new StreetSource(), 498 };
+                yield return new object[] { new CitySource(), 483 };
+                yield return new object[] { new CountySource(), 214 };
+                yield return new object[] { new PostCodeSource(), 433 };
+                yield return new object[] { new PhoneSource(), 500 };
+                yield return new object[] { new EmailSource(), 500 };
+                yield return new object[] { new WebsiteSource(), 498 };
+
+            }
+        }
+    }
+}

NTestDataBuilder.Tests/EquivalenceClasses/PersonEquivalenceClassesTests.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using NTestDataBuilder.DataSources;
+using NTestDataBuilder.EquivalenceClasses;
+using Shouldly;
+using Xunit.Extensions;
+
+namespace NTestDataBuilder.Tests.EquivalenceClasses
+{
+    public class PersonEquivalenceClassesTests
+    {
+         public static AnonymousValueFixture Any { get; private set; }
+
+         public PersonEquivalenceClassesTests()
+        {
+            Any = new AnonymousValueFixture();
+        }
+
+        [Theory]
+        [PropertyData("TestCases")]
+        public void WhenGettingAnyPersonData_ThenReturnRandomPersonDataWhichIsReasonablyUnique(DataSource<string> source,
+            List<string> testCases)
+        {
+            foreach (var testCase in testCases)
+            {
+                testCase.ShouldBeOfType<string>();
+                testCase.ShouldNotBeNullOrEmpty();
+                source.List.ShouldContain(testCase);
+            }
+            var unique = testCases.Distinct().Count();
+            unique.ShouldBeGreaterThan(5);
+        }
+
+        public static IEnumerable<object[]> TestCases
+        {
+            get
+            {
+                yield return new object[] { new FirstNameSource(), GenerateTestCasesForSut(Any.FirstName) };
+                yield return new object[] { new LastNameSource(), GenerateTestCasesForSut(Any.LastName) };
+                yield return new object[] { new FullNameSource(), GenerateTestCasesForSut(Any.FullName) };
+                yield return new object[] { new CompanySource(), GenerateTestCasesForSut(Any.Company) };
+                yield return new object[] { new StreetSource(), GenerateTestCasesForSut(Any.Street) };
+                yield return new object[] { new CitySource(), GenerateTestCasesForSut(Any.City) };
+                yield return new object[] { new CountySource(), GenerateTestCasesForSut(Any.County) };
+                yield return new object[] { new PostCodeSource(), GenerateTestCasesForSut(Any.PostCode) };
+                yield return new object[] { new PhoneSource(), GenerateTestCasesForSut(Any.Phone) };
+                yield return new object[] { new EmailSource(), GenerateTestCasesForSut(Any.Email) };
+                yield return new object[] { new WebsiteSource(), GenerateTestCasesForSut(Any.Website) };
+            }
+        }
+
+        private static List<string> GenerateTestCasesForSut(Func<string> any)
+        {
+            var results = new List<string>();
+            for (int i = 0; i < 10; i++)
+            {
+                results.Add(any());
+            }
+            return results;
+        } 
+    }
+}

NTestDataBuilder.Tests/NTestDataBuilder.Tests.csproj

@@ -55,7 +55,8 @@
     <Compile Include="DataSources\DataSourceTests.cs" />
     <Compile Include="DataSources\Generators\RandomGeneratorTests.cs" />
     <Compile Include="DataSources\Generators\SequentiaGeneratorTests.cs" />
-    <Compile Include="EquivalenceClasses\CompanyEquivalenceClassTests.cs" />
+    <Compile Include="DataSources\PersonSourceTests.cs" />
+    <Compile Include="EquivalenceClasses\PersonEquivalenceClassesTests.cs" />
     <Compile Include="EquivalenceClasses\StringEquivalenceClassesTests.cs" />
     <Compile Include="AsProxyTests.cs" />
     <Compile Include="BuildListTests.cs" />

NTestDataBuilder/DataSources/CitySource.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Linq;
+using NTestDataBuilder.DataSources.FileData;
+using NTestDataBuilder.DataSources.Generators;
+
+namespace NTestDataBuilder.DataSources
+{
+    /// <summary>
+    /// Free sample data for testing obtained from http://www.briandunning.com/sample-data/
+    /// </summary>
+    public class CitySource : DataSource<string>
+    {
+        /// <inheritdoc />
+        public CitySource() 
+            : base() { }
+
+        /// <inheritdoc />
+        public CitySource(IGenerator generator) 
+            : base(generator) { }
+
+        /// <inheritdoc />
+        protected override IList<string> InitializeList()
+        {
+            return FileDataRepository.People
+                .Select(person => person.City)
+                .Distinct()
+                .ToList();
+        }
+    }
+}

NTestDataBuilder/DataSources/CompanySource.cs

@@ -1,121 +1,30 @@
 using System.Collections.Generic;
+using System.Linq;
+using NTestDataBuilder.DataSources.FileData;
 using NTestDataBuilder.DataSources.Generators;
 
 namespace NTestDataBuilder.DataSources
 {
+    /// <summary>
+    /// Free sample data for testing obtained from http://www.briandunning.com/sample-data/
+    /// </summary>
     public class CompanySource : DataSource<string>
     {
+        /// <inheritdoc />
         public CompanySource() 
             : base() { }
 
+        /// <inheritdoc />
         public CompanySource(IGenerator generator) 
             : base(generator) { }
 
+        /// <inheritdoc />
         protected override IList<string> InitializeList()
         {
-            return new List<string>
-            {
-                "Wal-Mart Stores",
-                "Exxon Mobil",
-                "Chevron",
-                "Phillips ",
-                "Berkshire Hathaway",
-                "Apple",
-                "General Motors",
-                "General Electric",
-                "Valero Energy",
-                "Ford Motor",
-                "AT&T",
-                "Fannie Mae",
-                "CVS Caremark",
-                "McKesson",
-                "Hewlett-Packard",
-                "Verizon Communications",
-                "UnitedHealth Group",
-                "J.P. Morgan Chase & Co.",
-                "Cardinal Health",
-                "International Business Machines",
-                "Bank of America Corp.",
-                "Costco Wholesale",
-                "Kroger",
-                "Express Scripts Holding",
-                "Wells Fargo",
-                "Citigroup",
-                "Archer Daniels Midland",
-                "Procter & Gamble",
-                "Prudential Financial",
-                "Boeing",
-                "Freddie Mac",
-                "AmerisourceBergen",
-                "Marathon Petroleum",
-                "Home Depot",
-                "Microsoft",
-                "Target",
-                "Walgreen",
-                "American International Group",
-                "INTL FCStone",
-                "MetLife",
-                "Johnson & Johnson",
-                "Caterpillar",
-                "PepsiCo",
-                "State Farm Insurance Cos.",
-                "ConocoPhillips",
-                "Comcast",
-                "WellPoint",
-                "Pfizer",
-                "Amazon.com",
-                "United Technologies",
-                "Dell",
-                "Dow Chemical",
-                "United Parcel Service",
-                "Intel",
-                "Google",
-                "Lowe's",
-                "Coca-Cola",
-                "Merck",
-                "Lockheed Martin",
-                "Cisco Systems",
-                "Best Buy",
-                "Safeway",
-                "FedEx",
-                "Enterprise Products Partners",
-                "Sysco",
-                "Walt Disney",
-                "Johnson Controls",
-                "Goldman Sachs Group",
-                "CHS",
-                "Abbott Laboratories",
-                "Sears Holdings",
-                "DuPont",
-                "Humana",
-                "World Fuel Services",
-                "Hess",
-                "Ingram Micro",
-                "Plains All American Pipeline",
-                "Honeywell International",
-                "United Continental Holdings",
-                "Oracle",
-                "Liberty Mutual Insurance Group",
-                "HCA Holdings",
-                "Delta Air Lines",
-                "Aetna",
-                "Deere",
-                "Supervalu",
-                "Sprint Nextel",
-                "Mondelēz International",
-                "New York Life Insurance",
-                "American Express",
-                "News Corp.",
-                "Allstate",
-                "Tyson Foods",
-                "Massachusetts Mutual Life Insurance",
-                "Tesoro",
-                "Morgan Stanley",
-                "TIAA-CREF",
-                "General Dynamics",
-                "Philip Morris International",
-                "Nationwide"
-            };
+            return FileDataRepository.People
+                .Select(person => person.CompanyName)
+                .Distinct()
+                .ToList();
         }
     }
 }