public async Task ApplyChanges_Should_Set_Graph_States()
{
// Arrange
ITrackableRepository <Order> ordersRepo = new TrackableRepository <Order>(_fixture.Context);
var order = await ordersRepo.FindAsync(1);
ordersRepo.DetachEntities(order);
order.OrderDetails[0].TrackingState = TrackingState.Unchanged;
order.OrderDetails[1].TrackingState = TrackingState.Modified;
order.OrderDetails[2].TrackingState = TrackingState.Deleted;
var addedDetail = new OrderDetail
{
OrderDetailId = 4,
OrderId = 1,
ProductId = 3,
Product = order.OrderDetails[2].Product,
UnitPrice = 40,
Quantity = 400,
TrackingState = TrackingState.Added
};
order.OrderDetails.Add(addedDetail);
// Act
ordersRepo.ApplyChanges(order);
// Assert
Assert.Equal(EntityState.Unchanged, _fixture.Context.Entry(order).State);
Assert.Equal(EntityState.Unchanged, _fixture.Context.Entry(order.OrderDetails[0]).State);
Assert.Equal(EntityState.Modified, _fixture.Context.Entry(order.OrderDetails[1]).State);
Assert.Equal(EntityState.Deleted, _fixture.Context.Entry(order.OrderDetails[2]).State);
Assert.Equal(EntityState.Added, _fixture.Context.Entry(order.OrderDetails[3]).State);
}
public async Task Insert_Should_Create_Customer()
{
// Arrange
IUnitOfWork unitOfWork = new UnitOfWork(_fixture.Context);
var customerRepository = new TrackableRepository <Customer>(_fixture.Context);
var customerDomainService = new CustomerDomainService(customerRepository, _mapper);
const string customerId = "COMP1";
const string companyName = "Company 1";
var customer = new CustomerDomainModel
{
CustomerId = customerId,
CompanyName = companyName
};
// Act
customerDomainService.Insert(customer);
var savedChanges = await unitOfWork.SaveChangesAsync();
// Assert
Assert.Equal(1, savedChanges);
var newCustomer = await customerRepository.FindAsync(customerId);
Assert.Equal(newCustomer.CustomerId, customerId);
Assert.Equal(newCustomer.CompanyName, companyName);
}
public async Task CustomerSelectQueryObject()
{
var customerSelect = new CustomerQuery().WithfilterName("Alfreds");
ITrackableRepository <Customer> customerRepository = new TrackableRepository <Customer>(_fixture.Context);
var count = await customerRepository.Query(customerSelect).CountAsync();
var page = await customerRepository.Query(customerSelect).Skip(0).Take(10).SelectAsync();
Assert.Equal(1, count);
}
public async Task DeleteAsync_Should_Set_Entity_State_to_Deleted()
{
// Arrange
ITrackableRepository <Product> productsRepo = new TrackableRepository <Product>(_fixture.Context);
var product = await productsRepo.FindAsync(1);
// Act
await productsRepo.DeleteAsync(1);
// Assert
Assert.Equal(TrackingState.Deleted, product.TrackingState);
}
public async Task CustomerOrderTotalByYear_Should_Return_Order_Total()
{
// Arrange
ITrackableRepository <Customer> customerRepository = new TrackableRepository <Customer>(_fixture.Context);
ITrackableRepository <Order> orderRepository = new TrackableRepository <Order>(_fixture.Context);
var customerService = new CustomerService(customerRepository, orderRepository);
// Act
var customerOrderTotalByYear = await customerService.CustomerOrderTotalByYear("ALFKI", 1998);
// Assert
Assert.Equal(2302.2000m, customerOrderTotalByYear);
}
public void Update_Should_Set_Entity_State_to_Modified()
{
// Arrange
ITrackableRepository <Product> productsRepo = new TrackableRepository <Product>(_fixture.Context);
var product = new Product {
ProductId = 4, ProductName = "Product 4", UnitPrice = 40, CategoryId = 1
};
// Act
productsRepo.Update(product);
// Assert
Assert.Equal(TrackingState.Modified, product.TrackingState);
}
public void Insert_Should_Set_Entity_State_to_Added()
{
// Arrange
ITrackableRepository <Product> productsRepo = new TrackableRepository <Product>(_fixture.Context);
var product = new Product {
ProductId = 80, ProductName = "Product 80", UnitPrice = 40, CategoryId = 1
};
// Act
productsRepo.Insert(product);
// Assert
Assert.Equal(TrackingState.Added, product.TrackingState);
}
public async Task CustomersByCompany_Should_Return_Customer()
{
// Arrange
var customerRepository = new TrackableRepository <Customer>(_fixture.Context);
var customerDomainService = new CustomerDomainService(customerRepository, _mapper);
const string company = "Alfreds Futterkiste";
// Act
var customers = await customerDomainService.CustomersByCompany(company);
// Assert
Assert.Collection(customers, customer
=> Assert.Equal("ALFKI", customer.CustomerId));
}
public async Task SelectAsync_Should_Return_DomainModels()
{
// Arrange
var repository = new TrackableRepository <Customer>(_fixture.Context);
var customerService = new CustomerDomainService(repository, _mapper);
// Act
var customers = await customerService.SelectAsyncCustomers();
var enumerable = customers as CustomerDomainModel[] ?? customers.ToArray();
// Assert
Assert.Equal(90, enumerable.Length);
}
public async Task ApplyChanges_Should_Set_Graph_States()
{
// Arrange
ITrackableRepository <Order> ordersRepo = new TrackableRepository <Order>(_fixture.Context);
var order = await ordersRepo.FindAsync(10248);
ordersRepo.DetachEntities(order);
// updating object in complex object graph
order.OrderDetails[0].UnitPrice = 17;
order.OrderDetails[0].TrackingState = TrackingState.Modified;
// updating object in complex object graph
order.OrderDetails[1].Quantity = 2;
order.OrderDetails[1].TrackingState = TrackingState.Modified;
// deleting object in complex object graph
order.OrderDetails[2].TrackingState = TrackingState.Deleted;
// adding object in complex object graph
var addedDetail = new OrderDetail
{
//OrderDetailId = 4,
OrderId = 1,
ProductId = 3,
Product = order.OrderDetails[2].Product,
UnitPrice = 40,
Quantity = 400,
TrackingState = TrackingState.Added
};
// Act
order.OrderDetails.Add(addedDetail);
// Act
ordersRepo.ApplyChanges(order);
// Assert
Assert.Equal(EntityState.Unchanged, _fixture.Context.Entry(order).State);
Assert.Equal(EntityState.Modified, _fixture.Context.Entry(order.OrderDetails[0]).State);
Assert.Equal(EntityState.Modified, _fixture.Context.Entry(order.OrderDetails[1]).State);
Assert.Equal(EntityState.Deleted, _fixture.Context.Entry(order.OrderDetails[2]).State);
Assert.Equal(EntityState.Added, _fixture.Context.Entry(order.OrderDetails[3]).State);
// Save changes to object graph with different TrackingStates throughout the object graph
await _unitOfWork.SaveChangesAsync();
}
public async Task QueryableSql_Should_Return_Customer_Query()
{
// Arrange
var customerRepository = new TrackableRepository <Customer>(_fixture.Context);
var customerDomainService = new CustomerDomainService(customerRepository, _mapper);
const string companyName = "Alfreds Futterkiste";
// Act
var query = customerDomainService.QueryableSql("SELECT * FROM Customers");
var customers = await query
.Where(x => x.CompanyName.Contains(companyName))
.ToListAsync();
// Assert
Assert.Collection(customers, customer
=> Assert.Equal("ALFKI", customer.CustomerId));
}
public async Task ExistsAsync_Should_Return_False(bool useKey)
{
// Arrange
var customerRepository = new TrackableRepository <Customer>(_fixture.Context);
var customerService = new CustomerDomainService(customerRepository, _mapper);
// Act
bool result;
if (useKey)
{
result = await customerService.ExistsAsync("TEST");
}
else
{
result = await customerService.ExistsAsync(new object[] { "TEST" });
}
// Assert
Assert.False(result);
}
public async Task FindAsync_Should_Return_DomainModel(bool useKey)
{
// Arrange
var customerRepository = new TrackableRepository <Customer>(_fixture.Context);
var customerService = new CustomerDomainService(customerRepository, _mapper);
var customerDomainModel = new CustomerDomainModel();
// Act
if (useKey)
{
customerDomainModel = await customerService.FindAsync("ALFKI");
}
else
{
customerDomainModel = await customerService.FindAsync(new object[] { "ALFKI" });
}
// Assert
Assert.Equal("ALFKI", customerDomainModel.CustomerId);
Assert.NotNull(customerDomainModel);
}
public async Task Update_Should_Update_Customer()
{
// Arrange
IUnitOfWork unitOfWork = new UnitOfWork(_fixture.Context);
var customerRepository = new TrackableRepository <Customer>(_fixture.Context);
var customerDomainService = new CustomerDomainService(customerRepository, _mapper);
const string customerId = "BERGS";
const string companyName = "Eastern Connection 1";
var data = await customerRepository.FindAsync(customerId);
customerRepository.Detach(data);
var customerDomainModel = new CustomerDomainModel
{
CustomerId = data.CustomerId,
CompanyName = companyName,
ContactName = data.ContactName,
ContactTitle = data.ContactTitle,
Address = data.Address,
City = data.City,
Region = data.Region,
PostalCode = data.PostalCode,
Country = data.Country,
Phone = data.Phone,
Fax = data.Fax
};
// Act
customerDomainService.Update(customerDomainModel);
var savedChanges = await unitOfWork.SaveChangesAsync();
// Assert
Assert.Equal(1, savedChanges);
var updatedCustomer = await customerRepository.FindAsync(customerId);
Assert.Equal(data.Address, updatedCustomer.Address);
Assert.Equal(customerDomainModel.CompanyName, companyName);
}
public async Task Service_Insert_Should_Insert_Into_Database()
{
// Arrange
IUnitOfWork unitOfWork = new UnitOfWork(_fixture.Context);
ITrackableRepository <Customer> customerRepository = new TrackableRepository <Customer>(_fixture.Context);
ITrackableRepository <Order> orderRepository = new TrackableRepository <Order>(_fixture.Context);
var customerService = new CustomerService(customerRepository, orderRepository);
const string customerId = "COMP1";
const string companyName = "Company 1";
var customer = new Customer
{
CustomerId = customerId,
CompanyName = companyName
};
// Act
customerService.Insert(customer);
// Assert
Assert.Equal(TrackableEntities.Common.Core.TrackingState.Added, customer.TrackingState);
// Act
var savedChanges = await unitOfWork.SaveChangesAsync();
// Assert
Assert.Equal(1, savedChanges);
// Act
var newCustomer = await customerRepository.FindAsync(customerId);
// Assert
Assert.Equal(newCustomer.CustomerId, customerId);
Assert.Equal(newCustomer.CompanyName, companyName);
}
public async Task Queryable_Should_Allow_Composition()
{
// Arrange
var comparer = new MyProductComparer();
var expected1 = new MyProduct {
Id = 1, Name = "Chai", Price = 18.00m, Category = "Beverages"
};
var expected2 = new MyProduct {
Id = 2, Name = "Chang", Price = 19.00m, Category = "Beverages"
};
var repository = new TrackableRepository <Product>(_fixture.Context);
var productDomainService = new ProductDomainService(repository, _mapper);
// Act
var query = productDomainService.Queryable();
var products = await query
.Include(p => p.Category)
.Take(2)
.Where(p => p.UnitPrice > 15)
.Select(p => new MyProduct
{
Id = p.ProductId,
Name = p.ProductName,
Price = p.UnitPrice,
Category = p.Category.CategoryName
})
.ToListAsync();
// Assert
Assert.Collection(products,
p => Assert.Equal(expected1, p, comparer),
p => Assert.Equal(expected2, p, comparer));
}