public CartWithNikeShoesScenarioFor()
{
Cart = new CartBuilder()
.WithCustomer(CustomerBuilder.For <T>())
.WithItem(ItemBuilder.For <NikeShoes>())
.Build();
}
public void Plan_Should_Create_A_New_Job()
{
// arrange
CustomerBuilder customerBuilder = new CustomerBuilder();
VehicleBuilder vehicleBuilder = new VehicleBuilder();
MaintenanceJobBuilder maintenanceJobBuilder = new MaintenanceJobBuilder();
Customer customer = customerBuilder
.Build();
Vehicle vehicle = vehicleBuilder
.WithCustomerId(customer.CustomerId)
.Build();
MaintenanceJob sut = maintenanceJobBuilder
.WithCustomer(customer)
.WithVehicle(vehicle)
.Build();
// act
// sut.Plan() is called by the Testdata Builder
// assert
Assert.Equal(maintenanceJobBuilder.Id, sut.Id);
Assert.Equal(maintenanceJobBuilder.StartTime, sut.StartTime);
Assert.Equal(maintenanceJobBuilder.EndTime, sut.EndTime);
Assert.Equal(customer, sut.Customer);
Assert.Equal(vehicle, sut.Vehicle);
Assert.Equal(maintenanceJobBuilder.Description, sut.Description);
Assert.Null(sut.ActualStartTime);
Assert.Null(sut.ActualEndTime);
Assert.Null(sut.Notes);
Assert.Equal("Planned", sut.Status);
}
public void Finish_Should_Finish_An_Existing_Job()
{
// arrange
CustomerBuilder customerBuilder = new CustomerBuilder();
VehicleBuilder vehicleBuilder = new VehicleBuilder();
MaintenanceJobBuilder maintenanceJobBuilder = new MaintenanceJobBuilder();
Customer customer = customerBuilder
.Build();
Vehicle vehicle = vehicleBuilder
.WithCustomerId(customer.CustomerId)
.Build();
MaintenanceJob sut = maintenanceJobBuilder
.WithCustomer(customer)
.WithVehicle(vehicle)
.Build();
DateTime actualStartTime = maintenanceJobBuilder.StartTime.AddMinutes(30);
DateTime actualEndTime = maintenanceJobBuilder.EndTime.AddMinutes(15);
string notes = $"Mechanic notes {maintenanceJobBuilder.Id}";
// act
sut.Finish(actualStartTime, actualEndTime, notes);
// assert
Assert.Equal(maintenanceJobBuilder.Id, sut.Id);
Assert.Equal(maintenanceJobBuilder.StartTime, sut.StartTime);
Assert.Equal(maintenanceJobBuilder.EndTime, sut.EndTime);
Assert.Equal(customer, sut.Customer);
Assert.Equal(vehicle, sut.Vehicle);
Assert.Equal(maintenanceJobBuilder.Description, sut.Description);
Assert.Equal(actualStartTime, sut.ActualStartTime.Value);
Assert.Equal(actualEndTime, sut.ActualEndTime.Value);
Assert.Equal(notes, sut.Notes);
Assert.Equal("Completed", sut.Status);
}
public void GivenNewCustomerDTOWithAllRequiredProperties_WhenCreatingCustomer_ThenCallToCustomerRepositoryWithCustomer()
{
//Given
CustomerDTO customerDTO = new CustomerDTO();
customerDTO.Firstname = "test";
customerDTO.Lastname = "test";
customerDTO.AdressOfCustomer = new Adress(1820, "Perk", "kerkstraat", 5);
customerDTO.Email = "*****@*****.**";
customerDTO.PhoneNumber = "04/72123456";
CustomerBuilder customerbuilder = new CustomerBuilder();
Customer customer =
customerbuilder.WithFirstName("test")
.WithLastname("test")
.WithAddress(
new Adress(1820, "Perk", "kerkstraat", 5))
.WithPhoneNumber("04/721233456")
.WithEmailAdress("*****@*****.**")
.Build();
_customerMapperStub.FromCustomerDTOToCustomer(customerDTO).Returns(customer);
//When
_customerService.CreateNewCustomer(customerDTO);
//Then
_customerRepositoryStub.Received().AddNewCustomer(customer);
}
public async Task ResolveAsync_ShouldCreateCustomer_WhenNonFoundAfterAll_SearchPartyAsyncCalls_Performed()
{
// Arrange
_mockClient.Setup(_ => _.searchForPartyAsync(It.IsAny <FWTPartySearch>()))
.ReturnsAsync(new searchForPartyResponse {
FWTObjectBriefDetailsList = new FWTObjectBriefDetails[0]
});
_mockClient.Setup(_ => _.createIndividualAsync(It.IsAny <FWTIndividual>()))
.ReturnsAsync(new createIndividualResponse {
FLNewIndividualID = new FWTObjectID()
});
var customer = new CustomerBuilder()
.WithForename("forename")
.WithSurname("surname")
.WithEmail("*****@*****.**")
.WithTelephone("12345")
.WithAddress(new Address {
Postcode = "sk11aa", Number = "123"
})
.Build();
// Act
await _service.ResolveAsync(customer);
// Assert
_mockConnection.Verify(_ => _.Client().createIndividualAsync(It.IsAny <FWTIndividual>()), Times.Once);
_mockClient.Verify(_ => _.searchForPartyAsync(It.Is <FWTPartySearch>(x => x.SearchType == "individual" && x.PhoneNumber == "12345")), Times.Exactly(2));
_mockClient.Verify(_ => _.searchForPartyAsync(It.Is <FWTPartySearch>(x => x.SearchType == "individual" && x.EmailAddress == "*****@*****.**")), Times.Exactly(2));
_mockClient.Verify(_ => _.searchForPartyAsync(It.Is <FWTPartySearch>(x => x.SearchType == "individual" && x.AddressNumber == "123" && x.Postcode == "sk11aa")), Times.Exactly(2));
_mockClient.Verify(_ => _.createIndividualAsync(It.IsAny <FWTIndividual>()), Times.Once);
}
public async Task UpdateIndividual_ShouldCallVerintConnection_AndUpdateIndividual()
{
// Arrange
var individual = new FWTIndividual
{
BriefDetails = new FWTObjectBriefDetails
{
ObjectID = new FWTObjectID
{
ObjectReference = new [] { "objRef" },
ObjectType = "objType"
}
}
};
var customer = new CustomerBuilder()
.WithSurname("surname")
.WithForename("forename")
.WithEmail("*****@*****.**")
.Build();
_mockClient
.Setup(_ => _.retrieveIndividualAsync(individual.BriefDetails.ObjectID))
.ReturnsAsync(new retrieveIndividualResponse
{
FWTIndividual = individual
});
// Act
await _service.UpdateIndividual(individual, customer);
// Assert
_mockConnection.Verify(_ => _.Client().updateIndividualAsync(It.IsAny <FWTIndividualUpdate>()), Times.Once);
}
public void SetUp()
{
_customerDt = new CustomerDt();
_companySettings = new SalesSettings();
_mockedCompany = new Mock <ICompany>();
_mockedCustomer = new Mock <ICustomer>();
_mockedCompanySalesTransactions = new Mock <IGetSalesSettings>();
_mockedCustomerRetriever = new Mock <ICustomerRetriever>();
_mockedCompanySalesTransactions.Setup(x => x.Get()).Returns(_companySettings);
_mockedCustomerRetriever.Setup(x => x.GetCustomer(It.IsAny <string>())).Returns(_customerDt);
_mockedCustomerBuilder = new Mock <CustomerBuilder>();
_mockedCustomerBuilder.Setup(x => x.InstantiateCompany(_companySettings)).Returns(_mockedCompany.Object);
_mockedCustomerBuilder.Setup(x => x.InstantiateCustomer(_customerDt, It.IsAny <ICompany>())).Returns(_mockedCustomer.Object);
IKernel kernel = new StandardKernel();
kernel.Bind <IGetSalesSettings>().ToConstant(_mockedCompanySalesTransactions.Object);
kernel.Bind <ICustomerRetriever>().ToConstant(_mockedCustomerRetriever.Object);
NinjectDependencyInjector.Instance.Initialize(kernel);
_customerBuilder = _mockedCustomerBuilder.Object;
}
public void GivenCustomerId_WhenGetCustomerById_ThenCallToCustomerRepositoryWithThisId()
{
//Given
CustomerDTO customerDTO = new CustomerDTO();
customerDTO.Firstname = "test";
customerDTO.Lastname = "test";
customerDTO.AdressOfCustomer = new Adress(1820, "Perk", "kerkstraat", 5);
customerDTO.Email = "*****@*****.**";
customerDTO.PhoneNumber = "04/72123456";
CustomerBuilder customerbuilder = new CustomerBuilder();
Customer customer =
customerbuilder.WithFirstName("test")
.WithLastname("test")
.WithAddress(
new Adress(1820, "Perk", "kerkstraat", 5))
.WithPhoneNumber("04/721233456")
.WithEmailAdress("*****@*****.**")
.Build();
_customerMapperStub.FromCustomerToCustomerDTO(customer).Returns(customerDTO);
_customerRepositoryStub.GetCustomerById(customer.Id).Returns(customer);
//When
_customerService.GetCustomerById(customer.Id);
//Then
_customerRepositoryStub.Received().GetCustomerById(customer.Id);
}
public void UpdatesCustomerAfterAddingIt()
{
// add an Customer
var repository = GetRepository();
var initialTitle = Guid.NewGuid().ToString();
var Customer = new CustomerBuilder().Name(initialTitle).Build();
repository.Add(Customer);
// detach the Customer so we get a different instance
_dbContext.Entry(Customer).State = EntityState.Detached;
// fetch the Customer and update its title
var newCustomer = repository.List <Customer>()
.FirstOrDefault(i => i.Name == initialTitle);
Assert.NotNull(newCustomer);
Assert.NotSame(Customer, newCustomer);
var newName = Guid.NewGuid().ToString();
newCustomer.Name = newName;
// Update the Customer
repository.Update(newCustomer);
var updatedCustomer = repository.List <Customer>()
.FirstOrDefault(i => i.Name == newName);
Assert.NotNull(updatedCustomer);
Assert.NotEqual(Customer.Name, updatedCustomer.Name);
Assert.Equal(newCustomer.Id, updatedCustomer.Id);
}
/// <summary>
/// Tries to switches a member's user account to the one specified. If
/// the account cannot be found or if the account is already associated
/// with an existing member, then create a new user account for the
/// member if allowed. This will also switch the customer account if the
/// user account specified is tied to a different customer account.
/// </summary>
/// <param name="customer"></param>
/// <param name="user"></param>
/// <param name="allowCreate">Allows the creation of a new user account
/// if one cannot be found.</param>
/// <returns></returns>
public static bool UpdateUser(DojoMember member,
GreyFoxUser user)
{
DojoMember existingMember;
RHCustomer customer;
existingMember = GetMember(user);
if (existingMember == null)
{
member.UserAccount = user;
// Update Customer Reference
customer = CustomerBuilder.GetCustomer(user);
if (customer != null)
{
if (member.Customer == null ||
member.Customer.ID != customer.ID)
{
member.Customer = customer;
}
}
return(true);
}
else if (existingMember.ID == member.ID)
{
return(true); // Member is the same;
}
return(false);
}
public void ShouldAddSomeCustomer()
{
CustomerId = Guid.NewGuid();
var model = CustomerBuilder.New().WithId(CustomerId).Build();
var ret = customerWriteOnlyRepository.Add(model);
ret.Should().Be(1);
}
public void Build_creates_anonymous_Employee()
{
Customer customer = new CustomerBuilder().build();
Assert.IsNotNull(customer);
Assert.IsNotNullOrEmpty(customer.FirstName);
Assert.IsNotNullOrEmpty(customer.LastName);
}
public void OrderItem_PriceMinorThenZero_ReturnArgumentException(double invalidPrice)
{
const string errorMessage = "Invalid Price";
var customer = new CustomerBuilder().GetCustomer();
Assert.Throws <ArgumentException>(() => new OrderBuilder().GetOrderWithInvalidPrice(customer, Convert.ToDecimal(invalidPrice))).ValidateMessage(errorMessage);
}
public void OrderItem_AmountEqualOrMinorThenZero_ReturnArgumentException(int invalidAmount)
{
const string errorMessage = "Invalid Amount";
var customer = new CustomerBuilder().GetCustomer();
Assert.Throws <ArgumentException>(() => new OrderBuilder().GetOrderWithInvalidAmount(customer, invalidAmount)).ValidateMessage(errorMessage);
}
public void OrderItem_InvalidItem_ReturnArgumentException(List <OrderItem> invalidItems)
{
const string errorMessage = "The order must have at least 1 item";
var customer = new CustomerBuilder().GetCustomer();
Assert.Throws <ArgumentException>(() => new OrderBuilder().GetOrderWithInvalidItems(customer, invalidItems)).ValidateMessage(errorMessage);
}
public void OrderItem_InvalidProduct_ReturnArgumentException(Product invalidProduct)
{
const string errorMessage = "Invalid Product";
var customer = new CustomerBuilder().GetCustomer();
Assert.Throws <ArgumentException>(() => new OrderBuilder().GetOrderWithInvalidProduct(customer, invalidProduct)).ValidateMessage(errorMessage);
}
public void Deve_Gerar_Csv_Em_Byte_Array()
{
var cutomers = CustomerBuilder.Novo().BuildList();
var byteArray = _exportToCsv.GenerateByteArrayCsvAsync(cutomers).Result;
Assert.True(byteArray.Length > 0);
}
public void Deve_Gerar_Arquivo_Csv()
{
var cutomers = CustomerBuilder.Novo().BuildList();
var tempPathCsv = _exportToCsv.GenerateCsvAsync(cutomers).Result;
Assert.True(File.Exists(tempPathCsv));
}
public void Build_creates_anonymous_Employee()
{
Customer customer = new CustomerBuilder().build();
customer.Should().NotBeNull();
customer.FirstName.Should().NotBeNullOrWhiteSpace();
customer.LastName.Should().NotBeNullOrWhiteSpace();
}
public void Build_creates_anonymous_Employee()
{
Customer customer = new CustomerBuilder().build();
Assert.IsNotNull( customer );
Assert.IsNotNullOrEmpty( customer.FirstName );
Assert.IsNotNullOrEmpty( customer.LastName );
}
public void GivenListOfBuildersWithNoCustomisation_WhenCallingExtensionMethodToBuildList_ThenAListOfUniqueEntitiesShouldBeReturned()
{
var builders = CustomerBuilder.CreateListOfSize(5);
var entities = builders.BuildList();
Assert.That(entities, Is.Unique);
}
public void GivenListOfBuildersWithNoCustomisation_WhenCallingExtensionMethodToBuildList_ThenListOfTheRightTypeShouldBeReturned()
{
var builders = CustomerBuilder.CreateListOfSize(5);
var entities = builders.BuildList();
Assert.That(entities, Has.All.TypeOf <Customer>());
}
public void ShouldUpdateCustomer()
{
var model = customerReadOnlyRepository.GetById(idCustomer);
model.Should().NotBeNull();
var newModel = CustomerBuilder.New().WithId(model.Id).WithName("NewCustomer").Build();
customerWriteOnlyRepository.Update(newModel);
}
public void GivenBuilderIsSetAsProxy_WhenBuilding_AnNSubstituteProxyIsReturned()
{
var builder = new CustomerBuilder().AsProxy();
var proxy = builder.Build();
proxy.CustomerForHowManyYears(Arg.Any<DateTime>()).Returns(100);
proxy.CustomerForHowManyYears(DateTime.Now).ShouldBe(100);
}
public void ShouldAddSomeCustomer()
{
var model = CustomerBuilder.New().Build();
CustomerId = model.Id;
var ret = customerWriteOnlyRepository.Add(model);
ret.Should().Be(1);
}
protected Customer CreateExistingCustomer(BankContext context)
{
City existingCity = CreateExistingCity(context);
Customer existingCustomer = new CustomerBuilder().WithZipCode(existingCity.ZipCode).Build();
context.Set <Customer>().Add(existingCustomer);
context.SaveChanges();
return(existingCustomer);
}
public void CanCreate_ShouldSetProperties()
{
var customer = new CustomerBuilder().WithDefaults().Build();
customer.EmailAddress.Should().Be("*****@*****.**");
customer.FirstName.Should().Be("James");
customer.LastName.Should().Be("Eastham");
customer.Username.Should().Be("jeasthamdev");
}
private void EditFileIfExists(string path)
{
StreamWriter sw = File.CreateText(path);
string customerString = CustomerBuilder.GetCustomerDetails();
Console.WriteLine(customerString);
sw.WriteLine(customerString);
sw.Dispose();
}
public Customer(CustomerBuilder customerBuilder)
: base(customerBuilder.Id)
{
FirstName = customerBuilder.FirstName;
LastName = customerBuilder.LastName;
Email = customerBuilder.Email;
Address = customerBuilder.Address;
PhoneNumber = customerBuilder.PhoneNumber;
}
public void GivenBuilderIsSetAsProxy_WhenBuilding_AnNSubstituteProxyIsReturned()
{
var builder = new CustomerBuilder().AsProxy();
var proxy = builder.Build();
proxy.CustomerForHowManyYears(Arg.Any <DateTime>()).Returns(100);
proxy.CustomerForHowManyYears(DateTime.Now).ShouldBe(100);
}
public void GivenListOfBuildersWithCustomisation_WhenBuildingEntitiesImplicitly_ThenTheCustomisationShouldTakeEffect()
{
var generator = new SequentialGenerator(0, 100);
List <Customer> data = CustomerBuilder.CreateListOfSize(3)
.All().With(b => b.WithFirstName(generator.Generate().ToString()));
data.Select(c => c.FirstName).ToArray()
.ShouldBe(new[] { "0", "1", "2" });
}
public void future_get_by_id_retrieves_selected_record_only_when_it_is_accessed()
{
var newCustomer = new CustomerBuilder().Build();
Session.Save(newCustomer);
FlushAndClear();
var retrievedNewCustomer = Session.QueryOver<Customer>().Where(c => c.Id == newCustomer.Id).FutureValue();
Logger.Info("at this point, the select statement has not been executed yet");
Logger.Info("it will be executed once we try to access the retrieved value");
var id = retrievedNewCustomer.Value.Id;
}
public void session_get_for_existing_entity()
{
var customer = new CustomerBuilder().Build();
Session.Save(customer);
FlushAndClear();
Logger.Info("calling Session.Get will immediately issue the select statement");
Session.Get<Customer>(customer.Id);
Logger.Info("the select statement has been issued, even though we haven't done anything with the customer");
}
public void GivenListOfBuildersWithCustomisation_WhenCallingExtensionMethodToBuildList_ThenTheCustomisationShouldTakeEffect()
{
var generator = new SequentialGenerator <int>();
var list = CustomerBuilder.CreateListOfSize(3)
.All().With(b => b.WithFirstName(generator.Generate().ToString()));
var data = list.BuildList();
Assert.That(data.Select(c => c.FirstName), Is.EqualTo(new[] { "0", "1", "2" }));
}
public void GivenBuilderWithMethodCalls_WhenCallingBuildImplicitly_ThenReturnAnObjectWithTheConfiguredParameters()
{
Customer customer = new CustomerBuilder()
.WithFirstName("Matt")
.WithLastName("Kocaj")
.WhoJoinedIn(2010);
customer.FirstName.ShouldBe("Matt");
customer.LastName.ShouldBe("Kocaj");
customer.YearJoined.ShouldBe(2010);
}
public void GivenBuilder_WhenCallingSetImplicitly_ShouldOverrideValues()
{
Customer customer = new CustomerBuilder()
.Set(x => x.FirstName, "Pi")
.Set(x => x.LastName, "Lanningham")
.Set(x => x.YearJoined, 2014);
customer.FirstName.ShouldBe("Pi");
customer.LastName.ShouldBe("Lanningham");
customer.YearJoined.ShouldBe(2014);
}
public void session_load_of_entity_that_was_already_present_in_session_cache()
{
var customer = new CustomerBuilder().Build();
Session.Save(customer);
FlushAndClear();
var retrievedCustomer = Session.Get<Customer>(customer.Id);
var customerProxy = Session.Load<Customer>(customer.Id);
Assert.AreEqual(retrievedCustomer, customerProxy);
Assert.AreSame(retrievedCustomer, customerProxy);
}
public void attaching_a_transient_object_does_not_hit_the_database_until_the_session_is_flushed()
{
var customer = new CustomerBuilder().Build();
var insertCount = Statistics.EntityInsertCount;
Assert.AreEqual(customer.Id, 0);
Session.Save(customer);
Assert.Greater(customer.Id, 0);
// the ID has been filled in, but the insert hasn't been issued yet
Assert.AreEqual(insertCount, Statistics.EntityInsertCount);
// this will trigger the insert
Session.Flush();
Assert.AreEqual(insertCount + 1, Statistics.EntityInsertCount);
}
public void session_load_for_existing_entity()
{
var customer = new CustomerBuilder().Build();
Session.Save(customer);
FlushAndClear();
var customerProxy = Session.Load<Customer>(customer.Id);
Assert.IsFalse(NHibernateUtil.IsInitialized(customerProxy));
Logger.Info("The select statement hasn't been executed yet, we just have a proxy to our customer");
Logger.Info("Accessing its Id property doesn't trigger a select either");
Logger.Info(string.Format("The Id is: {0}", customerProxy.Id));
Logger.Info("Accessing any other property than the Id will issue the select statement however");
Logger.Info(string.Format("The Name is: {0}", customerProxy.Name));
}
public void proxies_can_be_used_to_set_foreign_keys_without_loading_the_actual_entity()
{
var customer = new CustomerBuilder().Build();
Session.Save(customer);
FlushAndClear();
var customerProxy = Session.Load<Customer>(customer.Id);
Logger.Info("there was no select statement to retrieve the customer");
var order = new OrderBuilder().WithCustomer(customerProxy).Build();
Logger.Info("we can now insert the order without having to retrieve the customer");
Session.Save(order.Employee);
Session.Save(order);
Flush();
}
public void CreateCustomerWithTestDataBuilder()
{
AnonymousValueFixture.GlobalValueSuppliers.Add(new IdValueSupplier());
Customer customer = new CustomerBuilder()
.WithFirstName("Bob")
.WithLastName("Johnson")
.WithAddress((address) => address.WithCity("Olympia")
.WithZipCode("98502"))
.WithOrders(1, (orders) => orders.All()
.WithItems(2, (items) => items.TheFirst(1).WithName("Donut")
.TheNext(1).WithName("Pancake")));
Assert.AreEqual(0, customer.Id); // The Id should be 0 because of the Anonymous value supplier IdValueSupplier
Assert.AreEqual(20, customer.Age); // The Age is set to 20 by the partial class CustomerBuilder in the CustomTestDataBuilders folder
Assert.AreEqual("Bob", customer.FirstName);
Assert.AreEqual("Johnson", customer.LastName);
Assert.AreEqual("Olympia", customer.Address.City);
Assert.AreEqual("98502", customer.Address.ZipCode);
Assert.AreEqual("Donut", customer.Orders.First().Items[0].Name);
Assert.AreEqual("Pancake", customer.Orders.First().Items[1].Name);
}
