public void GetChangeSet_CommitFalse_ContainsRemoves()
{
var expectedRemove = new TestItem();
var expectedItems = new List <TestItem>
{
new TestItem(),
expectedRemove,
new TestItem()
};
var subject = new ChangeTrackingCollection <TestItem>(expectedItems);
var basePath = ChangePath.Create("path");
Assert.True(subject.Remove(expectedRemove));
var result = subject.GetChangeSet(basePath);
var expectedPath = basePath.AppendIndex(1);
Assert.True(subject.HasChanges);
Assert.NotNull(result);
var kvp = Assert.Single(result);
Assert.Equal(ChangeTarget.Collection, kvp.Key.Target);
Assert.Contains(expectedPath, result as IDictionary <ChangePath, List <ChangeValue> >);
var values = result[expectedPath];
var value = Assert.Single(values);
Assert.Equal(ChangeAction.Remove, value.Action);
Assert.Null(value.NewValue);
Assert.Same(expectedRemove, value.OldValue);
}
public void ShouldRejectChangesWithModifiedAndRemovedItem()
{
Initialize();
var listItem = _listItems.First();
var c = new ChangeTrackingCollection <PocoListItemAdapter> (_listItems);
listItem.Description = "modified item";
c.Remove(listItem);
Assert.Equal("Description01", listItem.DescriptionOriginal);
Assert.Equal(1, c.Count);
Assert.Equal(0, c.AddedItems.Count);
Assert.Equal(0, c.ModifiedItems.Count);
Assert.Equal(1, c.RemovedItems.Count);
c.RejectChanges();
Assert.Equal(2, c.Count);
Assert.True(c.Contains(listItem));
Assert.Equal(0, c.AddedItems.Count);
Assert.Equal(0, c.ModifiedItems.Count);
Assert.Equal(0, c.RemovedItems.Count);
Assert.False(listItem.IsChanged);
Assert.Equal("Description01", listItem.Description);
Assert.Equal("Description01", listItem.DescriptionOriginal);
Assert.False(c.IsChanged);
}
public void ShouldRejectChangesWithModifiedAndRemovedItem()
{
var email = _emails.First();
var c = new ChangeTrackingCollection <FriendEmailWrapper>(_emails);
email.Email = "*****@*****.**";
c.Remove(email);
Assert.AreEqual("*****@*****.**", email.EmailOriginalValue);
Assert.AreEqual(1, c.Count);
Assert.AreEqual(0, c.AddedItems.Count);
Assert.AreEqual(0, c.ModifiedItems.Count);
Assert.AreEqual(1, c.RemovedItems.Count);
c.RejectChanges();
Assert.AreEqual(2, c.Count);
Assert.IsTrue(c.Contains(email));
Assert.AreEqual(0, c.AddedItems.Count);
Assert.AreEqual(0, c.ModifiedItems.Count);
Assert.AreEqual(0, c.RemovedItems.Count);
Assert.IsFalse(email.IsChanged);
Assert.AreEqual("*****@*****.**", email.Email);
Assert.AreEqual("*****@*****.**", email.EmailOriginalValue);
Assert.IsFalse(c.IsChanged);
}
public void Reset_HasChangesTrue_ResetsAllchanges()
{
var removeMe = new TestItem();
var expectedOldValue = "My old value";
var expectedNewValue = "The new value";
var expectedUpdate = new TestItem
{
StringValue = expectedOldValue
};
var expectedItems = new List <TestItem>
{
removeMe,
expectedUpdate
};
var subject = new ChangeTrackingCollection <TestItem>(expectedItems);
expectedUpdate.StringValue = expectedNewValue;
subject.Add(new TestItem());
subject.Remove(removeMe);
subject.Reset();
Assert.False(subject.HasChanges);
var changes = subject.GetChangeSet(ChangePath.Empty);
Assert.Null(changes);
Assert.False(expectedUpdate.HasChanges);
}
public void ShouldTrackAddedItems()
{
Initialize();
var listItemToAdd = new PocoListItemAdapter(new PocoListItem());
var c = new ChangeTrackingCollection <PocoListItemAdapter>(_listItems);
Assert.Equal(2, c.Count);
Assert.False(c.IsChanged);
c.Add(listItemToAdd);
Assert.Equal(3, c.Count);
Assert.Equal(1, c.AddedItems.Count);
Assert.Equal(0, c.RemovedItems.Count);
Assert.Equal(0, c.ModifiedItems.Count);
Assert.Equal(listItemToAdd, c.AddedItems.First());
Assert.True(c.IsChanged);
c.Remove(listItemToAdd);
Assert.Equal(2, c.Count);
Assert.Equal(0, c.AddedItems.Count);
Assert.Equal(0, c.RemovedItems.Count);
Assert.Equal(0, c.ModifiedItems.Count);
Assert.False(c.IsChanged);
}
public void ShoudNotTrackRemovedItemAsModified()
{
var wordToAdd = new WordWrapper(new Word());
var collection = new ChangeTrackingCollection<WordWrapper>(words);
Assert.AreEqual(2, collection.Count);
Assert.IsFalse(collection.IsChanged);
collection.Add(wordToAdd);
Assert.AreEqual(3, collection.Count);
Assert.AreEqual(1, collection.AddedItems.Count);
Assert.AreEqual(0, collection.RemovedItems.Count);
Assert.AreEqual(0, collection.ModifiedItems.Count);
Assert.AreEqual(wordToAdd, collection.AddedItems.First());
Assert.IsTrue(collection.IsChanged);
collection.Remove(wordToAdd);
Assert.AreEqual(2, collection.Count);
Assert.AreEqual(0, collection.AddedItems.Count);
Assert.AreEqual(0, collection.RemovedItems.Count);
Assert.AreEqual(0, collection.ModifiedItems.Count);
Assert.IsFalse(collection.IsChanged);
}
public void ShouldTrackRemovedItems()
{
var emailToRemove = _emails.First();
var c = new ChangeTrackingCollection <FriendEmailWrapper>(_emails);
Assert.Equal(2, c.Count);
Assert.False(c.IsChanged);
c.Remove(emailToRemove);
Assert.Equal(1, c.Count);
Assert.Equal(0, c.AddedItems.Count);
Assert.Equal(1, c.RemovedItems.Count);
Assert.Equal(0, c.ModifiedItems.Count);
Assert.Equal(emailToRemove, c.RemovedItems.First());
Assert.True(c.IsChanged);
c.Add(emailToRemove);
Assert.Equal(2, c.Count);
Assert.Equal(0, c.AddedItems.Count);
Assert.Equal(0, c.RemovedItems.Count);
Assert.Equal(0, c.ModifiedItems.Count);
Assert.False(c.IsChanged);
}
public void GetChangeSet_CommitTrue_MakesChangesPermanent()
{
var removeMe = ChangeTrackingObject.CreateTrackable <TestItem>();
var expectedUpdate = ChangeTrackingObject.CreateTrackable <TestItem>();
var expectedItems = new List <TestItem>
{
removeMe,
expectedUpdate
};
var subject = new ChangeTrackingCollection <TestItem>(expectedItems);
subject.Add(new TestItem());
subject.Remove(removeMe);
var expectedNewValue = "New Value";
expectedUpdate.StringValue = expectedNewValue;
var result = subject.GetChangeSet(ChangePath.Empty, commit: true);
Assert.Equal(3, result.Count);
Assert.False(subject.HasChanges);
Assert.False(expectedUpdate.HasChanges);
Assert.Equal(expectedNewValue, expectedUpdate.StringValue);
Assert.DoesNotContain(removeMe, subject);
Assert.Equal(2, subject.Count);
}
public void Should_Reject_Changes_With_Modified_And_Removed_Items()
{
var listItem = _listItems.First();
var c = new ChangeTrackingCollection <PocoListItemAdapter>(_listItems);
listItem.Description = "modified item";
c.Remove(listItem);
Assert.AreEqual("Description01", listItem.DescriptionOriginal);
Assert.AreEqual(1, c.Count);
Assert.AreEqual(0, c.AddedItems.Count);
Assert.AreEqual(0, c.ModifiedItems.Count);
Assert.AreEqual(1, c.RemovedItems.Count);
c.RejectChanges();
Assert.AreEqual(2, c.Count);
Assert.IsTrue(c.Contains(listItem));
Assert.AreEqual(0, c.AddedItems.Count);
Assert.AreEqual(0, c.ModifiedItems.Count);
Assert.AreEqual(0, c.RemovedItems.Count);
Assert.IsFalse(listItem.IsChanged);
Assert.AreEqual("Description01", listItem.Description);
Assert.AreEqual("Description01", listItem.DescriptionOriginal);
Assert.IsFalse(c.IsChanged);
}
public void Remove_FalseWhenNotFound()
{
var expectedItems = new List <TestItem>
{
new TestItem(),
new TestItem(),
new TestItem()
};
var subject = new ChangeTrackingCollection <TestItem>(expectedItems);
Assert.False(subject.Remove(new TestItem()));
}
public void Removed_Existing_Unchanged_Items_Should_Be_Marked_As_Deleted()
{
// Arrange
var database = new MockNorthwind();
var changeTracker = new ChangeTrackingCollection <Product>(database.Products[0]);
var product = changeTracker[0];
// Act
changeTracker.Remove(product);
// Assert
Assert.Equal(TrackingState.Deleted, product.TrackingState);
}
public void HasChanges_TrueWhenRemove()
{
var expectedItems = new List <TestItem>
{
new TestItem(),
new TestItem(),
new TestItem()
};
var subject = new ChangeTrackingCollection <TestItem>(expectedItems);
subject.Remove(expectedItems[0]);
Assert.True(subject.HasChanges);
}
public void HasChanges_Deleted_Parent_Should_Return_True()
{
// Arrange
var parent = new Parent("Parent");
var changeTracker = new ChangeTrackingCollection <Parent>(parent);
changeTracker.Remove(parent);
// Act
bool hasChanges = parent.HasChanges();
// Assert
Assert.True(hasChanges);
}
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 Collection_Set_State_As_Deleted_Should_Mark_Children_As_Deleted()
{
// Arrange
var parent = _family.Parent;
var changeTracker = new ChangeTrackingCollection <Parent>(parent);
// Act
changeTracker.Remove(parent);
// Assert
Assert.AreEqual(TrackingState.Deleted, parent.TrackingState);
IEnumerable <TrackingState> trackings = GetStates(parent);
Assert.IsTrue(trackings.All(t => t == TrackingState.Deleted));
}
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 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_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_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_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 Add_ItemAlreadyRemovedGetsRestored()
{
var expectedItems = new List <TestItem>
{
new TestItem(),
new TestItem(),
new TestItem()
};
var subject = new ChangeTrackingCollection <TestItem>(expectedItems);
subject.Remove(expectedItems[0]);
Assert.True(subject.HasChanges);
Assert.Equal(2, subject.Count);
subject.Add(expectedItems[0]);
Assert.False(subject.HasChanges);
Assert.Contains(expectedItems[0], subject);
}
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 EntityChanged_Event_Should_Fire_When_Items_Added_Modified_Deleted()
{
// Arrange
int changesCount = 0;
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.EntityChanged += (s, e) => changesCount++;
// Act
changeTracker.Add(addedProduct);
updatedProduct.UnitPrice++;
changeTracker.Remove(deletedProduct);
// Assert
Assert.Equal(3, changesCount);
}
public void ShouldNotTrackRemovedItemAsModified()
{
FriendEmailWrapper emailToModifyAndRemove = _emails.First();
ChangeTrackingCollection <FriendEmailWrapper> c = new ChangeTrackingCollection <FriendEmailWrapper>(_emails);
emailToModifyAndRemove.Email = "*****@*****.**";
Assert.AreEqual(2, c.Count);
Assert.AreEqual(0, c.AddedItems.Count);
Assert.AreEqual(0, c.RemovedItems.Count);
Assert.AreEqual(1, c.ModifiedItems.Count);
Assert.AreEqual(emailToModifyAndRemove, c.ModifiedItems.First());
Assert.IsTrue(c.IsChanged);
c.Remove(emailToModifyAndRemove);
Assert.AreEqual(1, c.Count);
Assert.AreEqual(0, c.AddedItems.Count);
Assert.AreEqual(1, c.RemovedItems.Count);
Assert.AreEqual(0, c.ModifiedItems.Count);
Assert.AreEqual(emailToModifyAndRemove, c.RemovedItems.First());
Assert.IsTrue(c.IsChanged);
}
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 ShouldNotTrackRemovedItemsAsModified()
{
var emailToModifyAndRemove = _emails.First();
var c = new ChangeTrackingCollection <EmailWrapper>(_emails);
emailToModifyAndRemove.EmailAddress = "*****@*****.**";
Assert.AreEqual(2, c.Count);
Assert.AreEqual(0, c.AddedItems.Count);
Assert.AreEqual(0, c.RemovedItems.Count);
Assert.AreEqual(1, c.ModifiedItems.Count);
Assert.AreEqual(emailToModifyAndRemove, c.ModifiedItems.First());
Assert.IsTrue(c.IsChanged);
c.Remove(emailToModifyAndRemove);
Assert.AreEqual(1, c.Count);
Assert.AreEqual(0, c.AddedItems.Count);
Assert.AreEqual(1, c.RemovedItems.Count);
Assert.AreEqual(0, c.ModifiedItems.Count);
Assert.AreEqual(emailToModifyAndRemove, c.RemovedItems.First());
Assert.IsTrue(c.IsChanged);
}
public void Removed_Items_Should_NOT_Disable_Change_Tracking_On_Related_Entities_OneToOne()
{
// Arrange
var database = new MockNorthwind();
var customer = database.Orders[0].Customer;
var setting = customer.CustomerSetting = new CustomerSetting
{
CustomerId = customer.CustomerId,
Customer = customer,
Setting = "Setting1"
};
var changeTracker = new ChangeTrackingCollection <Customer>(customer);
changeTracker.Remove(customer);
// Act
setting.Setting = "XXX";
// Assert
Assert.Equal(TrackingState.Modified, setting.TrackingState);
}
public void ShouldTrackRemovedAsModified()
{
var emailToModifyAndRemove = _emails.First();
var trackingCollection = new ChangeTrackingCollection <EmailWrapper>(_emails);
emailToModifyAndRemove.EmailAddress = "*****@*****.**";
Assert.AreEqual(2, trackingCollection.Count);
Assert.AreEqual(0, trackingCollection.AddedItems.Count);
Assert.AreEqual(0, trackingCollection.RemovedItems.Count);
Assert.AreEqual(1, trackingCollection.ModifiedItems.Count);
Assert.AreEqual(emailToModifyAndRemove, trackingCollection.ModifiedItems.First());
Assert.IsTrue(trackingCollection.IsChanged);
trackingCollection.Remove(emailToModifyAndRemove);
Assert.AreEqual(1, trackingCollection.Count);
Assert.AreEqual(0, trackingCollection.AddedItems.Count);
Assert.AreEqual(1, trackingCollection.RemovedItems.Count);
Assert.AreEqual(0, trackingCollection.ModifiedItems.Count);
Assert.AreEqual(emailToModifyAndRemove, trackingCollection.RemovedItems.First());
Assert.IsTrue(trackingCollection.IsChanged);
}
public void Should_Not_Track_Removed_Item_As_Modified()
{
var listItemToModifyAndRemove = _listItems.First();
var c = new ChangeTrackingCollection <PocoListItemAdapter>(_listItems);
listItemToModifyAndRemove.Description = "modified entry";
Assert.AreEqual(2, c.Count);
Assert.AreEqual(0, c.AddedItems.Count);
Assert.AreEqual(0, c.RemovedItems.Count);
Assert.AreEqual(1, c.ModifiedItems.Count);
Assert.AreEqual(listItemToModifyAndRemove, c.ModifiedItems.First());
Assert.IsTrue(c.IsChanged);
c.Remove(listItemToModifyAndRemove);
Assert.AreEqual(1, c.Count);
Assert.AreEqual(0, c.AddedItems.Count);
Assert.AreEqual(1, c.RemovedItems.Count);
Assert.AreEqual(0, c.ModifiedItems.Count);
Assert.AreEqual(listItemToModifyAndRemove, c.RemovedItems.First());
Assert.IsTrue(c.IsChanged);
}
public void ShouldAcceptChanges()
{
var emailToModify = _emails.First();
var emailToRemove = _emails.Skip(1).First();
var emailToAdd = new FriendEmailWrapper(new FriendEmail {
Email = "*****@*****.**"
});
var c = new ChangeTrackingCollection <FriendEmailWrapper>(_emails)
{
emailToAdd
};
c.Remove(emailToRemove);
emailToModify.Email = "*****@*****.**";
Assert.Equal("*****@*****.**", emailToModify.EmailOriginalValue);
Assert.Equal(2, c.Count);
Assert.Equal(1, c.AddedItems.Count);
Assert.Equal(1, c.ModifiedItems.Count);
Assert.Equal(1, c.RemovedItems.Count);
c.AcceptChanges();
Assert.Equal(2, c.Count);
Assert.True(c.Contains(emailToModify));
Assert.True(c.Contains(emailToAdd));
Assert.Equal(0, c.AddedItems.Count);
Assert.Equal(0, c.ModifiedItems.Count);
Assert.Equal(0, c.RemovedItems.Count);
Assert.False(emailToModify.IsChanged);
Assert.Equal("*****@*****.**", emailToModify.Email);
Assert.Equal("*****@*****.**", emailToModify.EmailOriginalValue);
Assert.False(c.IsChanged);
}
public void ShouldRejectChanges()
{
Initialize();
var listItemToAdd = new PocoListItemAdapter(new PocoListItem {
Id = 3, Title = "TestItem03", Description = "Description03"
});
var listItemToModify = _listItems.First();
var listItemToRemove = _listItems.Skip(1).First();
var c = new ChangeTrackingCollection <PocoListItemAdapter>(_listItems);
c.Add(listItemToAdd);
c.Remove(listItemToRemove);
listItemToModify.Description = "modified item";
Assert.Equal("Description01", listItemToModify.DescriptionOriginal);
Assert.Equal(2, c.Count);
Assert.Equal(1, c.AddedItems.Count);
Assert.Equal(1, c.ModifiedItems.Count);
Assert.Equal(1, c.RemovedItems.Count);
c.RejectChanges();
Assert.Equal(2, c.Count);
Assert.True(c.Contains(listItemToModify));
Assert.True(c.Contains(listItemToRemove));
Assert.Equal(0, c.AddedItems.Count);
Assert.Equal(0, c.ModifiedItems.Count);
Assert.Equal(0, c.RemovedItems.Count);
Assert.False(listItemToModify.IsChanged);
Assert.Equal("Description01", listItemToModify.Description);
Assert.Equal("Description01", listItemToModify.DescriptionOriginal);
Assert.False(c.IsChanged);
}
public void Removed_Order_With_New_Customer_Should_Mark_Customer_As_Unchanged()
{
// NOTE: Setting Order.Customer to null will not mark customer as deleted.
// Because customer not marked as deleted, it refers to an existing customer.
// 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
changeTracker.Remove(order);
// Assert
Assert.Equal(TrackingState.Deleted, order.TrackingState);
Assert.Equal(TrackingState.Unchanged, order.Customer.TrackingState);
Assert.True(order.HasChanges());
}
public void Existing_Order_Removed_With_Modified_Customer_Has_Children_ModifiedProperties_Cleared()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection<Order>(order);
var modifiedCustomer = order.Customer;
modifiedCustomer.CustomerName = "xxx";
order.OrderDetails[0].ModifiedProperties = new List<string> { "UnitPrice "};
// Act
changeTracker.Remove(order);
// Assert
Assert.True(modifiedCustomer.ModifiedProperties.Count == 1);
Assert.True(order.OrderDetails[0].ModifiedProperties == null);
}
public void Existing_Parent_Removed_With_Modified_Children_Should_Have_Children_Modified_Properties_Cleared()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var orderDetails = (IList<OrderDetail>)order.OrderDetails;
var orderDetail = orderDetails[0];
var changeTracker = new ChangeTrackingCollection<Order>(order);
orderDetail.Quantity++;
// Act
changeTracker.Remove(order);
// Assert
Assert.True(orderDetail.ModifiedProperties == null
|| orderDetail.ModifiedProperties.Count == 0);
}
public void EntityChanged_Event_Should_Fire_When_Items_Added_Modified_Deleted()
{
// Arrange
int changesCount = 0;
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.EntityChanged += (s, e) => changesCount++;
// Act
changeTracker.Add(addedProduct);
updatedProduct.UnitPrice++;
changeTracker.Remove(deletedProduct);
// Assert
Assert.AreEqual(3, changesCount);
}
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 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.AreEqual(TrackingState.Modified, territory.TrackingState);
}
public void Added_Parent_Then_Removed_Should_Have_Children_Marked_As_Unchanged()
{
// Arrange
var database = new MockNorthwind();
var changeTracker = new ChangeTrackingCollection<Order>(true);
var order = database.Orders[0];
var orderDetails = (IList<OrderDetail>)order.OrderDetails;
var orderDetail = orderDetails[0];
// Act
changeTracker.Add(order);
changeTracker.Remove(order);
// Assert
Assert.Equal(TrackingState.Unchanged, order.TrackingState);
Assert.Equal(TrackingState.Unchanged, orderDetail.TrackingState);
}
public void Existing_Employee_Removed_With_Modified_Children_Have_Children_ModifiedProperties_Cleared()
{
// Arrange
var database = new MockNorthwind();
var employee = database.Employees[0];
var changeTracker = new ChangeTrackingCollection<Employee>(employee);
var modifiedTerritory = employee.Territories[1];
modifiedTerritory.TerritoryDescription = "xxx";
// Act
changeTracker.Remove(employee);
// Assert
Assert.True(modifiedTerritory.ModifiedProperties == null
|| modifiedTerritory.ModifiedProperties.Count == 0);
}
public void HasChanges_Deleted_Parent_Should_Return_True()
{
// Arrange
var parent = new Parent("Parent");
var changeTracker = new ChangeTrackingCollection<Parent>(parent);
changeTracker.Remove(parent);
// Act
bool hasChanges = parent.HasChanges();
// Assert
Assert.True(hasChanges);
}
public void Removed_Items_Should_NOT_Disable_Change_Tracking_On_Related_Entities_OneToOne()
{
// Arrange
var database = new MockNorthwind();
var customer = database.Orders[0].Customer;
var setting = customer.CustomerSetting = new CustomerSetting
{
CustomerId = customer.CustomerId,
Customer = customer,
Setting = "Setting1"
};
var changeTracker = new ChangeTrackingCollection<Customer>(customer);
changeTracker.Remove(customer);
// Act
setting.Setting = "XXX";
// Assert
Assert.AreEqual(TrackingState.Modified, setting.TrackingState);
}
public void Removed_Employee_With_Territories_Should_Have_Territories_Marked_As_Deleted()
{
// NOTE: Removing a parent will mark both parent and children as deleted.
// Deleted M-M childen are simply removed from the relation with parent.
//
// 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];
// Act
modifiedTerritory.TerritoryDescription = "xxx";
employee.Territories.Add(addedTerritory);
employee.Territories.Remove(deletedTerritory);
changeTracker.Remove(employee);
// Assert
Assert.Equal(TrackingState.Deleted, employee.TrackingState);
Assert.Equal(TrackingState.Unchanged, unchangedTerritory.TrackingState);
Assert.Equal(TrackingState.Modified, modifiedTerritory.TrackingState);
Assert.Equal(TrackingState.Unchanged, addedTerritory.TrackingState);
Assert.Equal(TrackingState.Deleted, deletedTerritory.TrackingState);
}
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.AreEqual(TrackingState.Modified, product.TrackingState);
}
public void Added_Employee_Then_Removed_With_Territories_Should_Have_Territories_Marked_As_Unchanged()
{
// NOTE: Removing an added parent should mark parent and children as unchanged.
// This is so that GetChanges will not include parent or children.
// Arrange
var database = new MockNorthwind();
var changeTracker = new ChangeTrackingCollection<Employee>(true);
var employee = database.Employees[0];
var unchangedTerritory = employee.Territories[0];
var modifiedTerritory = employee.Territories[1];
var deletedTerritory = employee.Territories[2];
var addedTerritory = database.Territories[3];
changeTracker.Add(employee);
// Act
modifiedTerritory.TerritoryDescription = "xxx";
employee.Territories.Add(addedTerritory); // stays added
employee.Territories.Remove(deletedTerritory); // from added to unchanged
changeTracker.Remove(employee);
// Assert
Assert.Equal(TrackingState.Unchanged, employee.TrackingState);
Assert.Equal(TrackingState.Unchanged, unchangedTerritory.TrackingState);
Assert.Equal(TrackingState.Unchanged, modifiedTerritory.TrackingState);
Assert.Equal(TrackingState.Unchanged, addedTerritory.TrackingState);
Assert.Equal(TrackingState.Unchanged, deletedTerritory.TrackingState);
}
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);
}
public void Removed_Added_Items_Should_Be_Marked_As_Unchanged()
{
// Arrange
var database = new MockNorthwind();
var changeTracker = new ChangeTrackingCollection<Product>();
changeTracker.Tracking = true;
var product = new Product
{
ProductId = 100,
ProductName = "Test Beverage",
CategoryId = 1,
Category = database.Categories[0],
UnitPrice = 10M
};
// Act
changeTracker.Add(product);
product.UnitPrice++;
changeTracker.Remove(product);
// Assert
Assert.AreEqual(TrackingState.Unchanged, product.TrackingState);
}
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);
}
public void Removed_Added_Modified_Items_Should_Not_Have_ModifiedProperties()
{
// Arrange
var database = new MockNorthwind();
var changeTracker = new ChangeTrackingCollection<Product>(true);
var product = new Product
{
ProductId = 100,
ProductName = "Test Beverage",
CategoryId = 1,
Category = database.Categories[0],
UnitPrice = 10M
};
// Act
changeTracker.Add(product);
product.UnitPrice++;
changeTracker.Remove(product);
// Assert
Assert.IsTrue(product.ModifiedProperties == null
|| product.ModifiedProperties.Count == 0);
}
public void Existing_Parent_Removed_With_Modified_Children_Should_Have_Children_Marked_As_Deleted()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var orderDetails = (IList<OrderDetail>)order.OrderDetails;
var orderDetail = orderDetails[0];
var changeTracker = new ChangeTrackingCollection<Order>(order);
orderDetail.Quantity++;
// Act
changeTracker.Remove(order);
// Assert
Assert.Equal(TrackingState.Deleted, order.TrackingState);
Assert.Equal(TrackingState.Deleted, orderDetail.TrackingState);
}
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 Removed_Order_With_Removed_Customer_Should_Mark_Customer_As_Unchanged()
{
// NOTE: Removed customer will not be marked as deleted. Instead to be deleted
// it must be independently marked as deleted.
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection<Order>(order);
var customer = order.Customer;
order.Customer = null;
// Act
changeTracker.Remove(order);
// Assert
Assert.Equal(TrackingState.Deleted, order.TrackingState);
Assert.Equal(TrackingState.Unchanged, customer.TrackingState);
Assert.True(order.HasChanges());
}
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.IsTrue(product.ModifiedProperties == null
|| product.ModifiedProperties.Count == 0);
}
public void Removed_Order_With_Manually_Added_Customer_Should_Mark_Customer_As_Added()
{
// NOTE: Manually marking reference as added will create a new entity
// when it is saved.
// 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
changeTracker.Remove(order);
// Assert
Assert.Equal(TrackingState.Deleted, order.TrackingState);
Assert.Equal(TrackingState.Added, order.Customer.TrackingState);
Assert.True(order.HasChanges());
}
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.AreEqual(TrackingState.Unchanged, order.TrackingState);
}
public void Removed_Order_With_Modified_Customer_Should_Mark_Customer_As_Modified()
{
// NOTE: Modified reference entity will remain modified if parent is deleted.
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection<Order>(order);
order.Customer.CustomerName = "xxx";
// Act
changeTracker.Remove(order);
// Assert
Assert.Equal(TrackingState.Deleted, order.TrackingState);
Assert.Equal(TrackingState.Modified, order.Customer.TrackingState);
Assert.True(order.HasChanges());
}
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.AreEqual(TrackingState.Unchanged, detail.TrackingState);
}
public void Removed_Order_With_Unchanged_Customer_Should_Mark_Customer_As_Unchanged()
{
// NOTE: Removing order will not automatically mark customer as deleted.
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection<Order>(order);
var customer = order.Customer;
// Act
changeTracker.Remove(order);
// Assert
Assert.Equal(TrackingState.Deleted, order.TrackingState);
Assert.Equal(TrackingState.Unchanged, order.Customer.TrackingState);
Assert.True(order.HasChanges());
}
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.AreEqual(TrackingState.Modified, customer.TrackingState);
}
