public void Calling_Get_Changes_Multiple_Times_Should_Be_Possible()
{
// Arrange
var database = new MockNorthwind();
var employee = database.Employees[0];
var changeTracker = new ChangeTrackingCollection <Employee>(employee);
// Delete all territories, so employee.Territories.Count is 0
employee.Territories.Remove(employee.Territories[2]);
var changesA = changeTracker.GetChanges();
employee.Territories.Remove(employee.Territories[1]);
var changesB = changeTracker.GetChanges();
employee.Territories.Remove(employee.Territories[0]);
var changesC = changeTracker.GetChanges();
// Act
var changes = changeTracker.GetChanges();
// Assert
Assert.Equal(0, employee.Territories.Count);
Assert.Equal(3, changes[0].Territories.Count);
Assert.Equal(TrackingState.Deleted, changes[0].Territories[0].TrackingState);
Assert.Equal(TrackingState.Deleted, changes[0].Territories[1].TrackingState);
Assert.Equal(TrackingState.Deleted, changes[0].Territories[2].TrackingState);
}
public void Collection_GetChanges_Should_Add_Only_Added_Modified_Deleted_Children()
{
// Arrange
var parent = new Parent("Parent")
{
Children = new ChangeTrackingCollection <Child>
{
new Child("Child1"),
new Child("Child2"),
new Child("Child3")
}
};
var changeTracker = new ChangeTrackingCollection <Parent>(parent);
parent.Children.Add(new Child("Child4"));
parent.Children[0].Name += "_Changed";
parent.Children.RemoveAt(2);
// Act
var changes = changeTracker.GetChanges();
var changedParent = changes.First();
// Assert
Assert.AreEqual(1, changes.Count);
Assert.AreEqual(3, changedParent.Children.Count);
}
public void MergeChanges_Should_Set_Unchanged_Customer_With_Modified_Setting()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var customer = order.Customer;
customer.CustomerSetting = new CustomerSetting
{
CustomerId = customer.CustomerId,
Customer = customer,
Setting = "Setting1"
};
var changeTracker = new ChangeTrackingCollection <Order>(order);
var setting = customer.CustomerSetting.Setting = "xxx";
var origState = customer.CustomerSetting.TrackingState;
var changes = changeTracker.GetChanges();
var changedCustomer = changes[0].Customer;
var updatedOrder = changes[0].Clone <Order>();
updatedOrder.AcceptChanges();
// Act
changeTracker.MergeChanges(updatedOrder);
// Assert
Assert.Equal(setting, customer.CustomerSetting.Setting); // Changed customer setting is preserved
Assert.Equal(TrackingState.Modified, origState); // Changed state is modified
Assert.Equal(TrackingState.Unchanged, customer.TrackingState); // State set to unchanged
}
public void MergeChanges_Should_Set_Modified_Customer_With_Unchanged_Setting()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var customer = order.Customer;
customer.CustomerSetting = new CustomerSetting
{
CustomerId = customer.CustomerId,
Customer = customer,
Setting = "Setting1"
};
var changeTracker = new ChangeTrackingCollection <Order>(order);
var name = customer.CustomerName = "xxx";
var origState = customer.TrackingState;
var changes = changeTracker.GetChanges();
var changedCustomer = changes[0].Customer;
var updatedOrder = changes[0].Clone <Order>();
updatedOrder.AcceptChanges();
// Act
changeTracker.MergeChanges(updatedOrder);
// Assert
Assert.Equal(name, customer.CustomerName); // Changed customer name is preserved
Assert.Null(changedCustomer.CustomerSetting); // GetChanges sets unchanges ref props to null
Assert.NotNull(order.Customer.CustomerSetting); // Unchanged ref props not overwritten
Assert.Equal(TrackingState.Modified, origState); // Changed state is modified
Assert.Equal(TrackingState.Unchanged, customer.TrackingState); // State set to unchanged
}
public void MergeChanges_Should_Set_Modified_Employee_With_Unchanged_Territories()
{
// Arrange
var database = new MockNorthwind();
var employee = database.Employees[0];
var unchangedterritory = employee.Territories[0];
var modifiedterritory = employee.Territories[1];
var deletedterritory = employee.Territories[2];
var addedExistingTerritory = database.Territories[3];
var addedNewTerritory = new Territory
{
TerritoryId = "91360",
TerritoryDescription = "SouthernCalifornia",
Employees = new ChangeTrackingCollection <Employee> {
employee
}
};
var changeTracker = new ChangeTrackingCollection <Employee>(employee);
var name = employee.LastName = "xxx";
var origState = employee.TrackingState;
var changes = changeTracker.GetChanges();
var changedTerritories = changes[0].Territories;
var updatedEmployee = changes[0].Clone <Employee>();
updatedEmployee.AcceptChanges();
// Act
changeTracker.MergeChanges(updatedEmployee);
// Assert
Assert.Equal(name, employee.LastName); // Changed prop is preserved
Assert.Empty(changedTerritories); // GetChanges sets unchanges ref props to null
Assert.Equal(3, employee.Territories.Count); // Unchanged items preserved
}
static void Main(string[] args)
{
// Main method
Console.WriteLine("Press Enter to start");
Console.ReadLine();
// Create http client
const string serviceBaseAddress = "http://localhost:" + "49640" + "/";
var client = new HttpClient {
BaseAddress = new Uri(serviceBaseAddress)
};
List <Product> products = GetProducts(client).ToList();
foreach (var p in products)
{
PrintProduct(p);
}
// Select individual product
Console.WriteLine("\nProduct to update {ProductId}:");
int productId = int.Parse(Console.ReadLine());
var product = products.Single(p => p.ProductId == productId);
// Track changes
var changeTracker = new ChangeTrackingCollection <Product>(product);
// Update product
product.UnitPrice++;
// Get changes
var changedProduct = changeTracker.GetChanges().SingleOrDefault();
// Submit changes
Product updatedProduct;
if (product is DiscontinuedProduct)
{
updatedProduct = UpdateEntity(client, (DiscontinuedProduct)product);
}
else
{
updatedProduct = UpdateEntity(client, product);
}
// Merge changes
changeTracker.MergeChanges(updatedProduct);
Console.WriteLine("Updated product:");
PrintProduct(product);
// Keep console open
Console.WriteLine("\nPress any key to exit");
Console.ReadKey(true);
}
public void GetChanges_Should_Return_Deleted_Items()
{
// Arrange
var database = new MockNorthwind();
var product = database.Products[0];
var changeTracker = new ChangeTrackingCollection <Product>(product);
changeTracker.Remove(product);
// Act
var changes = changeTracker.GetChanges();
// Assert
Assert.Equal(TrackingState.Deleted, changes.First().TrackingState);
}
public void GetChanges_Should_Return_Modified_Items()
{
// Arrange
var database = new MockNorthwind();
var product = database.Products[0];
var changeTracker = new ChangeTrackingCollection <Product>(product);
product.UnitPrice++;
// Act
var changes = changeTracker.GetChanges();
// Assert
Assert.AreEqual(TrackingState.Modified, changes.First().TrackingState);
}
public void MergeChanges_Should_Merge_Updates_For_Unchanged_Order_With_Changed_OrderDetails()
{
// Arrange
var database = new MockNorthwind();
var origOrder = database.Orders[0];
var product = database.Products.Single(p => p.ProductId == 14);
origOrder.OrderDetails.Add(new OrderDetail {
ProductId = 14, OrderId = 10249, Quantity = 9, UnitPrice = 18.6000M, Product = product
});
var unchangedDetail = origOrder.OrderDetails[0];
var modifiedDetail = origOrder.OrderDetails[1];
var deletedDetail = origOrder.OrderDetails[3];
var changeTracker = new ChangeTrackingCollection <Order>(origOrder);
origOrder.OrderDetails[1].Product.ProductName = "xxx";
origOrder.OrderDetails[2].Quantity++;
origOrder.OrderDetails[2].ProductId = 1;
var newUnitPrice = origOrder.OrderDetails[2].UnitPrice + 1;
origOrder.OrderDetails.RemoveAt(3);
var addedDetail = new OrderDetail {
ProductId = 51, OrderId = 10249, Quantity = 40, UnitPrice = 42.4000M
};
origOrder.OrderDetails.Add(addedDetail);
var changes = changeTracker.GetChanges();
var updatedOrder = UpdateOrdersWithDetails(database, changes)[0];
// Act
changeTracker.MergeChanges(updatedOrder);
// Assert
Assert.Contains(unchangedDetail, origOrder.OrderDetails); // Unchanged present
Assert.Equal("xxx", origOrder.OrderDetails[1].Product.ProductName); // Prod name updated
Assert.Equal(updatedOrder.OrderDetails[1].ProductId, origOrder.OrderDetails[2].Product.ProductId); // Changed Product set
Assert.Equal(newUnitPrice, origOrder.OrderDetails[2].UnitPrice); // Db-generated value set
Assert.Equal(updatedOrder.OrderDetails[2].Product.ProductId, origOrder.OrderDetails[3].Product.ProductId); // Added detail Product set
Assert.True(origOrder.OrderDetails.All(d => d.TrackingState == TrackingState.Unchanged)); // Details unchanged
Assert.Same(addedDetail, origOrder.OrderDetails.Single(d => d.ProductId == 51)); // Ref equality
Assert.Same(modifiedDetail, origOrder.OrderDetails.Single(d => d.ProductId == 42)); // Ref equality
Assert.DoesNotContain(deletedDetail, origOrder.OrderDetails); // Detail deleted
ICollection cachedDeletes = ((ITrackingCollection)origOrder.OrderDetails).CachedDeletes;
Assert.Empty(cachedDeletes); // Cached deletes have been removed
}
public void Adding_And_Removing_The_Same_Territory_Should_Not_Keep_Added_Territory_In_Territory_Collection()
{
// Arrange
var database = new MockNorthwind();
var employee = database.Employees[0];
var changeTracker = new ChangeTrackingCollection <Employee>(employee);
// Act
employee.Territories.Add(database.Territories[4]);
employee.Territories.Remove(database.Territories[4]);
// Assert
var changes = changeTracker.GetChanges();
Assert.Equal(0, changes.Count);
Assert.Equal(3, employee.Territories.Count);
}
public void MergeChanges_Should_Set_Order_With_Modified_Customer_With_Db_Generated_Values()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection <Order>(order);
var customer = order.Customer;
var name = customer.CustomerName = "xxx";
var changes = changeTracker.GetChanges();
var updatedOrder = changes[0].Clone <Order>();
var data = updatedOrder.Customer.Data = "yyy"; // simulate db-generated values
updatedOrder.AcceptChanges();
// Act
changeTracker.MergeChanges(updatedOrder);
// Assert
Assert.Equal(name, order.Customer.CustomerName);
Assert.Equal(data, order.Customer.Data);
}
public void GetChanges_Should_Return_Added_Modified_Deleted_Items()
{
// Arrange
var database = new MockNorthwind();
var addedProduct = database.Products[0];
var updatedProduct = database.Products[1];
var deletedProduct = database.Products[2];
var changeTracker = new ChangeTrackingCollection <Product>(updatedProduct, deletedProduct);
changeTracker.Add(addedProduct);
updatedProduct.UnitPrice++;
changeTracker.Remove(deletedProduct);
// Act
var changes = changeTracker.GetChanges();
// Assert
Assert.Equal(TrackingState.Added, changes.ElementAt(1).TrackingState);
Assert.Equal(TrackingState.Modified, changes.ElementAt(0).TrackingState);
Assert.Equal(TrackingState.Deleted, changes.ElementAt(2).TrackingState);
}
public void GetChanges_Should_Not_Change_Territory_Collection_Of_Tracked_Employee()
{
// Arrange
var database = new MockNorthwind();
var employee = database.Employees[0];
var changeTracker = new ChangeTrackingCollection <Employee>(employee);
// Delete all territories, so employee.Territories.Count is 0
employee.Territories.Remove(employee.Territories[2]);
employee.Territories.Remove(employee.Territories[1]);
employee.Territories.Remove(employee.Territories[0]);
// Act
var changes = changeTracker.GetChanges();
// Assert
Assert.Equal(0, employee.Territories.Count);
Assert.Equal(3, changes[0].Territories.Count);
Assert.Equal(TrackingState.Deleted, changes[0].Territories[0].TrackingState);
Assert.Equal(TrackingState.Deleted, changes[0].Territories[1].TrackingState);
Assert.Equal(TrackingState.Deleted, changes[0].Territories[2].TrackingState);
}
public void Collection_GetChanges_Should_Add_Only_Deleted_Children()
{
// Arrange
var parent = new Parent("Parent")
{
Children = new ChangeTrackingCollection <Child>
{
new Child("Child1")
}
};
var changeTracker = new ChangeTrackingCollection <Parent>(parent);
parent.Children.RemoveAt(0);
// Act
var changes = changeTracker.GetChanges();
var changedParent = changes.First();
// Assert
Assert.AreEqual(1, changes.Count);
Assert.AreEqual(1, changedParent.Children.Count);
}
public void MergeChanges_Should_Set_Modified_Order_With_Unchanged_Customer()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection <Order>(order);
var date = order.OrderDate = order.OrderDate.AddDays(1);
var origState = order.TrackingState;
var changes = changeTracker.GetChanges();
var changedOrder = changes[0];
var updatedOrder = changes[0].Clone <Order>();
updatedOrder.AcceptChanges();
// Act
changeTracker.MergeChanges(updatedOrder);
// Assert
Assert.Equal(date, order.OrderDate); // Changed order date is preserved
Assert.Null(changedOrder.Customer); // GetChanges sets unchanges ref props to null
Assert.NotNull(order.Customer); // Unchanged order.Customer is not overwritten
Assert.Equal(TrackingState.Modified, origState); // Changed state is modified
Assert.Equal(TrackingState.Unchanged, order.TrackingState); // State set to unchanged
}
public void GetChanges_On_Existing_Order_With_Manually_Added_Customer_Should_Return_Customer_Marked_As_Added()
{
// NOTE: Reference properties must be explicitly marked as Added.
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection<Order>(order);
order.Customer = new Customer()
{
CustomerId = "ABCD",
CustomerName = "Test",
TrackingState = TrackingState.Added
};
// Act
var changes = changeTracker.GetChanges();
// Assert
Assert.NotEmpty(changes);
Assert.Equal(TrackingState.Unchanged, changes.First().TrackingState);
Assert.Equal(TrackingState.Added, changes.First().Customer.TrackingState);
}
public void GetChanges_On_Existing_Order_With_Modified_Customer_With_Deleted_Territory_Should_Set_Territory_To_Null()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
order.Customer.Territory = new Territory
{
TerritoryId = "91360",
TerritoryDescription = "Southern California",
Customers = new ChangeTrackingCollection<Customer> { order.Customer }
};
var changeTracker = new ChangeTrackingCollection<Order>(order);
order.Customer.CustomerName = "xxx";
order.Customer.Territory.TrackingState = TrackingState.Deleted;
// Act
var changes = changeTracker.GetChanges();
// Assert
Assert.NotEmpty(changes);
Assert.Equal(TrackingState.Unchanged, changes.First().TrackingState);
Assert.Equal(TrackingState.Modified, changes.First().Customer.TrackingState);
Assert.Null(changes.First().Customer.Territory);
}
static void Main(string[] args)
{
Console.WriteLine("Press Enter get customers");
Console.ReadLine();
// Get media type formatter
MediaTypeFormatter formatter;
string acceptHeader;
GetFormatter(out formatter, out acceptHeader);
// TODO: Address for Web API service (replace port number)
const string serviceBaseAddress = "http://localhost:" + "64139" + "/";
var client = new HttpClient {
BaseAddress = new Uri(serviceBaseAddress)
};
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(acceptHeader));
// Get customers
Console.WriteLine("Customers:");
IEnumerable <Customer> customers = GetCustomers(client, formatter);
if (customers == null)
{
return;
}
foreach (var c in customers)
{
PrintCustomer(c);
}
// Get orders for a customer
Console.WriteLine("\nGet customer orders {CustomerId}:");
string customerId = Console.ReadLine();
if (!customers.Any(c => string.Equals(c.CustomerId, customerId, StringComparison.OrdinalIgnoreCase)))
{
Console.WriteLine("Invalid customer id: {0}", customerId.ToUpper());
return;
}
IEnumerable <Order> orders = GetCustomerOrders(client, customerId, formatter);
foreach (var o in orders)
{
PrintOrder(o);
}
// Get an order
Console.WriteLine("\nGet an order {OrderId}:");
int orderId = int.Parse(Console.ReadLine());
if (!orders.Any(o => o.OrderId == orderId))
{
Console.WriteLine("Invalid order id: {0}", orderId);
return;
}
Order order = GetOrder(client, orderId, formatter);
PrintOrderWithDetails(order);
// Create a new order
Console.WriteLine("\nPress Enter to create a new order for {0}",
customerId.ToUpper());
Console.ReadLine();
var newOrder = new Order
{
CustomerId = customerId,
OrderDate = DateTime.Today,
ShippedDate = DateTime.Today.AddDays(1),
OrderDetails = new ChangeTrackingCollection <OrderDetail>
{
new OrderDetail {
ProductId = 1, Quantity = 5, UnitPrice = 10
},
new OrderDetail {
ProductId = 2, Quantity = 10, UnitPrice = 20
},
new OrderDetail {
ProductId = 4, Quantity = 40, UnitPrice = 40
}
}
};
var createdOrder = CreateOrder(client, newOrder, formatter);
PrintOrderWithDetails(createdOrder);
// Update the order
Console.WriteLine("\nPress Enter to update order and details");
Console.ReadLine();
// Start change-tracking the order
var changeTracker = new ChangeTrackingCollection <Order>(createdOrder);
// Modify order
createdOrder.OrderDate = createdOrder.OrderDate.GetValueOrDefault().AddDays(1);
// Modify order details
createdOrder.OrderDetails[0].UnitPrice++;
createdOrder.OrderDetails.RemoveAt(1);
createdOrder.OrderDetails.Add(new OrderDetail
{
OrderId = createdOrder.OrderId,
ProductId = 3,
Quantity = 15,
UnitPrice = 30
});
// Submit changes
var changedOrder = changeTracker.GetChanges().SingleOrDefault();
var updatedOrder = UpdateOrder(client, changedOrder, formatter);
// Merge changes
changeTracker.MergeChanges(updatedOrder);
Console.WriteLine("Updated order:");
PrintOrderWithDetails(createdOrder);
// Delete the order
Console.WriteLine("\nPress Enter to delete the order");
Console.ReadLine();
DeleteOrder(client, createdOrder);
// Verify order was deleted
var deleted = VerifyOrderDeleted(client, createdOrder.OrderId);
Console.WriteLine(deleted ?
"Order was successfully deleted" :
"Order was not deleted");
// Keep console open
Console.WriteLine("Press any key to exit");
Console.ReadKey(true);
}
static void Main(string[] args)
{
Console.WriteLine("Press Enter to start");
Console.ReadLine();
ICustomerService customerService = new ChannelFactory <ICustomerService>("customerService").CreateChannel();
IOrderService orderService = new ChannelFactory <IOrderService>("orderService").CreateChannel();
using ((IDisposable)customerService)
using ((IDisposable)orderService)
{
try
{
// Get customers
Console.WriteLine("Customers:");
IEnumerable <Customer> customers = customerService.GetCustomersAsync().Result;
if (customers == null)
{
return;
}
foreach (var c in customers)
{
PrintCustomer(c);
}
// Get orders for a customer
Console.WriteLine("\nGet customer orders {CustomerId}:");
string customerId = Console.ReadLine();
if (!customers.Any(c => string.Equals(c.CustomerId, customerId, StringComparison.OrdinalIgnoreCase)))
{
Console.WriteLine("Invalid customer id: {0}", customerId.ToUpper());
return;
}
IEnumerable <Order> orders = orderService.GetCustomerOrdersAsync(customerId).Result;
foreach (var o in orders)
{
PrintOrder(o);
}
// Get an order
Console.WriteLine("\nGet an order {OrderId}:");
int orderId = int.Parse(Console.ReadLine());
if (!orders.Any(o => o.OrderId == orderId))
{
Console.WriteLine("Invalid order id: {0}", orderId);
return;
}
Order order = orderService.GetOrderAsync(orderId).Result;
PrintOrderWithDetails(order);
// Create a new order
Console.WriteLine("\nPress Enter to create a new order for {0}",
customerId.ToUpper());
Console.ReadLine();
var newOrder = new Order
{
CustomerId = customerId,
OrderDate = DateTime.Today,
ShippedDate = DateTime.Today.AddDays(1),
OrderDetails = new ChangeTrackingCollection <OrderDetail>
{
new OrderDetail {
ProductId = 1, Quantity = 5, UnitPrice = 10
},
new OrderDetail {
ProductId = 2, Quantity = 10, UnitPrice = 20
},
new OrderDetail {
ProductId = 4, Quantity = 40, UnitPrice = 40
}
}
};
var createdOrder = orderService.CreateOrderAsync(newOrder).Result;
PrintOrderWithDetails(createdOrder);
// Update the order
Console.WriteLine("\nPress Enter to update order details");
Console.ReadLine();
// Start change-tracking the order
var changeTracker = new ChangeTrackingCollection <Order>(createdOrder);
// Modify order details
createdOrder.OrderDetails[0].UnitPrice++;
createdOrder.OrderDetails.RemoveAt(1);
createdOrder.OrderDetails.Add(new OrderDetail
{
OrderId = createdOrder.OrderId,
ProductId = 3,
Quantity = 15,
UnitPrice = 30
});
// Submit changes
Order changedOrder = changeTracker.GetChanges().SingleOrDefault();
Order updatedOrder = orderService.UpdateOrderAsync(changedOrder).Result;
// Merge changes
changeTracker.MergeChanges(updatedOrder);
Console.WriteLine("Updated order:");
PrintOrderWithDetails(createdOrder);
// Delete the order
Console.WriteLine("\nPress Enter to delete the order");
Console.ReadLine();
bool deleted = orderService.DeleteOrderAsync(createdOrder.OrderId).Result;
// Verify order was deleted
Order deletedOrder = orderService.GetOrderAsync(createdOrder.OrderId).Result;
Console.WriteLine(deleted && deletedOrder == null
? "Order was successfully deleted"
: "Order was not deleted");
}
catch (AggregateException aggEx)
{
var baseEx = aggEx.Flatten().GetBaseException();
var innerExMsg = baseEx.InnerException != null ? "\r\n" + baseEx.InnerException.Message : "";
Console.WriteLine(baseEx.Message + innerExMsg);
}
finally
{
var channel = customerService as IClientChannel;
if (channel != null && channel.State == CommunicationState.Faulted)
{
channel.Abort();
}
}
// Keep console open
Console.WriteLine("Press any key to exit");
Console.ReadKey(true);
}
}
public void GetChanges_On_Existing_Order_With_Modified_Customer_Should_Return_Customer_Marked_As_Modified()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection<Order>(order);
order.Customer.CustomerName = "xxx";
// Act
var changes = changeTracker.GetChanges();
// Assert
Assert.NotEmpty(changes);
Assert.Equal(TrackingState.Unchanged, changes.First().TrackingState);
Assert.Equal(TrackingState.Modified, changes.First().Customer.TrackingState);
}
public void MergeChanges_Should_Set_Modified_Order_With_Unchanged_Customer()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection<Order>(order);
var date = order.OrderDate = order.OrderDate.AddDays(1);
var origState = order.TrackingState;
var changes = changeTracker.GetChanges();
var changedOrder = changes[0];
var updatedOrder = changes[0].Clone<Order>();
updatedOrder.AcceptChanges();
// Act
changeTracker.MergeChanges(updatedOrder);
// Assert
Assert.Equal(date, order.OrderDate); // Changed order date is preserved
Assert.Null(changedOrder.Customer); // GetChanges sets unchanges ref props to null
Assert.NotNull(order.Customer); // Unchanged order.Customer is not overwritten
Assert.Equal(TrackingState.Modified, origState); // Changed state is modified
Assert.Equal(TrackingState.Unchanged, order.TrackingState); // State set to unchanged
}
public void MergeChanges_Should_Merge_Updates_For_Unchanged_Order_With_Changed_OrderDetails()
{
// Arrange
var database = new MockNorthwind();
var origOrder = database.Orders[0];
var product = database.Products.Single(p => p.ProductId == 14);
origOrder.OrderDetails.Add(new OrderDetail { ProductId = 14, OrderId = 10249, Quantity = 9, UnitPrice = 18.6000M, Product = product });
var unchangedDetail = origOrder.OrderDetails[0];
var modifiedDetail = origOrder.OrderDetails[1];
var deletedDetail = origOrder.OrderDetails[3];
var changeTracker = new ChangeTrackingCollection<Order>(origOrder);
origOrder.OrderDetails[1].Product.ProductName = "xxx";
origOrder.OrderDetails[2].Quantity++;
origOrder.OrderDetails[2].ProductId = 1;
var newUnitPrice = origOrder.OrderDetails[2].UnitPrice + 1;
origOrder.OrderDetails.RemoveAt(3);
var addedDetail = new OrderDetail {ProductId = 51, OrderId = 10249, Quantity = 40, UnitPrice = 42.4000M};
origOrder.OrderDetails.Add(addedDetail);
var changes = changeTracker.GetChanges();
var updatedOrder = UpdateOrdersWithDetails(database, changes)[0];
// Act
changeTracker.MergeChanges(updatedOrder);
// Assert
Assert.Contains(unchangedDetail, origOrder.OrderDetails); // Unchanged present
Assert.Equal("xxx", origOrder.OrderDetails[1].Product.ProductName); // Prod name updated
Assert.Equal(updatedOrder.OrderDetails[1].ProductId, origOrder.OrderDetails[2].Product.ProductId); // Changed Product set
Assert.Equal(newUnitPrice, origOrder.OrderDetails[2].UnitPrice); // Db-generated value set
Assert.Equal(updatedOrder.OrderDetails[2].Product.ProductId, origOrder.OrderDetails[3].Product.ProductId); // Added detail Product set
Assert.True(origOrder.OrderDetails.All(d => d.TrackingState == TrackingState.Unchanged)); // Details unchanged
Assert.Same(addedDetail, origOrder.OrderDetails.Single(d => d.ProductId == 51)); // Ref equality
Assert.Same(modifiedDetail, origOrder.OrderDetails.Single(d => d.ProductId == 42)); // Ref equality
Assert.DoesNotContain(deletedDetail, origOrder.OrderDetails); // Detail deleted
ICollection cachedDeletes = ((ITrackingCollection)origOrder.OrderDetails).GetChanges(true);
Assert.Empty(cachedDeletes); // Cached deletes have been removed
}
public void GetChanges_On_Modified_Employee_With_Unchanged_Territories_Should_Return_No_Territories()
{
// Arrange
var database = new MockNorthwind();
var employee = database.Employees[0];
var changeTracker = new ChangeTrackingCollection<Employee>(employee);
employee.LastName = "xxx";
// Act
var changes = changeTracker.GetChanges();
var changedEmployee = changes.First();
// Assert
Assert.Empty(changedEmployee.Territories);
}
public void GetChanges_On_Existing_Employee_With_Territory_And_Modified_Area_Should_Return_Marked_Territory()
{
// Ensure that changes are retrieved across M-M relationships.
// Arrange
var database = new MockNorthwind();
var employee = database.Employees[0];
var territory = employee.Territories[0];
var area = new Area
{
AreaId = 1,
AreaName = "Northern",
TrackingState = TrackingState.Modified
};
territory.AreaId = 1;
territory.Area = area;
var changeTracker = new ChangeTrackingCollection<Employee>(employee);
area.AreaName = "xxx"; // Modify area
// Act
var changes = changeTracker.GetChanges();
var changedEmployee = changes.First();
var changedTerritory = changedEmployee.Territories.Single(t => t.TerritoryId == territory.TerritoryId);
var changedArea = changedTerritory.Area;
// Assert
Assert.Equal(TrackingState.Unchanged, changedEmployee.TrackingState);
Assert.Equal(TrackingState.Unchanged, changedTerritory.TrackingState);
Assert.Equal(TrackingState.Modified, changedArea.TrackingState);
Assert.Contains("AreaName", area.ModifiedProperties);
}
public void GetChanges_On_Existing_Employee_With_Territories_Should_Return_Marked_Territories()
{
// Arrange
var database = new MockNorthwind();
var employee = database.Employees[0];
var changeTracker = new ChangeTrackingCollection<Employee>(employee);
var unchangedTerritory = employee.Territories[0];
var modifiedTerritory = employee.Territories[1];
var deletedTerritory = employee.Territories[2];
var addedTerritory = database.Territories[3];
employee.Territories.Add(addedTerritory);
modifiedTerritory.TerritoryDescription = "xxx";
employee.Territories.Remove(deletedTerritory);
// Act
var changes = changeTracker.GetChanges();
var changedEmployee = changes.First();
var changedModifiedTerritory = changedEmployee.Territories.Single(t => t.TerritoryId == modifiedTerritory.TerritoryId);
var changedAddedTerritory = changedEmployee.Territories.Single(t => t.TerritoryId == addedTerritory.TerritoryId);
var changedDeletedTerritory = changedEmployee.Territories.Single(t => t.TerritoryId == deletedTerritory.TerritoryId);
// Assert
Assert.Equal(TrackingState.Unchanged, changedEmployee.TrackingState);
Assert.Equal(3, changedEmployee.Territories.Count);
Assert.Equal(TrackingState.Modified, changedModifiedTerritory.TrackingState);
Assert.Equal(TrackingState.Added, changedAddedTerritory.TrackingState);
Assert.Equal(TrackingState.Deleted, changedDeletedTerritory.TrackingState);
Assert.DoesNotContain(unchangedTerritory, changedEmployee.Territories);
}
public void GetChanges_With_More_Than_One_ITrackable_Members_Should_Return_NonEmpty_Changeset_if_Modified()
{
// Arrange
var family = new Family
{
Father = new Parent
{
Name = "Alan"
},
Mother = new Parent
{
Name = "Judith"
},
Child = new Child
{
Name = "Jake"
}
};
var changeTracker = new ChangeTrackingCollection<Family>(family);
// Act
family.Father.Name = "Herb";
var changedFamily = changeTracker.GetChanges().SingleOrDefault();
//Assert
Assert.NotNull(changedFamily);
Assert.Equal(TrackingState.Unchanged, changedFamily.TrackingState);
Assert.NotNull(changedFamily.Father);
Assert.Equal(TrackingState.Modified, changedFamily.Father.TrackingState);
Assert.Null(changedFamily.Mother);
Assert.Null(changedFamily.Child);
}
public void GetChanges_On_Unchanged_OrderDetail_With_Modified_Product_Should_Return_OrderDetail()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection<Order>(order);
order.OrderDetails[0].Product.ProductName = "xxx";
// Act
var changes = changeTracker.GetChanges();
// Assert
Assert.Equal(TrackingState.Unchanged, changes[0].OrderDetails[0].TrackingState);
Assert.Equal(1, changes[0].OrderDetails.Count);
Assert.Equal(TrackingState.Modified, changes[0].OrderDetails[0].Product.TrackingState);
Assert.True(changes[0].IsEquatable(order));
Assert.True(changes[0].OrderDetails[0].IsEquatable(order.OrderDetails[0]));
Assert.True(changes[0].OrderDetails[0].Product.IsEquatable(order.OrderDetails[0].Product));
}
public void GetChanges_On_Existing_Order_With_New_Customer_Should_Return_Empty_Collection()
{
// NOTE: Reference properties not explicitly marked as Added will be considered
// unchanged.
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection<Order>(order);
order.Customer = new Customer()
{
CustomerId = "ABCD",
CustomerName = "Test"
};
// Act
var changes = changeTracker.GetChanges();
// Assert
Assert.Empty(changes);
}
public void GetChanges_Should_Return_Deleted_Items()
{
// Arrange
var database = new MockNorthwind();
var product = database.Products[0];
var changeTracker = new ChangeTrackingCollection<Product>(product);
changeTracker.Remove(product);
// Act
var changes = changeTracker.GetChanges();
// Assert
Assert.AreEqual(TrackingState.Deleted, changes.First().TrackingState);
}
public void MergeChanges_Should_Set_Order_With_Modified_Customer_With_Db_Generated_Values()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection<Order>(order);
var customer = order.Customer;
var name = customer.CustomerName = "xxx";
var changes = changeTracker.GetChanges();
var updatedOrder = changes[0].Clone<Order>();
var data = updatedOrder.Customer.Data = "yyy"; // simulate db-generated values
updatedOrder.AcceptChanges();
// Act
changeTracker.MergeChanges(updatedOrder);
// Assert
Assert.Equal(name, order.Customer.CustomerName);
Assert.Equal(data, order.Customer.Data);
}
public void GetChanges_On_Modified_Order_Should_Return_Order()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection<Order>(order);
order.OrderDate = order.OrderDate.AddDays(1);
// Act
var changes = changeTracker.GetChanges();
// Assert
Assert.False(changes.Tracking);
Assert.NotSame(changes[0], order);
Assert.True(changes[0].IsEquatable(order));
}
public void MergeChanges_Should_Set_Modified_Customer_With_Unchanged_Setting()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var customer = order.Customer;
customer.CustomerSetting = new CustomerSetting
{
CustomerId = customer.CustomerId,
Customer = customer,
Setting = "Setting1"
};
var changeTracker = new ChangeTrackingCollection<Order>(order);
var name = customer.CustomerName = "xxx";
var origState = customer.TrackingState;
var changes = changeTracker.GetChanges();
var changedCustomer = changes[0].Customer;
var updatedOrder = changes[0].Clone<Order>();
updatedOrder.AcceptChanges();
// Act
changeTracker.MergeChanges(updatedOrder);
// Assert
Assert.Equal(name, customer.CustomerName); // Changed customer name is preserved
Assert.Null(changedCustomer.CustomerSetting); // GetChanges sets unchanges ref props to null
Assert.NotNull(order.Customer.CustomerSetting); // Unchanged ref props not overwritten
Assert.Equal(TrackingState.Modified, origState); // Changed state is modified
Assert.Equal(TrackingState.Unchanged, customer.TrackingState); // State set to unchanged
}
public void GetChanges_On_Existing_Customer_With_Removed_CustomerSetting_Return_Empty_Collection()
{
// Arrange
var database = new MockNorthwind();
var customer = database.Customers[0];
customer.CustomerSetting = new CustomerSetting
{
CustomerId = customer.CustomerId,
Setting = "Setting1",
Customer = customer
};
var customerSetting = customer.CustomerSetting;
var changeTracker = new ChangeTrackingCollection<Customer>(customer);
customer.CustomerSetting = null;
// Act
var changes = changeTracker.GetChanges();
// Assert
Assert.Empty(changes);
Assert.Equal(TrackingState.Unchanged, customerSetting.TrackingState);
}
public void MergeChanges_Should_Set_Unchanged_Customer_With_Modified_Setting()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var customer = order.Customer;
customer.CustomerSetting = new CustomerSetting
{
CustomerId = customer.CustomerId,
Customer = customer,
Setting = "Setting1"
};
var changeTracker = new ChangeTrackingCollection<Order>(order);
var setting = customer.CustomerSetting.Setting = "xxx";
var origState = customer.CustomerSetting.TrackingState;
var changes = changeTracker.GetChanges();
var changedCustomer = changes[0].Customer;
var updatedOrder = changes[0].Clone<Order>();
updatedOrder.AcceptChanges();
// Act
changeTracker.MergeChanges(updatedOrder);
// Assert
Assert.Equal(setting, customer.CustomerSetting.Setting); // Changed customer setting is preserved
Assert.Equal(TrackingState.Modified, origState); // Changed state is modified
Assert.Equal(TrackingState.Unchanged, customer.TrackingState); // State set to unchanged
}
private static void ManyToManyRelation(HttpClient client)
{
Console.WriteLine("\nPress Enter to create a new employee existing territory");
Console.ReadLine();
// Get existing territories
var territory1 = GetEntity <Territory, string>(client, "01581");
var territory2 = GetEntity <Territory, string>(client, "01730");
var territory3 = GetEntity <Territory, string>(client, "01833");
// Create a new employee
var employee = new Employee
{
LastName = "Smith",
FirstName = "John",
BirthDate = DateTime.Parse("1979-12-09"),
HireDate = DateTime.Parse("2001-05-01"),
City = "Dallas",
Country = "USA",
Territories = new ChangeTrackingCollection <Territory>
{
territory1, territory2, territory3
}
};
// Add to change tracker to mark as Added
var employeeChangeTracker = new ChangeTrackingCollection <Employee>(true)
{
employee
};
// Insert employee and merge
Employee updatedEmployee = CreateEntity(client, employee);
employeeChangeTracker.MergeChanges(updatedEmployee);
PrintEmployee(employee);
Console.WriteLine("\nPress Enter to modify, add and remove territories");
Console.ReadLine();
// Modify territory, remove territory, add existing territory
var territory4 = GetEntity <Territory, string>(client, "02116");
employee.Territories[1].TerritoryDescription += " - Changed";
employee.Territories.RemoveAt(2);
employee.Territories.Add(territory4);
// Update employee, then merge changes
var changedEmployee = employeeChangeTracker.GetChanges().SingleOrDefault();
updatedEmployee = UpdateEntity(client, changedEmployee);
employeeChangeTracker.MergeChanges(updatedEmployee);
PrintEmployee(employee);
// Delete the order and customer
Console.WriteLine("\nPress Enter to delete the employee without deleting territories");
Console.ReadLine();
// Delete order and verify
DeleteEntity <Employee, int>(client, employee.EmployeeId);
var employeeDeleted = VerifyEntityDeleted <Employee, int>(client, employee.EmployeeId);
Console.WriteLine(employeeDeleted ?
"Employee was successfully deleted" :
"Employee was NOT deleted");
var removedTerritory = GetEntity <Territory, string>(client, "01833");
Console.WriteLine("Removed territory '01833' still exists: {0}",
removedTerritory != null);
}
public void MergeChanges_Should_Set_Modified_Employee_With_Unchanged_Territories()
{
// Arrange
var database = new MockNorthwind();
var employee = database.Employees[0];
var unchangedterritory = employee.Territories[0];
var modifiedterritory = employee.Territories[1];
var deletedterritory = employee.Territories[2];
var addedExistingTerritory = database.Territories[3];
var addedNewTerritory = new Territory
{
TerritoryId = "91360",
TerritoryDescription = "SouthernCalifornia",
Employees = new ChangeTrackingCollection<Employee> {employee}
};
var changeTracker = new ChangeTrackingCollection<Employee>(employee);
var name = employee.LastName = "xxx";
var origState = employee.TrackingState;
var changes = changeTracker.GetChanges();
var changedTerritories = changes[0].Territories;
var updatedEmployee = changes[0].Clone<Employee>();
updatedEmployee.AcceptChanges();
// Act
changeTracker.MergeChanges(updatedEmployee);
// Assert
Assert.Equal(name, employee.LastName); // Changed prop is preserved
Assert.Empty(changedTerritories); // GetChanges sets unchanges ref props to null
Assert.Equal(3, employee.Territories.Count); // Unchanged items preserved
}
public void GetChanges_On_Existing_Customer_With_Manually_Added_CustomerSetting_Return_CustomerSetting_Marked_As_Added()
{
// Arrange
var database = new MockNorthwind();
var customer = database.Customers[0];
var changeTracker = new ChangeTrackingCollection<Customer>(customer);
customer.CustomerSetting = new CustomerSetting
{
CustomerId = customer.CustomerId,
Setting = "Setting1",
Customer = customer,
TrackingState = TrackingState.Added
};
// Act
var changes = changeTracker.GetChanges();
// Assert
Assert.NotEmpty(changes);
Assert.Equal(TrackingState.Unchanged, changes.First().TrackingState);
Assert.Equal(TrackingState.Added, changes.First().CustomerSetting.TrackingState);
}
public void GetChanges_On_Existing_Order_With_Unchanged_Customer_Should_Return_Empty_Collection()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection<Order>(order);
// Act
var changes = changeTracker.GetChanges();
// Assert
Assert.Empty(changes);
}
public void GetChanges_On_Existing_Order_With_Customer_Territory_Added_Modified_Removed_Employees_Should_Return_Marked_Employees()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
order.Customer.Territory = new Territory
{
TerritoryId = "91360",
TerritoryDescription = "Southern California",
Customers = new ChangeTrackingCollection<Customer> { order.Customer }
};
var employee1 = database.Employees[0];
var employee2 = database.Employees[1];
var employee3 = database.Employees[2];
var employee4 = database.Employees[3];
employee1.Territories.Add(order.Customer.Territory);
employee2.Territories.Add(order.Customer.Territory);
employee3.Territories.Add(order.Customer.Territory);
employee4.Territories.Add(order.Customer.Territory);
order.Customer.Territory.Employees = new ChangeTrackingCollection<Employee>
{ employee1, employee2, employee3 };
var changeTracker = new ChangeTrackingCollection<Order>(order);
employee2.FirstName = "xxx";
order.Customer.Territory.Employees.Remove(employee3);
order.Customer.Territory.Employees.Add(employee4);
// Act
var changes = changeTracker.GetChanges();
// Assert
Assert.NotEmpty(changes);
var changedOrder = changes.First();
Assert.Equal(TrackingState.Unchanged, changedOrder.TrackingState);
Assert.Equal(TrackingState.Unchanged, changedOrder.Customer.TrackingState);
Assert.Equal(TrackingState.Unchanged, changedOrder.Customer.Territory.TrackingState);
Assert.Equal(3, changedOrder.Customer.Territory.Employees.Count);
Assert.Equal(TrackingState.Modified, changedOrder.Customer.Territory.Employees[0].TrackingState);
Assert.Equal(TrackingState.Added, changedOrder.Customer.Territory.Employees[1].TrackingState);
Assert.Equal(TrackingState.Deleted, changedOrder.Customer.Territory.Employees[2].TrackingState);
}
public void GetChanges_On_Added_Order_With_Details_Should_Return_Marked_Children_Added()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection<Order>(true) {order};
var orderDetails = (IList<OrderDetail>)changeTracker[0].OrderDetails;
var unchangedDetail = orderDetails[0];
var modifiedDetail = orderDetails[1];
var deletedDetail = orderDetails[2];
var addedDetail = new OrderDetail
{
ProductId = 1,
Product = database.Products[0],
Quantity = 10,
UnitPrice = 20M
};
orderDetails.Add(addedDetail);
modifiedDetail.UnitPrice++;
orderDetails.Remove(deletedDetail);
// Act
var changes = changeTracker.GetChanges();
// Assert
var changedOrder = changes.First();
var changedExistingDetail = changedOrder.OrderDetails.Single(d => d.ProductId == unchangedDetail.ProductId);
var changedModifiedDetail = changedOrder.OrderDetails.Single(d => d.ProductId == modifiedDetail.ProductId);
var changedAddedDetail = changedOrder.OrderDetails.Single(d => d.ProductId == addedDetail.ProductId);
Assert.Equal(TrackingState.Added, changedOrder.TrackingState);
Assert.Equal(3, changedOrder.OrderDetails.Count);
Assert.Equal(TrackingState.Added, changedModifiedDetail.TrackingState);
Assert.Equal(TrackingState.Added, changedAddedDetail.TrackingState);
Assert.Equal(TrackingState.Added, changedExistingDetail.TrackingState);
Assert.DoesNotContain(deletedDetail, changedOrder.OrderDetails);
}
public void GetChanges_On_Existing_Order_With_Removed_Customer_Should_Return_Empty_Collection()
{
// NOTE: Reference properties are change-tracked but do not call
// NotifyPropertyChanged because it is called by foreign key's property setter.
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection<Order>(order);
var customer = order.Customer;
order.Customer = null;
// Act
var changes = changeTracker.GetChanges();
// Assert
Assert.Empty(changes);
Assert.Equal(TrackingState.Unchanged, customer.TrackingState);
}
public void GetChanges_On_Unchanged_Order_With_Details_Should_Return_Marked_Children()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var order3 = database.Orders[3];
var changeTracker = new ChangeTrackingCollection<Order>(order, order3);
order3.OrderDate += new System.TimeSpan(1, 0, 0, 0); // + one day
order3.Customer.CustomerName += " (test)";
var orderDetails = (IList<OrderDetail>)changeTracker[0].OrderDetails;
var unchangedDetail = orderDetails[0];
var modifiedDetail = orderDetails[1];
var deletedDetail = orderDetails[2];
var addedDetail = new OrderDetail
{
ProductId = 1,
Product = database.Products[0],
Quantity = 10,
UnitPrice = 20M
};
orderDetails.Add(addedDetail);
modifiedDetail.UnitPrice++;
orderDetails.Remove(deletedDetail);
// Act
var changes = changeTracker.GetChanges();
// Assert
var changedOrder = changes.First();
var changedOrder3 = changes[1];
var changedModifiedDetail = changedOrder.OrderDetails.Single(d => d.ProductId == modifiedDetail.ProductId);
var changedAddedDetail = changedOrder.OrderDetails.Single(d => d.ProductId == addedDetail.ProductId);
var changedDeletedDetail = changedOrder.OrderDetails.Single(d => d.ProductId == deletedDetail.ProductId);
Assert.Equal(TrackingState.Unchanged, changedOrder.TrackingState);
Assert.Equal(3, changedOrder.OrderDetails.Count);
Assert.Equal(TrackingState.Modified, changedModifiedDetail.TrackingState);
Assert.Equal(TrackingState.Added, changedAddedDetail.TrackingState);
Assert.Equal(TrackingState.Deleted, changedDeletedDetail.TrackingState);
Assert.DoesNotContain(unchangedDetail, changedOrder.OrderDetails);
Assert.NotNull(order.Customer);
Assert.NotNull(order3.Customer);
Assert.NotNull(changedOrder.Customer);
Assert.NotNull(changedOrder3.Customer);
Assert.True(object.ReferenceEquals(order.Customer, order3.Customer));
Assert.False(object.ReferenceEquals(order.Customer, changedOrder.Customer));
Assert.True(object.ReferenceEquals(changedOrder.Customer, changedOrder3.Customer));
}
public void MergeChanges_Should_Merge_Updates_For_Unchanged_Employee_With_Changed_Territories()
{
// Arrange
var database = new MockNorthwind();
var employee = database.Employees[0];
var unchangedTerritory = employee.Territories[0];
var modifiedTerritory = employee.Territories[1];
var deletedTerritory = employee.Territories[2];
var addedExistingTerritory = database.Territories[3];
var area1 = new Area {
AreaId = 1, AreaName = "Northern", Territories = new ChangeTrackingCollection <Territory> {
unchangedTerritory
}
};
var area2 = new Area {
AreaId = 2, AreaName = "Southern", Territories = new ChangeTrackingCollection <Territory> {
modifiedTerritory
}
};
var area3 = new Area {
AreaId = 3, AreaName = "Eastern", Territories = new ChangeTrackingCollection <Territory> {
deletedTerritory
}
};
var area4 = new Area {
AreaId = 4, AreaName = "Western", Territories = new ChangeTrackingCollection <Territory> {
addedExistingTerritory
}
};
var addedNewTerritory = new Territory
{
TerritoryId = "91360",
TerritoryDescription = "SouthernCalifornia",
Employees = new ChangeTrackingCollection <Employee> {
employee
},
AreaId = 5,
TrackingState = TrackingState.Added // Must explicitly mark as added
};
unchangedTerritory.Area = area1;
unchangedTerritory.AreaId = area1.AreaId;
modifiedTerritory.Area = area2;
modifiedTerritory.AreaId = area2.AreaId;
deletedTerritory.Area = area3;
deletedTerritory.AreaId = area3.AreaId;
addedExistingTerritory.Area = area4;
addedExistingTerritory.AreaId = area4.AreaId;
var changeTracker = new ChangeTrackingCollection <Employee>(employee);
modifiedTerritory.TerritoryDescription = "xxx"; // mod prop
modifiedTerritory.AreaId = 6; // mod FK prop
employee.Territories.Remove(deletedTerritory); // should mark area deleted
employee.Territories.Add(addedExistingTerritory); // should keep area unchanged
employee.Territories.Add(addedNewTerritory); // should keep territory added
addedExistingTerritory.Area.AreaName = "zzz"; // should mark area modified
var changes = changeTracker.GetChanges(); // should exclude unchanged territory
var updatedEmployee = UpdateEmployeesWithTerritories(changes)[0]; // rel entities, db-gen vals
// Act
changeTracker.MergeChanges(updatedEmployee);
// Assert
Assert.Contains(unchangedTerritory, employee.Territories); // Unchanged present
Assert.Equal("zzz", addedExistingTerritory.Area.AreaName); // Area name updated
Assert.Equal("yyy", addedNewTerritory.Data); // Db-generated value set
Assert.Equal(addedNewTerritory.AreaId, addedNewTerritory.Area.AreaId); // Added territory Area set
Assert.Equal(modifiedTerritory.AreaId, modifiedTerritory.Area.AreaId); // Modified territory Area set
Assert.Same(addedExistingTerritory, employee.Territories.Single(t => t.TerritoryId == "02116")); // Ref equality
Assert.Same(addedNewTerritory, employee.Territories.Single(t => t.TerritoryId == "91360")); // Ref equality
Assert.Same(modifiedTerritory, employee.Territories.Single(t => t.TerritoryId == "01730")); // Ref equality
Assert.DoesNotContain(deletedTerritory, employee.Territories); // Detail deleted
ICollection cachedDeletes = ((ITrackingCollection)employee.Territories).CachedDeletes;
Assert.Empty(cachedDeletes); // Cached deletes have been removed
}
public void GetChanges_Should_Return_Modified_Items()
{
// Arrange
var database = new MockNorthwind();
var product = database.Products[0];
var changeTracker = new ChangeTrackingCollection<Product>(product);
product.UnitPrice++;
// Act
var changes = changeTracker.GetChanges();
// Assert
Assert.Equal(TrackingState.Modified, changes.First().TrackingState);
}
static void Main()
{
// Get media type formatter
MediaTypeFormatter formatter;
string acceptHeader;
GetFormatter(out formatter, out acceptHeader);
// TODO: Address for Web API service (replace port number)
const string serviceBaseAddress = "http://localhost:" + "58527" + "/";
var client = new HttpClient { BaseAddress = new Uri(serviceBaseAddress) };
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(acceptHeader));
// Get customers
Console.WriteLine("Customers:");
IEnumerable<Customer> customers = GetCustomers(client, formatter);
if (customers == null) return;
foreach (var c in customers)
PrintCustomer(c);
// Get orders for a customer
Console.WriteLine("\nGet customer orders {CustomerId}:");
string customerId = Console.ReadLine();
if (!customers.Any(c => string.Equals(c.CustomerId, customerId, StringComparison.OrdinalIgnoreCase)))
{
Console.WriteLine("Invalid customer id: {0}", customerId.ToUpper());
return;
}
IEnumerable<Order> orders = GetCustomerOrders(client, customerId, formatter);
foreach (var o in orders)
PrintOrder(o);
// Get an order
Console.WriteLine("\nGet an order {OrderId}:");
int orderId = int.Parse(Console.ReadLine());
if (!orders.Any(o => o.OrderId == orderId))
{
Console.WriteLine("Invalid order id: {0}", orderId);
return;
}
Order order = GetOrder(client, orderId, formatter);
PrintOrderWithDetails(order);
// Create a new order
Console.WriteLine("\nPress Enter to create a new order for {0}",
customerId.ToUpper());
Console.ReadLine();
var newOrder = new Order
{
CustomerId = customerId,
OrderDate = DateTime.Today,
ShippedDate = DateTime.Today.AddDays(1),
OrderDetails = new ChangeTrackingCollection<OrderDetail>
{
new OrderDetail { ProductId = 1, Quantity = 5, UnitPrice = 10 },
new OrderDetail { ProductId = 2, Quantity = 10, UnitPrice = 20 },
new OrderDetail { ProductId = 4, Quantity = 40, UnitPrice = 40 }
}
};
var createdOrder = CreateOrder(client, newOrder, formatter);
PrintOrderWithDetails(createdOrder);
// Update the order
Console.WriteLine("\nPress Enter to update order details");
Console.ReadLine();
// Start change-tracking the order
var changeTracker = new ChangeTrackingCollection<Order>(createdOrder);
// Modify order details
createdOrder.OrderDetails[0].UnitPrice++;
createdOrder.OrderDetails.RemoveAt(1);
createdOrder.OrderDetails.Add(new OrderDetail
{
OrderId = createdOrder.OrderId,
ProductId = 3,
Quantity = 15,
UnitPrice = 30
});
// Submit changes
var changedOrder = changeTracker.GetChanges().SingleOrDefault();
var updatedOrder = UpdateOrder(client, changedOrder, formatter);
// Merge changes
changeTracker.MergeChanges(updatedOrder);
Console.WriteLine("Updated order:");
PrintOrderWithDetails(createdOrder);
// Delete the order
Console.WriteLine("\nPress Enter to delete the order");
Console.ReadLine();
DeleteOrder(client, createdOrder);
// Verify order was deleted
var deleted = VerifyOrderDeleted(client, createdOrder.OrderId);
Console.WriteLine(deleted ?
"Order was successfully deleted" :
"Order was not deleted");
// Keep console open
Console.WriteLine("Press any key to exit");
Console.ReadKey(true);
}
static void Main(string[] args)
{
Console.WriteLine("Press Enter to start");
Console.ReadLine();
ICustomerService customerService = new ChannelFactory<ICustomerService>("customerService").CreateChannel();
IOrderService orderService = new ChannelFactory<IOrderService>("orderService").CreateChannel();
using ((IDisposable)customerService)
using ((IDisposable)orderService)
{
try
{
// Get customers
Console.WriteLine("Customers:");
IEnumerable<Customer> customers = customerService.GetCustomersAsync().Result;
if (customers == null) return;
foreach (var c in customers)
PrintCustomer(c);
// Get orders for a customer
Console.WriteLine("\nGet customer orders {CustomerId}:");
string customerId = Console.ReadLine();
if (!customers.Any(c => string.Equals(c.CustomerId, customerId, StringComparison.OrdinalIgnoreCase)))
{
Console.WriteLine("Invalid customer id: {0}", customerId.ToUpper());
return;
}
IEnumerable<Order> orders = orderService.GetCustomerOrdersAsync(customerId).Result;
foreach (var o in orders)
PrintOrder(o);
// Get an order
Console.WriteLine("\nGet an order {OrderId}:");
int orderId = int.Parse(Console.ReadLine());
if (!orders.Any(o => o.OrderId == orderId))
{
Console.WriteLine("Invalid order id: {0}", orderId);
return;
}
Order order = orderService.GetOrderAsync(orderId).Result;
PrintOrderWithDetails(order);
// Create a new order
Console.WriteLine("\nPress Enter to create a new order for {0}",
customerId.ToUpper());
Console.ReadLine();
var newOrder = new Order
{
CustomerId = customerId,
OrderDate = DateTime.Today,
ShippedDate = DateTime.Today.AddDays(1),
OrderDetails = new ChangeTrackingCollection<OrderDetail>
{
new OrderDetail { ProductId = 1, Quantity = 5, UnitPrice = 10 },
new OrderDetail { ProductId = 2, Quantity = 10, UnitPrice = 20 },
new OrderDetail { ProductId = 4, Quantity = 40, UnitPrice = 40 }
}
};
var createdOrder = orderService.CreateOrderAsync(newOrder).Result;
PrintOrderWithDetails(createdOrder);
// Update the order
Console.WriteLine("\nPress Enter to update order details");
Console.ReadLine();
// Start change-tracking the order
var changeTracker = new ChangeTrackingCollection<Order>(createdOrder);
// Modify order details
createdOrder.OrderDetails[0].UnitPrice++;
createdOrder.OrderDetails.RemoveAt(1);
createdOrder.OrderDetails.Add(new OrderDetail
{
OrderId = createdOrder.OrderId,
ProductId = 3,
Quantity = 15,
UnitPrice = 30
});
// Submit changes
Order changedOrder = changeTracker.GetChanges().SingleOrDefault();
Order updatedOrder = orderService.UpdateOrderAsync(changedOrder).Result;
// Merge changes
changeTracker.MergeChanges(updatedOrder);
Console.WriteLine("Updated order:");
PrintOrderWithDetails(createdOrder);
// Delete the order
Console.WriteLine("\nPress Enter to delete the order");
Console.ReadLine();
bool deleted = orderService.DeleteOrderAsync(createdOrder.OrderId).Result;
// Verify order was deleted
Order deletedOrder = orderService.GetOrderAsync(createdOrder.OrderId).Result;
Console.WriteLine(deleted && deletedOrder == null
? "Order was successfully deleted"
: "Order was not deleted");
}
catch (AggregateException aggEx)
{
var baseEx = aggEx.Flatten().GetBaseException();
var innerExMsg = baseEx.InnerException != null ? "\r\n" + baseEx.InnerException.Message : "";
Console.WriteLine(baseEx.Message + innerExMsg);
}
finally
{
var channel = customerService as IClientChannel;
if (channel != null && channel.State == CommunicationState.Faulted)
{
channel.Abort();
}
}
// Keep console open
Console.WriteLine("Press any key to exit");
Console.ReadKey(true);
}
}
public void GetChanges_Should_Return_Added_Modified_Deleted_Items()
{
// Arrange
var database = new MockNorthwind();
var addedProduct = database.Products[0];
var updatedProduct = database.Products[1];
var deletedProduct = database.Products[2];
var changeTracker = new ChangeTrackingCollection<Product>(updatedProduct, deletedProduct);
changeTracker.Add(addedProduct);
updatedProduct.UnitPrice++;
changeTracker.Remove(deletedProduct);
// Act
var changes = changeTracker.GetChanges();
// Assert
Assert.AreEqual(TrackingState.Added, changes.ElementAt(1).TrackingState);
Assert.AreEqual(TrackingState.Modified, changes.ElementAt(0).TrackingState);
Assert.AreEqual(TrackingState.Deleted, changes.ElementAt(2).TrackingState);
}
static void Main()
{
// To debug with Fiddler, append .fiddler to localhost
const string baseAddress = "http://localhost:" + "5000" + "/";
// Start
Console.WriteLine("Press Enter to start");
Console.ReadLine();
INorthwindServiceAgent serviceAgent = new NorthwindServiceAgent(baseAddress, new JsonMediaTypeFormatter());
// Get customers
Console.WriteLine("Customers:");
IEnumerable <Customer> customers = serviceAgent.GetCustomers().Result;
if (customers == null)
{
return;
}
foreach (var c in customers)
{
PrintCustomer(c);
}
// Get orders for a customer
Console.WriteLine("\nGet customer orders {CustomerId}:");
string customerId = Console.ReadLine();
if (string.IsNullOrWhiteSpace(customerId))
{
return;
}
if (!customers.Any(c => string.Equals(c.CustomerId, customerId, StringComparison.OrdinalIgnoreCase)))
{
Console.WriteLine("Invalid customer id: {0}", customerId.ToUpper());
return;
}
IEnumerable <Order> orders = serviceAgent.GetCustomerOrders(customerId).Result;
foreach (var o in orders)
{
PrintOrder(o);
}
// Get an order
Console.WriteLine("\nGet an order {OrderId}:");
int orderId = int.Parse(Console.ReadLine());
if (!orders.Any(o => o.OrderId == orderId))
{
Console.WriteLine("Invalid order id: {0}", orderId);
return;
}
Order order = serviceAgent.GetOrder(orderId).Result;
PrintOrderWithDetails(order);
// Create a new order
Console.WriteLine("\nPress Enter to create a new order for {0}",
customerId.ToUpper());
Console.ReadLine();
var newOrder = new Order
{
CustomerId = customerId,
OrderDate = DateTime.Today,
ShippedDate = DateTime.Today.AddDays(1),
OrderDetails = new ChangeTrackingCollection <OrderDetail>
{
new OrderDetail {
ProductId = 1, Quantity = 5, UnitPrice = 10
},
new OrderDetail {
ProductId = 2, Quantity = 10, UnitPrice = 20
},
new OrderDetail {
ProductId = 4, Quantity = 40, UnitPrice = 40
}
}
};
Order createdOrder = serviceAgent.CreateOrder(newOrder).Result;
PrintOrderWithDetails(createdOrder);
// Update the order
Console.WriteLine("\nPress Enter to update order details");
Console.ReadLine();
// Start change-tracking the order
var changeTracker = new ChangeTrackingCollection <Order>(createdOrder);
// Modify order details
createdOrder.OrderDetails[0].UnitPrice++;
createdOrder.OrderDetails.RemoveAt(1);
createdOrder.OrderDetails.Add(new OrderDetail
{
OrderId = createdOrder.OrderId,
ProductId = 3,
Quantity = 15,
UnitPrice = 30
});
// Submit changes
Order changedOrder = changeTracker.GetChanges().SingleOrDefault();
Order updatedOrder = serviceAgent.UpdateOrder(changedOrder).Result;
// Merge changes
changeTracker.MergeChanges(updatedOrder);
Console.WriteLine("Updated order:");
PrintOrderWithDetails(createdOrder);
// Delete the order
Console.WriteLine("\nPress Enter to delete the order");
Console.ReadLine();
serviceAgent.DeleteOrder(createdOrder).Wait();
// Verify order was deleted
bool deleted = serviceAgent.VerifyOrderDeleted(createdOrder.OrderId).Result;
Console.WriteLine(deleted ?
"Order was successfully deleted" :
"Order was not deleted");
// Keep console open
Console.WriteLine("Press any key to exit");
Console.ReadKey(true);
}
public void MergeChanges_Should_Merge_Updates_For_Unchanged_Employee_With_Changed_Territories()
{
// Arrange
var database = new MockNorthwind();
var employee = database.Employees[0];
var unchangedTerritory = employee.Territories[0];
var modifiedTerritory = employee.Territories[1];
var deletedTerritory = employee.Territories[2];
var addedExistingTerritory = database.Territories[3];
var area1 = new Area { AreaId = 1, AreaName = "Northern", Territories = new ChangeTrackingCollection<Territory> { unchangedTerritory } };
var area2 = new Area { AreaId = 2, AreaName = "Southern", Territories = new ChangeTrackingCollection<Territory> { modifiedTerritory } };
var area3 = new Area { AreaId = 3, AreaName = "Eastern", Territories = new ChangeTrackingCollection<Territory> { deletedTerritory } };
var area4 = new Area { AreaId = 4, AreaName = "Western", Territories = new ChangeTrackingCollection<Territory> { addedExistingTerritory } };
var addedNewTerritory = new Territory
{
TerritoryId = "91360",
TerritoryDescription = "SouthernCalifornia",
Employees = new ChangeTrackingCollection<Employee> { employee },
AreaId = 5,
TrackingState = TrackingState.Added // Must explicitly mark as added
};
unchangedTerritory.Area = area1;
unchangedTerritory.AreaId = area1.AreaId;
modifiedTerritory.Area = area2;
modifiedTerritory.AreaId = area2.AreaId;
deletedTerritory.Area = area3;
deletedTerritory.AreaId = area3.AreaId;
addedExistingTerritory.Area = area4;
addedExistingTerritory.AreaId = area4.AreaId;
var changeTracker = new ChangeTrackingCollection<Employee>(employee);
modifiedTerritory.TerritoryDescription = "xxx"; // mod prop
modifiedTerritory.AreaId = 6; // mod FK prop
employee.Territories.Remove(deletedTerritory); // should mark area deleted
employee.Territories.Add(addedExistingTerritory); // should keep area unchanged
employee.Territories.Add(addedNewTerritory); // should keep territory added
addedExistingTerritory.Area.AreaName = "zzz"; // should mark area modified
var changes = changeTracker.GetChanges(); // should exclude unchanged territory
var updatedEmployee = UpdateEmployeesWithTerritories(changes)[0]; // rel entities, db-gen vals
// Act
changeTracker.MergeChanges(updatedEmployee);
// Assert
Assert.Contains(unchangedTerritory, employee.Territories); // Unchanged present
Assert.Equal("zzz", addedExistingTerritory.Area.AreaName); // Area name updated
Assert.Equal("yyy", addedNewTerritory.Data); // Db-generated value set
Assert.Equal(addedNewTerritory.AreaId, addedNewTerritory.Area.AreaId); // Added territory Area set
Assert.Equal(modifiedTerritory.AreaId, modifiedTerritory.Area.AreaId); // Modified territory Area set
Assert.Same(addedExistingTerritory, employee.Territories.Single(t => t.TerritoryId == "02116")); // Ref equality
Assert.Same(addedNewTerritory, employee.Territories.Single(t => t.TerritoryId == "91360")); // Ref equality
Assert.Same(modifiedTerritory, employee.Territories.Single(t => t.TerritoryId == "01730")); // Ref equality
Assert.DoesNotContain(deletedTerritory, employee.Territories); // Detail deleted
ICollection cachedDeletes = ((ITrackingCollection)employee.Territories).GetChanges(true);
Assert.Empty(cachedDeletes); // Cached deletes have been removed
}
public void GetChanges_On_Deleted_Order_With_Details_Should_Return_Marked_Children_Deleted()
{
// NOTE: Removed order with added detail should exclude added detail
// Removed order with deleted detail should include deleted detail
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection<Order>(order);
var orderDetails = (IList<OrderDetail>)changeTracker[0].OrderDetails;
var unchangedDetail = orderDetails[0];
var modifiedDetail = orderDetails[1];
var deletedDetail = orderDetails[2];
var addedDetail = new OrderDetail
{
ProductId = 1,
Product = database.Products[0],
Quantity = 10,
UnitPrice = 20M
};
orderDetails.Add(addedDetail);
modifiedDetail.UnitPrice++;
orderDetails.Remove(deletedDetail);
changeTracker.Remove(order);
// Act
var changes = changeTracker.GetChanges();
// Assert
var changedOrder = changes.First();
var changedExistingDetail = changedOrder.OrderDetails.SingleOrDefault(d => d.ProductId == unchangedDetail.ProductId);
var changedModifiedDetail = changedOrder.OrderDetails.SingleOrDefault(d => d.ProductId == modifiedDetail.ProductId);
var changedAddedDetail = changedOrder.OrderDetails.SingleOrDefault(d => d.ProductId == addedDetail.ProductId);
var changedDeletedDetail = changedOrder.OrderDetails.SingleOrDefault(d => d.ProductId == deletedDetail.ProductId);
Assert.Equal(TrackingState.Deleted, changedOrder.TrackingState);
Assert.Equal(3, changedOrder.OrderDetails.Count);
Assert.Equal(TrackingState.Deleted, changedModifiedDetail.TrackingState);
Assert.Equal(TrackingState.Deleted, changedExistingDetail.TrackingState);
Assert.Equal(TrackingState.Deleted, changedDeletedDetail.TrackingState);
Assert.Null(changedAddedDetail);
Assert.Equal(TrackingState.Unchanged, addedDetail.TrackingState);
}
