public void Removed_Existing_Modified_Items_Should_Be_Marked_As_Deleted()
{
// Arrange
var database = new MockNorthwind();
var changeTracker = new ChangeTrackingCollection <Product>(database.Products[0]);
var product = changeTracker[0];
product.UnitPrice++;
// Act
changeTracker.Remove(product);
// Assert
Assert.AreEqual(TrackingState.Deleted, product.TrackingState);
}
public void Items_Should_Be_Added_As_Unchanged_With_Enumerable_Ctor()
{
// Arrange
var database = new MockNorthwind();
var product = database.Products[0];
var products = new List <Product> {
product
};
// Act
var changeTracker = new ChangeTrackingCollection <Product>(products);
// Assert
Assert.AreEqual(TrackingState.Unchanged, changeTracker[0].TrackingState);
}
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 Modified_Existing_Excluded_Items_Should_Not_Be_Marked_As_Modified()
{
// Arrange
var database = new MockNorthwind();
var changeTracker = new ChangeTrackingCollection <Product>(database.Products[0]);
changeTracker.ExcludedProperties.Add("UnitPrice");
var product = changeTracker[0];
// Act
product.UnitPrice++;
// Assert
Assert.AreEqual(TrackingState.Unchanged, product.TrackingState);
}
public void IsEquatable_Should_Return_True_If_SetEntityIdentifier_Called()
{
// Arrange
var northwind = new MockNorthwind();
var customer1 = northwind.Customers[0];
var customer2 = northwind.Customers[1];
customer1.SetEntityIdentifier();
customer2.SetEntityIdentifier(customer1);
// Act
bool areEquatable = customer1.IsEquatable(customer2);
// Assert
Assert.IsTrue(areEquatable);
}
public void Added_Employee_After_Tracking_Enabled_Should_Not_Mark_Manually_Added_Territories_As_Unchanged()
{
// Arrange
var database = new MockNorthwind();
var employee = database.Employees[0];
employee.Territories.ToList().ForEach(t => t.TrackingState = TrackingState.Added);
var changeTracker = new ChangeTrackingCollection <Employee>(true);
// Act
changeTracker.Add(employee);
// Assert
Assert.Equal(TrackingState.Added, employee.TrackingState);
Assert.True(employee.Territories.All(t => t.TrackingState == TrackingState.Added));
}
public void Modified_Existing_Excluded_Items_Should_Not_Add_ModifiedProperty()
{
// Arrange
var database = new MockNorthwind();
var changeTracker = new ChangeTrackingCollection <Product>(database.Products[0]);
changeTracker.ExcludedProperties.Add("UnitPrice");
var product = changeTracker[0];
// Act
product.UnitPrice++;
// Assert
Assert.True(product.ModifiedProperties == null ||
product.ModifiedProperties.Count == 0);
}
public void Accept_Changes_Should_Mark_Order_With_Deleted_Customer_Unchanged()
{
// Arrange
var northwind = new MockNorthwind();
var order = northwind.Orders[0];
order.TrackingState = TrackingState.Modified;
order.Customer.TrackingState = TrackingState.Deleted;
// Act
order.AcceptChanges();
// Assert
Assert.Equal(TrackingState.Unchanged, order.TrackingState);
Assert.Equal(TrackingState.Unchanged, order.Customer.TrackingState);
}
public void Removed_Existing_Modified_Items_Should_Not_Have_ModifiedProperties()
{
// Arrange
var database = new MockNorthwind();
var changeTracker = new ChangeTrackingCollection <Product>(database.Products[0]);
var product = changeTracker[0];
product.UnitPrice++;
// Act
changeTracker.Remove(product);
// Assert
Assert.True(product.ModifiedProperties == null ||
product.ModifiedProperties.Count == 0);
}
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 State_Interceptor_Should_Mark_Many_To_Many_Entities_States(bool setState1, bool setState2)
{
// Arrange
var context = TestsHelper.CreateNorthwindDbContext(CreateNorthwindDbOptions);
var nw = new MockNorthwind();
var employee = nw.Employees[0];
var territory1 = employee.Territories[0];
var territory2 = employee.Territories[1];
employee.Territories = new List <Territory> {
territory1, territory2
};
territory1.TrackingState = TrackingState.Modified;
territory2.TrackingState = TrackingState.Modified;
// Act
var states = new[]
{
setState1?EntityState.Unchanged : null as EntityState?,
setState2 ? EntityState.Unchanged : null as EntityState?,
};
context
.WithStateChangeInterceptor <Territory>((e, r) =>
{
if (e.TerritoryId == "01581")
{
return(states[0]);
}
if (e.TerritoryId == "01730")
{
return(states[1]);
}
return(null);
})
.ApplyChanges(employee);
// Assert
var expectedStates = new[]
{
setState1?EntityState.Unchanged : EntityState.Modified,
setState2 ? EntityState.Unchanged : EntityState.Modified,
};
Assert.Equal(expectedStates[0], context.Entry(territory1).State);
Assert.Equal(expectedStates[1], context.Entry(territory2).State);
}
public void PromotionalProduct_Property_Setter_Should_Fire_PropertyChanged_Event()
{
// Arrange
var northwind = new MockNorthwind();
var product = northwind.Products.OfType <PromotionalProduct>().First();
var subscriber = new Subscriber <Product>
{
Model = product
};
// Act
product.PromoCode += "_X";
// Assert
Assert.True(subscriber.ModelChanged);
Assert.AreEqual("PromoCode", subscriber.ChangedPropertyName);
}
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 Removed_Items_Should_NOT_Disable_Change_Tracking_On_Related_Entities_OneToMany_ToOne()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var product = order.OrderDetails[0].Product;
var changeTracker = new ChangeTrackingCollection <Order>(order);
changeTracker.Remove(order);
// Act
product.ProductName = "XXX";
// Assert
Assert.Equal(TrackingState.Modified, product.TrackingState);
}
public void Removed_Items_Should_NOT_Disable_Change_Tracking_On_Related_Entities_ManyToOne()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var customer = order.Customer;
var changeTracker = new ChangeTrackingCollection <Order>(order);
changeTracker.Remove(order);
// Act
customer.CustomerName = "XXX";
// Assert
Assert.Equal(TrackingState.Modified, customer.TrackingState);
}
public void Removed_Items_Should_NOT_Disable_Change_Tracking_On_Related_Entities_ManyToMany()
{
// Arrange
var database = new MockNorthwind();
var employee = database.Employees[0];
var territory = employee.Territories[0];
var changeTracker = new ChangeTrackingCollection <Employee>(employee);
changeTracker.Remove(employee);
// Act
territory.TerritoryDescription = "XXX";
// Assert
Assert.Equal(TrackingState.Modified, territory.TrackingState);
}
public void Removed_Items_Should_Disable_Change_Tracking_On_Entity()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection <Order>(order);
changeTracker.Remove(order);
order.TrackingState = TrackingState.Unchanged;
// Act
order.OrderDate = order.OrderDate.AddDays(1);
// Assert
Assert.Equal(TrackingState.Unchanged, order.TrackingState);
}
public void Modified_Existing_Items_Should_Add_Multiples_ModifiedProperties()
{
// Arrange
var database = new MockNorthwind();
var changeTracker = new ChangeTrackingCollection <Product>(database.Products[0]);
var product = changeTracker[0];
// Act
product.UnitPrice++;
product.Discontinued = true;
product.ProductName = "xxxxxxxx";
// Assert
Assert.Contains("UnitPrice", product.ModifiedProperties);
Assert.Contains("Discontinued", product.ModifiedProperties);
Assert.Contains("ProductName", product.ModifiedProperties);
}
public void Tracking_Should_Be_Enabled_With_Enumerable_Ctor()
{
// Arrange
var database = new MockNorthwind();
var products = new List <Product> {
database.Products[0]
};
var product = database.Products[1];
// Act
var changeTracker = new ChangeTrackingCollection <Product>(products);
changeTracker.Add(product);
// Assert
Assert.Equal(TrackingState.Added, changeTracker[1].TrackingState);
}
public void HasChanges_Unchanged_Order_OrderDetail_Set_Product_To_Deleted_Product_Should_Return_True()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection <Order>(order);
var product = database.Products[0];
product.TrackingState = TrackingState.Deleted;
order.OrderDetails[0].Product = product;
// Act
bool hasChanges = order.HasChanges();
// Assert
Assert.True(hasChanges);
}
public void MergeChanges_Should_Set_TrackingState_To_Unchanged_For_Modified_Order_With_Updated_Customer()
{
// Arrange
var database = new MockNorthwind();
var origOrder = database.Orders[0];
var changeTracker = new ChangeTrackingCollection <Order>(origOrder);
origOrder.CustomerId = "ALFKI";
TrackingState origTrackingState = origOrder.TrackingState;
var updatedOrder = UpdateOrders(database, origOrder)[0];
// Act
changeTracker.MergeChanges(updatedOrder);
// Assert
Assert.Equal(TrackingState.Modified, origTrackingState);
Assert.Equal(TrackingState.Unchanged, origOrder.TrackingState);
}
public void Removed_Items_Should_Disable_Change_Tracking_On_Related_Entities_OneToMany()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var detail = order.OrderDetails[0];
var changeTracker = new ChangeTrackingCollection <Order>(order);
changeTracker.Remove(order);
detail.TrackingState = TrackingState.Unchanged;
// Act
detail.Quantity++;
// Assert
Assert.Equal(TrackingState.Unchanged, detail.TrackingState);
}
public void MergeChanges_Should_Set_Properties_For_Modified_Order_With_Updated_Customer()
{
// Arrange
var database = new MockNorthwind();
var origOrder = database.Orders[0];
var changeTracker = new ChangeTrackingCollection <Order>(origOrder);
origOrder.CustomerId = "ALFKI";
var updatedOrder = UpdateOrders(database, origOrder)[0];
// Act
changeTracker.MergeChanges(updatedOrder);
// Assert
Assert.AreEqual(updatedOrder.CustomerId, origOrder.CustomerId);
Assert.AreEqual(updatedOrder.Customer.CustomerId, origOrder.Customer.CustomerId);
Assert.AreEqual(updatedOrder.OrderDate, origOrder.OrderDate);
}
public void Modified_Existing_Mixed_Items_Should_Not_Be_Marked_As_Modified()
{
// Arrange
var database = new MockNorthwind();
var changeTracker = new ChangeTrackingCollection <Product>(database.Products[0]);
changeTracker.ExcludedProperties.Add("UnitPrice");
var product = changeTracker[0];
// Act
product.UnitPrice++;
product.ProductName = "xxxxxxxx";
// Assert
Assert.Equal(TrackingState.Modified, product.TrackingState);
Assert.Contains("ProductName", product.ModifiedProperties);
Assert.DoesNotContain("UnitPrice", product.ModifiedProperties);
}
public void HasChanges_Unchanged_Order_OrderDetail_With_Product_Set_To_Null_Should_Return_False()
{
// NOTE: Setting OrderDetail.Product to null is not considered a change,
// because it will not result in any updated entities.
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection <Order>(order);
order.OrderDetails[0].Product = null;
// Act
bool hasChanges = order.HasChanges();
// Assert
Assert.False(hasChanges);
}
public void MergeChanges_Should_Set_ModifiedProperties_To_Null_For_Modified_Order_With_Updated_Customer()
{
// Arrange
var database = new MockNorthwind();
var origOrder = database.Orders[0];
var changeTracker = new ChangeTrackingCollection <Order>(origOrder);
origOrder.CustomerId = "ALFKI";
var origModifiedProps = origOrder.ModifiedProperties;
var updatedOrder = UpdateOrders(database, origOrder)[0];
// Act
changeTracker.MergeChanges(updatedOrder);
// Assert
Assert.Contains("CustomerId", origModifiedProps);
Assert.Null(origOrder.ModifiedProperties);
}
public void Accept_Changes_Should_Not_Remove_Deleted_Customer_From_Order()
{
// NOTE: Reference entities cannot be deleted from a related entity, because
// of possible referential constraints, but they can be deleted independently.
// Arrange
var northwind = new MockNorthwind();
var order = northwind.Orders[0];
order.TrackingState = TrackingState.Modified;
order.Customer.TrackingState = TrackingState.Deleted;
// Act
order.AcceptChanges();
// Assert
Assert.NotNull(order.Customer);
Assert.Equal(TrackingState.Unchanged, order.Customer.TrackingState);
}
public void Accept_Changes_Should_Mark_Customer_With_Deleted_CustomerSetting_Unchanged()
{
// Arrange
var northwind = new MockNorthwind();
var customer = northwind.Customers[0];
customer.TrackingState = TrackingState.Modified;
customer.CustomerSetting = new CustomerSetting
{
TrackingState = TrackingState.Deleted
};
// Act
customer.AcceptChanges();
// Assert
Assert.Equal(TrackingState.Unchanged, customer.TrackingState);
Assert.Equal(TrackingState.Unchanged, customer.CustomerSetting.TrackingState);
}
public void Collection_Clone_Should_Deep_Copy_Category()
{
// Arrange
var database = new MockNorthwind();
var categoryOrig = database.Categories[0];
// Act
var categoryCopy = categoryOrig.Clone <Category>();
// Assert
Assert.AreNotSame(categoryOrig, categoryCopy);
Assert.AreNotSame(categoryOrig.Products[0], categoryCopy.Products[0]);
Assert.AreNotSame(categoryOrig.Products[1], categoryCopy.Products[1]);
Assert.AreEqual(categoryOrig.Products.Count, categoryCopy.Products.Count);
for (int i = 0; i < categoryOrig.Products.Count; ++i)
{
Assert.AreSame(categoryOrig.Products[i].GetType(), categoryCopy.Products[i].GetType());
}
}
public void State_Interceptor_Should_Mark_One_To_Many_Entities_States(bool setState1, bool setState2)
{
// Arrange
var context = TestsHelper.CreateNorthwindDbContext(CreateNorthwindDbOptions);
var order = new MockNorthwind().Orders[0];
var detail1 = order.OrderDetails[0];
var detail2 = order.OrderDetails[1];
detail1.TrackingState = TrackingState.Modified;
detail2.TrackingState = TrackingState.Modified;
// Act
var states = new[]
{
setState1?EntityState.Unchanged : null as EntityState?,
setState2 ? EntityState.Unchanged : null as EntityState?,
};
context
.WithStateChangeInterceptor <OrderDetail>((e, r) =>
{
if (e.OrderDetailId == 1)
{
return(states[0]);
}
if (e.OrderDetailId == 2)
{
return(states[1]);
}
return(null);
})
.ApplyChanges(order);
// Assert
var expectedStates = new[]
{
setState1?EntityState.Unchanged : EntityState.Modified,
setState2 ? EntityState.Unchanged : EntityState.Modified,
};
Assert.Equal(expectedStates[0], context.Entry(detail1).State);
Assert.Equal(expectedStates[1], context.Entry(detail2).State);
}
