public void Generate_IncrementDaysMoreThanMaximumAllowedValue_ThrowsException() { generator.StartingWith(DateTime.MaxValue); generator.IncrementDateBy = IncrementDate.Day; generator.Generate(); Assert.Throws <ArgumentOutOfRangeException>(() => generator.Generate()); }
async Task GivenGroupsInDatabase() { using (var dbContext = new WordkiDbContext(ConnectionStringProvider)) { var user = Builder <Api.Domain.User> .CreateNew() .With(u => u.Id = 1) .With(u => u.Name = "user") .With(u => u.Password = Host.EncrypterMock.Object.Md5Hash("pass")) .With(u => u.LastLoginDate = new DateTime(2020, 1, 1)) .With(u => u.CreationDate = new DateTime(2020, 1, 1)) .Build(); dbContext.Users.Add(user); var sequence = new SequentialGenerator <long> { Direction = GeneratorDirection.Ascending, Increment = 1 }; sequence.StartingWith(1); var builder = Builder <Api.Domain.Group> .CreateNew() .With(g => g.Id = sequence.Generate()) .With(g => g.GroupLanguage1 = 1) .With(g => g.GroupLanguage2 = 2) .With(g => g.Name = "name"); var groups = new Api.Domain.Group[] { builder.Build(), builder.Build() }; dbContext.Groups.AddRange(groups); await dbContext.SaveChangesAsync(); } }
public void UsingSequentialGenerators() { // Arrange var decimalGenerator = new SequentialGenerator <decimal> { Increment = 10, Direction = GeneratorDirection.Descending }; decimalGenerator.StartingWith(2000); var intGenerator = new SequentialGenerator <int> { Increment = 10000 }; // Act var list = new Builder() .CreateListOfSize <Product>(3) .All() .With(x => x.PriceBeforeTax = decimalGenerator.Generate()) .And(x => x.Id = intGenerator.Generate()) .Build(); // Assert list[0].PriceBeforeTax.ShouldBe(2000); list[1].PriceBeforeTax.ShouldBe(1990); list[2].PriceBeforeTax.ShouldBe(1980); list[0].Id.ShouldBe(0); list[1].Id.ShouldBe(10000); list[2].Id.ShouldBe(20000); }
private IEnumerable <Address> MakeFifteenThousandAddress(bool generateIncrementalId) { if (generateIncrementalId) { var generator = new SequentialGenerator <int>(); generator.StartingWith(nextValueToGenerate: 4); return(Builder <Address> .CreateListOfSize(15_000) .All() .With(a => a.Id = GetId(generator)) .With(a => a.Street = "Updated Street") .With(a => a.ZipPostCode = GetZipCode()) .With(a => a.City = GetCity()) .Build()); } return(Builder <Address> .CreateListOfSize(15_000) .All() .With(a => a.Id = 0) .With(a => a.Street = GetStreet()) .With(a => a.ZipPostCode = GetZipCode()) .With(a => a.City = GetCity()) .Build()); }
public override void SetValuesOfAllIn <T>(IList <T> objects) { aisleGenerator.StartingWith('A'); shelfGenerator.StartingWith(2); locGenerator.StartingWith(1000); base.SetValuesOfAllIn(objects); }
public void UsingSequentialGenerators() { var builderSetup = new BuilderSettings(); // Arrange var decimalGenerator = new SequentialGenerator <decimal> { Increment = 10, Direction = GeneratorDirection.Descending }; decimalGenerator.StartingWith(2000); var intGenerator = new SequentialGenerator <int> { Increment = 10000 }; // Act var list = new Builder(builderSetup).CreateListOfSize <Product>(3) .All() .With(x => x.PriceBeforeTax = decimalGenerator.Generate()) .And(x => x.Id = intGenerator.Generate()) .Build(); // Assert Assert.That(list[0].PriceBeforeTax, Is.EqualTo(2000)); Assert.That(list[1].PriceBeforeTax, Is.EqualTo(1990)); Assert.That(list[2].PriceBeforeTax, Is.EqualTo(1980)); Assert.That(list[0].Id, Is.EqualTo(0)); Assert.That(list[1].Id, Is.EqualTo(10000)); Assert.That(list[2].Id, Is.EqualTo(20000)); }
static LocationGenerator() { charGenerator = new SequentialGenerator<char>(); shelfGenerator = new SequentialGenerator<int>(); locGenerator = new SequentialGenerator<int> {Increment = 1000}; charGenerator.StartingWith('A'); shelfGenerator.StartingWith(1); locGenerator.StartingWith(7500); }
static LocationGenerator() { charGenerator = new SequentialGenerator <char>(); shelfGenerator = new SequentialGenerator <int>(); locGenerator = new SequentialGenerator <int> { Increment = 1000 }; charGenerator.StartingWith('A'); shelfGenerator.StartingWith(1); locGenerator.StartingWith(7500); }
public void ShouldBeAbleToUseAChar() { var generator = new SequentialGenerator <char>(); generator.StartingWith('A'); generator.Generate().ShouldBe('A'); generator.Generate().ShouldBe('B'); generator.Generate().ShouldBe('C'); generator.Direction = GeneratorDirection.Descending; generator.Generate().ShouldBe('B'); generator.Generate().ShouldBe('A'); }
public void ShouldBeAbleToUseAChar() { var generator = new SequentialGenerator <char>(); generator.StartingWith('A'); Assert.That(generator.Generate(), Is.EqualTo('A')); Assert.That(generator.Generate(), Is.EqualTo('B')); Assert.That(generator.Generate(), Is.EqualTo('C')); generator.Direction = GeneratorDirection.Descending; Assert.That(generator.Generate(), Is.EqualTo('B')); Assert.That(generator.Generate(), Is.EqualTo('A')); }
private IList <Address> MakeFifteenThousandAddressIlist() { var generator = new SequentialGenerator <int>(); generator.StartingWith(nextValueToGenerate: 4); return(Builder <Address> .CreateListOfSize(15_000) .All() .With(a => a.Id = GetId(generator)) .With(a => a.Street = GetStreet()) .With(a => a.ZipPostCode = GetZipCode()) .With(a => a.City = GetCity()) .Build()); }
private IEnumerable <Address> MakeFiveThousandAddress(int nextIdToGenerate) { var generator = new SequentialGenerator <int>(); generator.StartingWith(nextValueToGenerate: nextIdToGenerate); var address = Builder <Address> .CreateListOfSize(5_000) .All() .With(a => a.Id = GetId(generator)) .With(a => a.Street = "Updated Street") .With(a => a.ZipPostCode = GetZipCode()) .With(a => a.City = GetCity()) .Build(); return(address); }
public IList <Department> GenerateDepartments(int requiredNumber) { SequentialGenerator <int> sequentialGenerator = new SequentialGenerator <int> { Direction = GeneratorDirection.Ascending, Increment = 1 }; sequentialGenerator.StartingWith(1); IList <Department> departments = Builder <Department> .CreateListOfSize(requiredNumber).All().With( x => x.DepartmentNumber = string.Concat("P", sequentialGenerator.Generate())).Build(); return(departments); }
public IList<Department> GenerateDepartments(int requiredNumber) { SequentialGenerator<int> sequentialGenerator = new SequentialGenerator<int> { Direction = GeneratorDirection.Ascending, Increment = 1 }; sequentialGenerator.StartingWith(1); IList<Department> departments = Builder<Department>.CreateListOfSize(requiredNumber).All().With( x => x.DepartmentNumber = string.Concat("P", sequentialGenerator.Generate())).Build(); return departments; }
public static Api.Domain.Card GetCard() { SequentialGenerator <long> generator = new SequentialGenerator <long>() { Increment = 1, Direction = GeneratorDirection.Ascending, }; generator.StartingWith(1); var builder = Builder <Api.Domain.Card> .CreateNew() .With(x => x.Id = generator.Generate()) .With(x => x.Heads = GetSide()) .With(x => x.Tails = GetSide()) .With(x => x.WordCreationDate = Yesterday); return(builder.Build()); }
public void UsingTheSequentialGenerator() { var generator = new SequentialGenerator <int> { Direction = GeneratorDirection.Descending, Increment = 2 }; generator.StartingWith(6); var products = Builder <Product> .CreateListOfSize(3) .All() .With(x => x.Id = generator.Generate()) .Build(); Assert.That(products[0].Id, Is.EqualTo(6)); Assert.That(products[1].Id, Is.EqualTo(4)); Assert.That(products[2].Id, Is.EqualTo(2)); }
public static IEnumerable <Customer> Make(int quantity) { const int nextUnusedAddressIdInDatabase = 4; var generator = new SequentialGenerator <int>(); generator.StartingWith(nextValueToGenerate: nextUnusedAddressIdInDatabase); var customers = Builder <Customer> .CreateListOfSize(quantity) .All() .With(a => a.Id = 0) .With(a => a.Name = Faker.Name.FullName()) .With(a => a.Birthday = Faker.Identification.DateOfBirth()) .With(a => a.Email = Faker.Internet.Email()) .With(a => a.Cpf = GetCpf()) .With(a => a.AddressId = generator.Generate()) .Build(); return(customers); }
public void UsingTheSequentialGenerator() { var builderSetup = new BuilderSettings(); var generator = new SequentialGenerator <int> { Direction = GeneratorDirection.Descending, Increment = 2 }; generator.StartingWith(6); var products = new Builder(builderSetup) .CreateListOfSize <Product>(3) .All() .With(x => x.Id = generator.Generate()) .Build(); products[0].Id.ShouldBe(6); products[1].Id.ShouldBe(4); products[2].Id.ShouldBe(2); }
public void SequentialGenerator_DateTimeGeneration() { const int increment = 2; var dateTimeGenerator = new SequentialGenerator <DateTime> { IncrementDateBy = IncrementDate.Day, IncrementDateValueBy = increment }; var startingDate = DateTime.MinValue; dateTimeGenerator.StartingWith(startingDate); var list = Builder <Product> .CreateListOfSize(2) .All() .With(x => x.Created = dateTimeGenerator.Generate()) .Build(); Assert.That(list[0].Created, Is.EqualTo(startingDate)); Assert.That(list[1].Created, Is.EqualTo(startingDate.AddDays(increment))); }
public void SequentialGenerator_DateTimeGeneration() { var builderSetup = new BuilderSettings(); const int increment = 2; var dateTimeGenerator = new SequentialGenerator <DateTime> { IncrementDateBy = IncrementDate.Day, IncrementDateValueBy = increment }; var startingDate = DateTime.MinValue; dateTimeGenerator.StartingWith(startingDate); var list = new Builder(builderSetup).CreateListOfSize <Product>(2) .All() .With(x => x.Created = dateTimeGenerator.Generate()) .Build(); list[0].Created.ShouldBe(startingDate); list[1].Created.ShouldBe(startingDate.AddDays(increment)); }
public void UsingTheSequentialGenerator() { var generator = new SequentialGenerator<int> { Direction = GeneratorDirection.Descending, Increment = 2 }; generator.StartingWith(6); var products = Builder<Product> .CreateListOfSize(3) .All() .With(x => x.Id = generator.Generate()) .Build(); Assert.That(products[0].Id, Is.EqualTo(6)); Assert.That(products[1].Id, Is.EqualTo(4)); Assert.That(products[2].Id, Is.EqualTo(2)); }
public void SetUp() { generator = new SequentialGenerator <DateTime>(); startingValue = new DateTime(9, 9, 9, 9, 9, 9, 9); generator.StartingWith(startingValue); }
public void SetUp() { generator = new SequentialGenerator<DateTime>(); startingValue = new DateTime(9, 9, 9, 9, 9, 9, 9); generator.StartingWith(startingValue); }
public SequentialGeneratorDateTimeTests() { generator = new SequentialGenerator <DateTime>(); startingValue = new DateTime(9, 9, 9, 9, 9, 9, 9); generator.StartingWith(startingValue); }
public void ShouldBeAbleToUseAChar() { var generator = new SequentialGenerator<char>(); generator.StartingWith('A'); Assert.That(generator.Generate(), Is.EqualTo('A')); Assert.That(generator.Generate(), Is.EqualTo('B')); Assert.That(generator.Generate(), Is.EqualTo('C')); generator.Direction = GeneratorDirection.Descending; Assert.That(generator.Generate(), Is.EqualTo('B')); Assert.That(generator.Generate(), Is.EqualTo('A')); }
public void SequentialGenerator_DateTimeGeneration() { const int increment = 2; var dateTimeGenerator = new SequentialGenerator<DateTime> { IncrementDateBy = IncrementDate.Day, IncrementDateValueBy = increment }; var startingDate = DateTime.MinValue; dateTimeGenerator.StartingWith(startingDate); var list = Builder<Product>.CreateListOfSize(2) .All() .With(x => x.Created = dateTimeGenerator.Generate()) .Build(); Assert.That(list[0].Created, Is.EqualTo(startingDate)); Assert.That(list[1].Created, Is.EqualTo(startingDate.AddDays(increment))); }
public void UsingSequentialGenerators() { // Arrange var decimalGenerator = new SequentialGenerator<decimal> { Increment = 10, Direction = GeneratorDirection.Descending }; decimalGenerator.StartingWith(2000); var intGenerator = new SequentialGenerator<int> { Increment = 10000 }; // Act var list = Builder<Product>.CreateListOfSize(3) .All() .With(x => x.PriceBeforeTax = decimalGenerator.Generate()) .And(x => x.Id = intGenerator.Generate()) .Build(); // Assert Assert.That(list[0].PriceBeforeTax, Is.EqualTo(2000)); Assert.That(list[1].PriceBeforeTax, Is.EqualTo(1990)); Assert.That(list[2].PriceBeforeTax, Is.EqualTo(1980)); Assert.That(list[0].Id, Is.EqualTo(0)); Assert.That(list[1].Id, Is.EqualTo(10000)); Assert.That(list[2].Id, Is.EqualTo(20000)); }