public async Task when_updated_customer_it_should_be_updated_correctly_in_the_db()
{
ICustomerRepository _customerRepository = new CustomerRepository(_dbContextConfig.CompanyContext);
var customer1 = new Customer("Justyna", "Stanczyk", "+48662622117");
customer1.AddAddress(new CustomerAddress("190", "108", "Wadowica", "Kraków", "31-416"));
var customer2 = new Customer("Karol", "Cichon", "+48504400336");
customer2.AddAddress(new CustomerAddress("117", "06", "Krakowska", "Limanowa", "31-416"));
await _customerRepository.AddAsync(customer1);
await _customerRepository.AddAsync(customer2);
var existingCustomer = await _customerRepository.GetByPhoneNumberAsync(customer1.TelephoneNumber);
var existingCustomerWithAddress = await _customerRepository.GetWithAddressAsync(existingCustomer.Id);
existingCustomerWithAddress.Update(existingCustomerWithAddress.Name, "Cichon", existingCustomerWithAddress.TelephoneNumber);
existingCustomerWithAddress.CustomerAddress.Update("27", "28", "Krakowska", "Kraków", existingCustomerWithAddress.CustomerAddress.ZipCode);
// // await _customerRepository.UpdateAsync (existingCustomerWithAddress);
// var updatedCustomerWithAddress = await _customerRepository.GetWithAddressAsync (existingCustomerWithAddress.Id);
// // Assert.Equal (existingCustomerWithAddress, updatedCustomerWithAddress);
// Assert.Equal (customer2, existingCustomerWithAddress);
customer1.ShouldBeEquivalentTo(existingCustomer);
}
public async Task UpdatesCustomerOrderStatusToPaidAfterTheReceivingOfOrderPaidNotification()
{
//Arrange
var customerRepository = new CustomerRepository(_dbContext);
var suitAlterationRepository = new SuitAlterationRepository(_dbContext);
var customer = CreateNewCustomer();
await customerRepository.AddAsync(customer);
customer.PlaceOrder(5, 5, 5, 5);
await _unitOfWork.CommitAsync(CancellationToken.None);
//Pre-assert
var order = customer.SuitAlterations.Single();
order.Status.Should().Be(SuitAlterationStatus.Created);
//Act
var markOrderAsPaidCommandHandler = new MarkOrderAsPaidCommandHandler(suitAlterationRepository);
await markOrderAsPaidCommandHandler.Handle(new MarkOrderAsPaidCommand(order.Id), CancellationToken.None);
await _unitOfWork.CommitAsync(CancellationToken.None);
//Assert
SuitAlteration paidOrder = await suitAlterationRepository.GetByIdAsync(order.Id);
order.DomainEvents.Should().ContainEquivalentOf(new OrderPaidDomainEvent(order.Id));
paidOrder.Status.Should().Be(SuitAlterationStatus.Paid);
order.DomainEvents.Count.Should().Be(2);
}
public async Task EnsureInvoiceCreated()
{
var model = new InvoiceModelBuilder().Default;
using (var ctx = CreateContext())
{
var repo = new CustomerRepository(ctx);
var customer = Mapper.Map <Customer>(new CustomerModelBuilder().Default);
await repo.AddAsync(customer);
var first = ctx.Customers.First();
model.CustomerId = first.Id;
var invoiceRepository = new InvoiceRepository(ctx);
await invoiceRepository.AddAsync(Mapper.Map <Invoice>(model));
}
using (var ctx = CreateContext())
{
var repo = new CustomerRepository(ctx);
var customer = await repo.GetAsync(model.CustomerId);
var invoices = customer.Invoices;
invoices.Count.ShouldBe(1);
}
}
public async Task ThrowsExceptionWhenOrderStatusIsPaidAndWeTriesToSetTheSameStatusAgain()
{
//Arrange
var customerRepository = new CustomerRepository(_dbContext);
var suitAlterationRepository = new SuitAlterationRepository(_dbContext);
var customer = CreateNewCustomer();
await customerRepository.AddAsync(customer);
customer.PlaceOrder(5, 5, 5, 5);
await _unitOfWork.CommitAsync(CancellationToken.None);
//Act
var order = customer.SuitAlterations.Single();
var markOrderAsPaidCommandHandler = new MarkOrderAsPaidCommandHandler(suitAlterationRepository);
await markOrderAsPaidCommandHandler.Handle(new MarkOrderAsPaidCommand(order.Id), CancellationToken.None);
await _unitOfWork.CommitAsync(CancellationToken.None);
//Pre-assert
order.DomainEvents.Should().ContainEquivalentOf(new OrderPaidDomainEvent(order.Id));
//imagine that we got OrderPaidNotification second time
Func <Task> action = async() => await markOrderAsPaidCommandHandler.Handle(new MarkOrderAsPaidCommand(order.Id), CancellationToken.None);
//Assert
action.Should().Throw <BusinessRuleValidationException>().WithMessage(
$"Order has inconsistent status to be marked as paid. Status - {order.Status.ToString()}");
order.DomainEvents.Count.Should().Be(2);
}
public async Task EnsureCustomerDeleted()
{
Customer customer;
var model = new CustomerModelBuilder().Default;
using (var ctx = CreateContext())
{
var repo = new CustomerRepository(ctx);
var entity = Mapper.Map <Customer>(model);
await repo.AddAsync(entity);
var all = await repo.GetAllAsync();
customer = all.First();
await repo.DeleteAsync(customer.Id);
}
using (var ctx = CreateContext())
{
var repo = new CustomerRepository(ctx);
var found = await repo.GetAsync(customer.Id);
found.ShouldBeNull();
}
}
public async Task EnsureCustomerUpdated()
{
var model = new CustomerModelBuilder().Default;
CustomerModel toUpdate;
using (var ctx = CreateContext())
{
var repo = new CustomerRepository(ctx);
var entity = Mapper.Map <Customer>(model);
await repo.AddAsync(entity);
var all = await repo.GetAllAsync();
var customer = all.First();
toUpdate = Mapper.Map <CustomerModel>(customer);
toUpdate.Lastname = "Updated";
toUpdate.Address.Street = "AlsoUpdated";
var updated = Mapper.Map <Customer>(toUpdate);
await repo.UpdateAsync(updated.Id, updated);
}
using (var ctx = CreateContext())
{
var repo = new CustomerRepository(ctx);
var all = await repo.GetAllAsync();
var customer = all.First();
CheckCustomer(customer, toUpdate);
}
}
public async Task EnsureSearchOnAllCriteria()
{
var model = new CustomerModelBuilder().Default;
using (var ctx = CreateContext())
{
ctx.Customers.RemoveRange(ctx.Customers);
await ctx.SaveChangesAsync();
var repo = new CustomerRepository(ctx);
var customer = Mapper.Map <Customer>(model);
await repo.AddAsync(customer);
}
await EnsureSearch(model.Lastname);
await EnsureSearch(model.Firstname);
await EnsureSearch($"{model.Firstname} {model.Lastname}");
await EnsureSearch($"{model.Lastname} {model.Firstname}");
await EnsureSearch(model.VatNumber);
await EnsureSearch(model.Telephone);
await EnsureSearch(model.Address.Street);
await EnsureSearch($"{model.Address.Street} {model.Address.Number}");
await EnsureSearch(model.Address.PostalCode);
await EnsureSearch(model.Address.City);
}
public async Task WhenWeAskToAddACustomer_ShouldBeAskedToStoreInCosmosDB()
{
var newCustomer = DomainGenerator.CustomerGenerator().Generate();
var updatedCustomer = await _sut.AddAsync(newCustomer);
await _genericRepo.Received().CreateAsync(Arg.Any <Customer>());
}
public async Task <IActionResult> Create(CustomerDTO customerDTO)
{
Customer customer = new Customer();
_mapper.Map(customerDTO, customer);
await customerRepository.AddAsync(customer);
return(Ok(customer.Id));
}
public async Task when_adding_new_customer_it_should_be_added_correctly_to_the_db()
{
ICustomerRepository _customerRepository = new CustomerRepository(_dbContextConfig.CompanyContext);
var customer = new Customer("Karol", "Cichon", "+48504400336");
customer.AddAddress(new CustomerAddress("27", "28", "Krakowska", "Kraków", "31-416"));
await _customerRepository.AddAsync(customer);
var existingCustomer = await _customerRepository.GetByPhoneNumberAsync(customer.TelephoneNumber);
Assert.Equal(customer, existingCustomer);
}
public async Task added_customer_should_be_removed_correctly_in_the_db()
{
ICustomerRepository _customerRepository = new CustomerRepository(_dbContextConfig.CompanyContext);
var customer = new Customer("Jan", "Kowalski", "+48123456789");
customer.AddAddress(new CustomerAddress("1", "2", "Krotka", "Kraków", "31-416"));
await _customerRepository.AddAsync(customer);
var existingCustomer = await _customerRepository.GetByPhoneNumberAsync(customer.TelephoneNumber);
await _customerRepository.DeleteAsync(existingCustomer);
var removedCustomer = await _customerRepository.GetAsync(existingCustomer.Id);
Assert.Equal(null, removedCustomer);
}
public async Task GetsExpectedSuitAlterationByCustomerId()
{
//Arrange
var suitAlterationRepository = new SuitAlterationRepository(_dbContext);
var customerRepository = new CustomerRepository(_dbContext);
var expectedCustomer = await RegisterCustomer();
expectedCustomer.PlaceOrder(5, 5, 5, 5);
var anotherCustomer = await RegisterCustomer();
anotherCustomer.PlaceOrder(1, 1, 1, 1);
await _unitOfWork.CommitAsync(CancellationToken.None);
var expectedOrder = expectedCustomer.SuitAlterations.Single();
SuitAlterationDto expectedCustomerSuitAlteration = null;
_mapperMock.Setup(x => x.Map <SuitAlterationDto>(expectedOrder))
.Returns((SuitAlteration suitAlteration) =>
{
expectedCustomerSuitAlteration = new SuitAlterationDto()
{
Id = suitAlteration.Id.Value
};
return(expectedCustomerSuitAlteration);
});
//Act
var customerOrdersQueryHandler = new GetCustomerSuitAlterationsQueryHandler(suitAlterationRepository, _mapperMock.Object);
IReadOnlyList <SuitAlterationDto> customerSuitAlterations =
await customerOrdersQueryHandler.Handle(new GetCustomerSuitAlterationsQuery(expectedCustomer.Id.Value), CancellationToken.None);
//Assert
customerSuitAlterations.Should().ContainSingle().Which.Id.Should().Be(expectedCustomerSuitAlteration.Id);
async Task <Customer> RegisterCustomer()
{
var customer = CreateNewCustomer();
await customerRepository.AddAsync(customer);
return(customer);
}
}
public async Task EnsureCustomerCreated()
{
var model = new CustomerModelBuilder().Default;
using (var ctx = CreateContext())
{
var repo = new CustomerRepository(ctx);
var customer = Mapper.Map <Customer>(model);
await repo.AddAsync(customer);
}
using (var ctx = CreateContext())
{
var repo = new CustomerRepository(ctx);
var all = await repo.GetAllAsync();
var customer = all.First();
CheckCustomer(customer, model);
}
}
public async Task SuccessfullyPlacesCustomerOrderForNewSuitAlteration()
{
//Arrange
var customerRepository = new CustomerRepository(_dbContext);
var customer = CreateNewCustomer();
await customerRepository.AddAsync(customer);
await _unitOfWork.CommitAsync(CancellationToken.None);
var suitAlterationRepository = new SuitAlterationRepository(_dbContext);
var customerOrders = await LoadCustomerOrders();
//Pre-assert
customerOrders.Should().BeEmpty();
//Act
var placeCustomerOrderCommandHandler = new PlaceCustomerOrderCommandHandler(customerRepository);
await placeCustomerOrderCommandHandler.Handle(new PlaceCustomerOrderCommand(5,
5,
5,
5,
customer.Id.Value), CancellationToken.None);
await _unitOfWork.CommitAsync(CancellationToken.None);
//Assert
customerOrders = await LoadCustomerOrders();
customerOrders.Should().ContainSingle();
var createdOrder = customerOrders.Single();
createdOrder.DomainEvents.Should().ContainSingle().And.BeEquivalentTo(new OrderPlacedDomainEvent(createdOrder.Id));
createdOrder.Status.Should().Be(SuitAlterationStatus.Created);
customer.SuitAlterations.Should().Contain(createdOrder);
async Task <IReadOnlyList <SuitAlteration> > LoadCustomerOrders()
{
return(await suitAlterationRepository.GetByCustomerIdAsync(customer.Id));
}
}
public async Task InitDemoDataAsync()
{
var brands = await BrandRepository.GetAllAsync();
if (brands.Any())
{
return; // already initialized
}
var brandA = new CarBrand
{
Title = "Audi"
};
var brandB = new CarBrand
{
Title = "BMW"
};
var brandC = new CarBrand
{
Title = "Fiat"
};
brandA = await BrandRepository.AddAsync(brandA);
brandB = await BrandRepository.AddAsync(brandB);
brandC = await BrandRepository.AddAsync(brandC);
var classA = new CarClass
{
Title = "Cheap",
Cost = 102.20M
};
var classB = new CarClass
{
Title = "Midlevel",
Cost = 180.50M
};
var classC = new CarClass
{
Title = "Highend",
Cost = 250.99M
};
classA = await ClassRepository.AddAsync(classA);
classB = await ClassRepository.AddAsync(classB);
classC = await ClassRepository.AddAsync(classC);
var typeA = new CarType
{
Title = "PKW"
};
var typeB = new CarType
{
Title = "Limousine"
};
var typeC = new CarType
{
Title = "Coupé"
};
typeA = await TypeRepository.AddAsync(typeA);
typeB = await TypeRepository.AddAsync(typeB);
typeC = await TypeRepository.AddAsync(typeC);
var customerA = new Customer
{
FirstName = "Peter",
LastName = "Müller",
Address = "Mordorweg 4, 8355 Gondor",
EMail = "*****@*****.**",
PhoneNumber = "79 546 65 65"
};
var customerB = new Customer
{
FirstName = "Maria",
LastName = "Meier",
Address = "Rohangasse 23, 5564 Auenland",
EMail = "*****@*****.**",
PhoneNumber = "76 215 54 64"
};
var customerC = new Customer
{
FirstName = "Bruno",
LastName = "Gander",
Address = "Isengardweg 3, 5445 Helmsklamm",
EMail = "*****@*****.**",
PhoneNumber = "76 651 12 35"
};
customerA = await CustomerRepository.AddAsync(customerA);
customerB = await CustomerRepository.AddAsync(customerB);
customerC = await CustomerRepository.AddAsync(customerC);
var carA = new Car
{
BrandId = brandA.Id,
ClassId = classA.Id,
HorsePower = 112,
Kilometers = 216535,
RegistrationYear = 2000,
TypeId = typeA.Id
};
var carB = new Car
{
BrandId = brandB.Id,
ClassId = classB.Id,
HorsePower = 212,
Kilometers = 116535,
RegistrationYear = 2010,
TypeId = typeB.Id
};
var carC = new Car
{
BrandId = brandC.Id,
ClassId = classC.Id,
HorsePower = 312,
Kilometers = 16535,
RegistrationYear = 2018,
TypeId = typeC.Id
};
carA = await CarRepository.AddAsync(carA);
carB = await CarRepository.AddAsync(carB);
carC = await CarRepository.AddAsync(carC);
var reservationA = new Reservation
{
CarId = carA.Id,
CustomerId = customerA.Id,
Days = 12,
RentalDate = DateTime.Now.AddDays(12),
ReservationDate = DateTime.Now,
State = ReservationState.Pending
};
var reservationB = new Reservation
{
CustomerId = customerB.Id,
CarId = carB.Id,
Days = 2,
RentalDate = DateTime.Now.AddDays(1),
ReservationDate = DateTime.Now.AddDays(-3),
State = ReservationState.Reserved
};
var reservationC = new Reservation
{
CustomerId = customerC.Id,
CarId = carC.Id,
Days = 42,
RentalDate = DateTime.Now.AddDays(-2),
ReservationDate = DateTime.Now.AddDays(-8),
State = ReservationState.Contracted
};
await ReservationRepository.AddAsync(reservationA);
await ReservationRepository.AddAsync(reservationB);
reservationC = await ReservationRepository.AddAsync(reservationC);
var contractA = new RentalContract
{
CarId = carC.Id,
CustomerId = customerC.Id,
Days = 42,
RentalDate = DateTime.Now.AddDays(-2),
ReservationId = reservationC.Id,
TotalCosts = classC.Cost * 42
};
await ContractRepository.AddAsync(contractA);
}
public async Task CustomerRepositoryAsyncAllMethodTest()
{
// DbContextOptions<T> Object Creation
var options = new DbContextOptionsBuilder <DotNetSaleCoreDbContext>()
.UseInMemoryDatabase(databaseName: $"DotNetSaleCore{Guid.NewGuid()}").Options;
//.UseSqlServer("server=(localdb)\\mssqllocaldb;database=DotNetSaleCore;integrated security=true;").Options;
// ILoggerFactory Object Creation
var serviceProvider = new ServiceCollection().AddLogging().BuildServiceProvider();
var factory = serviceProvider.GetService <ILoggerFactory>();
//[1] AddAsync() Method Test
using (var context = new DotNetSaleCoreDbContext(options))
{
// Repository Object Creation
//[!] Arrange
var repository = new CustomerRepository(context, factory);
var model = new Customer {
CustomerName = "[1] 고객이름", Created = DateTime.Now
};
//[!] Act
await repository.AddAsync(model);
await context.SaveChangesAsync();
}
using (var context = new DotNetSaleCoreDbContext(options))
{
//[!] Assert
Assert.AreEqual(1, await context.Customers.CountAsync());
var model = await context.Customers.Where(m => m.CustomerId == 1).SingleOrDefaultAsync();
Assert.AreEqual("[1] 고객이름", model?.CustomerName);
}
//[2] GetAllAsync() Method Test
using (var context = new DotNetSaleCoreDbContext(options))
{
//// 트랜잭션 관련 코드는 InMemoryDatabase 공급자에서는 지원 X
////using (var transaction = context.Database.BeginTransaction()) { transaction.Commit(); }
var repository = new CustomerRepository(context, factory);
var model = new Customer {
CustomerName = "[2] 홍길동", Created = DateTime.Now
};
await context.Customers.AddAsync(model);
await context.SaveChangesAsync(); //[1]
await context.Customers.AddAsync(new Customer { CustomerName = "[3] 백두산", Created = DateTime.Now });
await context.SaveChangesAsync(); //[2]
}
using (var context = new DotNetSaleCoreDbContext(options))
{
var repository = new CustomerRepository(context, factory);
var models = await repository.GetAllAsync();
Assert.AreEqual(3, models.Count);
}
//[3] GetByIdAsync() Method Test
using (var context = new DotNetSaleCoreDbContext(options))
{
// Empty
}
using (var context = new DotNetSaleCoreDbContext(options))
{
var repository = new CustomerRepository(context, factory);
var model = await repository.GetByIdAsync(2);
Assert.IsTrue(model.CustomerName.Contains("길동"));
Assert.AreEqual("[2] 홍길동", model.CustomerName);
}
//[4] GetEditAsync() Method Test
using (var context = new DotNetSaleCoreDbContext(options))
{
// Empty
}
using (var context = new DotNetSaleCoreDbContext(options))
{
var repository = new CustomerRepository(context, factory);
var model = await repository.GetByIdAsync(2);
model.CustomerName = "[2] 임꺽정";
await repository.EditAsync(model);
await context.SaveChangesAsync();
Assert.AreEqual("[2] 임꺽정",
(await context.Customers.Where(m => m.CustomerId == 2).SingleOrDefaultAsync()).CustomerName);
}
//[5] GetDeleteAsync() Method Test
using (var context = new DotNetSaleCoreDbContext(options))
{
// Empty
}
using (var context = new DotNetSaleCoreDbContext(options))
{
var repository = new CustomerRepository(context, factory);
await repository.DeleteAsync(2);
await context.SaveChangesAsync();
Assert.AreEqual(2, await context.Customers.CountAsync());
Assert.IsNull(await repository.GetByIdAsync(2));
}
//[6] PagingAsync() Method Test
using (var context = new DotNetSaleCoreDbContext(options))
{
// Empty
}
using (var context = new DotNetSaleCoreDbContext(options))
{
int pageIndex = 0;
int pageSize = 1;
var repository = new CustomerRepository(context, factory);
var models = await repository.GetAllAsync(pageIndex, pageSize);
Assert.AreEqual("[3] 백두산", models.Records.FirstOrDefault().CustomerName);
Assert.AreEqual(2, models.TotalRecords);
}
}