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));
}
