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