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 Existing_Parent_With_Added_Children_Should_Have_Children_Marked_As_Added()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection<Order>(order);
var orderDetails = (IList<OrderDetail>)changeTracker[0].OrderDetails;
var addedDetail1 = new OrderDetail
{
ProductId = 1,
Product = database.Products[0],
Quantity = 10,
UnitPrice = 20M
};
var addedDetail2 = new OrderDetail
{
ProductId = 2,
Product = database.Products[1],
Quantity = 20,
UnitPrice = 30M
};
// Act
orderDetails.Add(addedDetail1);
orderDetails.Add(addedDetail2);
// Assert
Assert.Equal(TrackingState.Added, addedDetail1.TrackingState);
Assert.Equal(TrackingState.Added, addedDetail2.TrackingState);
}
public void Existing_Parent_With_Children_Should_Have_Children_Marked()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection<Order>(order);
var orderDetails = (IList<OrderDetail>)changeTracker[0].OrderDetails;
var addedDetail = new OrderDetail
{
ProductId = 1,
Product = database.Products[0],
Quantity = 10,
UnitPrice = 20M
};
var modifiedDetail = orderDetails[0];
var deletedDetail = orderDetails[1];
addedDetail.Order = order;
modifiedDetail.Order = order;
deletedDetail.Order = order;
// Act
modifiedDetail.UnitPrice++;
orderDetails.Remove(deletedDetail);
orderDetails.Add(addedDetail);
// Assert
Assert.Equal(TrackingState.Added, addedDetail.TrackingState);
Assert.Equal(TrackingState.Modified, modifiedDetail.TrackingState);
Assert.Equal(TrackingState.Deleted, deletedDetail.TrackingState);
}
public void WhenISubmitPostToCreateAnEntity()
{
ScenarioContext.Current.Pending();
var customer = ScenarioContext.Current.Get<Customer>("Customer");
var changeTracker = new ChangeTrackingCollection<Customer>(true) { customer };
Customer result = _client.CreateEntity(customer);
changeTracker.MergeChanges(result);
}
/// <summary>
/// Keep underlying model collection synchronized with wrapper-collection.
/// Note: wrapper-collection performs change-notification and change-tracking.
/// </summary>
/// <typeparam name="TWrapper">Wrapper class</typeparam>
/// <typeparam name="TModel">Underlying class</typeparam>
/// <param name="wrapperCollection">ChangeTrackingCollection</param>
/// <param name="modelCollection">Underlying generic collection</param>
protected void RegisterCollection <TWrapper, TModel>(
ChangeTrackingCollection <TWrapper> wrapperCollection,
List <TModel> modelCollection) where TWrapper : ModelWrapper <TModel>
{
// Synchronize underlying model collection with wrapperCollection
wrapperCollection.CollectionChanged += (s, e) =>
{
modelCollection.Clear();
modelCollection.AddRange(wrapperCollection.Select(w => w.Model));
};
RegisterTrackingObject(wrapperCollection);
}
public void Items_Should_Be_Added_As_Unchanged_With_Array_Ctor()
{
// Arrange
var database = new MockNorthwind();
var product = database.Products[0];
// Act
var changeTracker = new ChangeTrackingCollection <Product>(product);
// Assert
Assert.AreEqual(TrackingState.Unchanged, changeTracker[0].TrackingState);
}
public void Modified_Existing_Items_Should_Add_ModifiedProperty()
{
// Arrange
var database = new MockNorthwind();
var changeTracker = new ChangeTrackingCollection <Product>(database.Products[0]);
var product = changeTracker[0];
// Act
product.UnitPrice++;
// Assert
Assert.Contains("UnitPrice", product.ModifiedProperties);
}
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 Modified_Existing_Items_Should_Be_Marked_As_Modified()
{
// Arrange
var database = new MockNorthwind();
var changeTracker = new ChangeTrackingCollection <Product>(database.Products[0]);
var product = changeTracker[0];
// Act
product.UnitPrice++;
// Assert
Assert.Equal(TrackingState.Modified, 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 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 Added_Items_After_Tracking_Enabled_Should_Be_Marked_As_Added()
{
// Arrange
var database = new MockNorthwind();
var product = database.Products[0];
var changeTracker = new ChangeTrackingCollection <Product>(true);
// Act
changeTracker.Add(product);
// Assert
Assert.Equal(TrackingState.Added, product.TrackingState);
}
public void HasChanges_Unchanged_Employee_With_Unchanged_Territories_Should_Return_False()
{
// Arrange
var database = new MockNorthwind();
var employee = database.Employees[0];
var changeTracker = new ChangeTrackingCollection <Employee>(employee);
// Act
bool hasChanges = employee.HasChanges();
// Assert
Assert.False(hasChanges);
}
public void Contains_ReturnsFalseWhenNotFound()
{
var findMe = new TestItem();
var expectedItems = new List <TestItem>
{
new TestItem(),
new TestItem(),
new TestItem()
};
var subject = new ChangeTrackingCollection <TestItem>(expectedItems);
Assert.DoesNotContain(findMe, subject);
}
public void Contains_ReturnsTrueWhenFound()
{
var findMe = new TestItem();
var expectedItems = new List <TestItem>
{
new TestItem(),
findMe,
new TestItem()
};
var subject = new ChangeTrackingCollection <TestItem>(expectedItems);
Assert.Contains(findMe, subject);
}
public void WhenISubmitPostToCreateAnEntity()
{
ScenarioContext.Current.Pending();
var customer = ScenarioContext.Current.Get <Customer>("Customer");
var changeTracker = new ChangeTrackingCollection <Customer>(true)
{
customer
};
Customer result = _client.CreateEntity(customer);
changeTracker.MergeChanges(result);
}
public void Tracking_Should_Be_Disabled_With_Default_Ctor()
{
// Arrange
var database = new MockNorthwind();
var product = database.Products[0];
var changeTracker = new ChangeTrackingCollection<Product>();
// Act
changeTracker.Add(product);
// Assert
Assert.AreEqual(TrackingState.Unchanged, changeTracker[0].TrackingState);
}
public void MergeChanges_On_Equatable_PromotionalProduct_Should_Not_Throw_ArgumentException()
{
// Arrange
var product = new MockNorthwind().Products.OfType <PromotionalProduct>().First();
var changeTracker = new ChangeTrackingCollection <PromotionalProduct>(product);
var clonedProduct = product.Clone();
// Act
changeTracker.MergeChanges(clonedProduct);
// Assert
Assert.True(true);
}
public void Tracking_Should_Be_Enabled_With_Array_Ctor()
{
// Arrange
var database = new MockNorthwind();
var product = database.Products[1];
// Act
var changeTracker = new ChangeTrackingCollection<Product>(database.Products[0]);
changeTracker.Add(product);
// Assert
Assert.AreEqual(TrackingState.Added, changeTracker[1].TrackingState);
}
public void Tracking_Should_Be_Disabled_With_Default_Ctor()
{
// Arrange
var database = new MockNorthwind();
var product = database.Products[0];
var changeTracker = new ChangeTrackingCollection <Product>();
// Act
changeTracker.Add(product);
// Assert
Assert.Equal(TrackingState.Unchanged, changeTracker[0].TrackingState);
}
public void Tracking_Should_Be_Enabled_With_Array_Ctor()
{
// Arrange
var database = new MockNorthwind();
var product = database.Products[1];
// Act
var changeTracker = new ChangeTrackingCollection <Product>(database.Products[0]);
changeTracker.Add(product);
// Assert
Assert.Equal(TrackingState.Added, changeTracker[1].TrackingState);
}
protected override void InitializeCollectionProperties(Account model)
{
if (model.Addresses == null)
{
throw new ArgumentException("Addresses cannot be null");
}
Addresses = new ChangeTrackingCollection <AddressWrapper>(model.Addresses.Select(e => new AddressWrapper(e)));
RegisterCollection(Addresses, model.Addresses);
if (model.AccountAttributes == null)
{
throw new ArgumentException("AccountAttributes cannot be null");
}
AccountAttributes = new ChangeTrackingCollection <EntityAttributeWrapper>(model.AccountAttributes.Select(e => new EntityAttributeWrapper(e)));
RegisterCollection(AccountAttributes, model.AccountAttributes);
if (model.FeeSchedules == null)
{
throw new ArgumentException("FeeSchedules cannot be null");
}
FeeSchedules = new ChangeTrackingCollection <FeeScheduleWrapper>(model.FeeSchedules.Select(e => new FeeScheduleWrapper(e)));
RegisterCollection(FeeSchedules, model.FeeSchedules);
if (model.Employees == null)
{
throw new ArgumentException("Employees cannot be null");
}
Employees = new ChangeTrackingCollection <AccountPersonWrapper>(model.Employees.Select(e => new AccountPersonWrapper(e)));
RegisterCollection(Employees, model.Employees);
if (model.Contacts == null)
{
throw new ArgumentException("Contacts cannot be null");
}
Contacts = new ChangeTrackingCollection <ContactWrapper>(model.Contacts.Select(e => new ContactWrapper(e)));
RegisterCollection(Contacts, model.Contacts);
if (model.Comments == null)
{
throw new ArgumentException("Comments cannot be null");
}
Comments = new ChangeTrackingCollection <CommentWrapper>(model.Comments.Select(e => new CommentWrapper(e)));
RegisterCollection(Comments, model.Comments);
}
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 HasChanges_Modified_Parent_Should_Return_True()
{
// Arrange
var parent = new Parent("Parent");
var changeTracker = new ChangeTrackingCollection <Parent>(parent);
parent.Name += "_Changed";
// Act
bool hasChanges = parent.HasChanges();
// Assert
Assert.True(hasChanges);
}
public void MergeChanges_On_Equatable_Customer_Should_Not_Throw_ArgumentException()
{
// Arrange
var customer = new Customer {
CustomerId = "ALFKI"
};
var changeTracker = new ChangeTrackingCollection <Customer>(customer);
// Act
changeTracker.MergeChanges();
// Assert
Assert.True(true);
}
public void Collection_Ctor_Should_Disable_Tracking_For_Children()
{
// Arrange
var parent = _family.Parent;
// Act
var changeTracker = new ChangeTrackingCollection <Parent>(parent);
// Assert
Assert.IsTrue(changeTracker.Tracking);
IEnumerable <bool> trackings = GetTrackings(parent);
Assert.IsTrue(trackings.All(t => t));
}
public void Clear_RemovesAllItems()
{
var expectedItems = new List <TestItem>
{
new TestItem(),
new TestItem(),
new TestItem()
};
var subject = new ChangeTrackingCollection <TestItem>(expectedItems);
subject.Clear();
Assert.True(subject.HasChanges);
Assert.Empty(subject);
}
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 HasChanges_Unchanged_Order_OrderDetail_With_Modified_Product_Should_Return_True()
{
// Arrange
var database = new MockNorthwind();
var order = database.Orders[0];
var changeTracker = new ChangeTrackingCollection <Order>(order);
order.OrderDetails[0].Product.ProductName = "xxx";
// Act
bool hasChanges = order.HasChanges();
// Assert
Assert.True(hasChanges);
}
public AddEdgeViewModel(Attribute attribute)
{
if (attribute == null)
{
throw new ArgumentNullException("attribute");
}
attribute.IsEditable = true;
Attributes =
new ChangeTrackingCollection<AttributeWrapper>(new List<AttributeWrapper>
{
new AttributeWrapper(attribute)
});
OkButtonCommand = new DelegateCommand(OkButtonCommandExecute, OkButtonCommandCanExecute);
}
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 Should_Not_Track_Added_Item_As_Modified()
{
var listItemToAdd = new PocoListItemAdapter(new PocoListItem());
var c = new ChangeTrackingCollection <PocoListItemAdapter>(_listItems);
c.Add(listItemToAdd);
listItemToAdd.Description = "modified entry";
Assert.IsTrue(listItemToAdd.IsChanged);
Assert.AreEqual(3, c.Count);
Assert.AreEqual(1, c.AddedItems.Count);
Assert.AreEqual(0, c.RemovedItems.Count);
Assert.AreEqual(0, c.ModifiedItems.Count);
Assert.IsTrue(c.IsChanged);
}
public void Ctor_Collection_ContainsItems()
{
var expectedItems = new List <TestItem>
{
new TestItem(),
new TestItem(),
new TestItem()
};
var subject = new ChangeTrackingCollection <TestItem>(expectedItems);
Assert.Equal(expectedItems.Count, subject.Count);
Assert.Same(expectedItems[0], subject.ElementAt(0));
Assert.Same(expectedItems[1], subject.ElementAt(1));
Assert.Same(expectedItems[2], subject.ElementAt(2));
}
public void Added_Parent_With_Children_Should_Have_Children_Marked_As_Added()
{
// Arrange
var database = new MockNorthwind();
var changeTracker = new ChangeTrackingCollection<Order>(true);
var order = database.Orders[0];
var orderDetails = (IList<OrderDetail>)order.OrderDetails;
// Act
changeTracker.Add(order);
// Assert
Assert.Equal(TrackingState.Added, order.TrackingState);
Assert.Equal(TrackingState.Added, orderDetails[0].TrackingState);
}
protected override void InitializeCollectionProperties(IPBU model)
{
if (model.JobAdders == null)
{
throw new ArgumentException("Adders cannot be empty");
}
JobAdders = new ChangeTrackingCollection <AdderWrapper>(
model.JobAdders.Select(a => new AdderWrapper(a)));
//pricing is 0'd unless current frame is set on instantiation
foreach (var a in JobAdders)
{
a.CurrentFrame = this.SelectedFrame;
}
RegisterCollection(JobAdders, model.JobAdders);
}
public void ShouldNotTrackAddedItemsAsModified()
{
var emailToAdd = new FriendEmailWrapper(new FriendEmail());
var c = new ChangeTrackingCollection <FriendEmailWrapper>(_emails);
c.Add(emailToAdd);
emailToAdd.Email = "*****@*****.**";
Assert.IsTrue(emailToAdd.IsChanged);
Assert.AreEqual(3, c.Count);
Assert.AreEqual(1, c.AddedItems.Count);
Assert.AreEqual(0, c.RemovedItems.Count);
Assert.AreEqual(0, c.ModifiedItems.Count);
Assert.IsTrue(c.IsChanged);
}
public void ShouldTrackAddedAsModified()
{
var emailToAdd = new EmailWrapper(new Email());
var c = new ChangeTrackingCollection <EmailWrapper>(_emails);
c.Add(emailToAdd);
emailToAdd.EmailAddress = "*****@*****.**";
Assert.IsTrue(emailToAdd.IsChanged);
Assert.AreEqual(3, c.Count);
Assert.AreEqual(1, c.AddedItems.Count);
Assert.AreEqual(0, c.RemovedItems.Count);
Assert.AreEqual(0, c.ModifiedItems.Count);
Assert.IsTrue(c.IsChanged);
}
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 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 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 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 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 MergeChanges_Should_Set_ChangeTracker_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);
TrackingState origTrackingState = origOrder.Customer.TrackingState;
origOrder.Customer.CustomerName = "xxx";
// Assert
Assert.AreEqual(TrackingState.Unchanged, origTrackingState);
Assert.AreEqual(TrackingState.Modified, origOrder.Customer.TrackingState);
Assert.Contains("CustomerName", (ICollection)origOrder.Customer.ModifiedProperties);
}
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 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 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.IsTrue(product.ModifiedProperties == null
|| product.ModifiedProperties.Count == 0);
}
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 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.AreEqual(TrackingState.Modified, product.TrackingState);
Assert.Contains("ProductName", (ICollection)product.ModifiedProperties);
Assert.That(product.ModifiedProperties, Has.No.Member("UnitPrice"));
}
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", (ICollection)product.ModifiedProperties);
Assert.Contains("Discontinued", (ICollection)product.ModifiedProperties);
Assert.Contains("ProductName", (ICollection)product.ModifiedProperties);
}
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 Added_Items_After_Tracking_Enabled_Should_Be_Marked_As_Added()
{
// Arrange
var database = new MockNorthwind();
var product = database.Products[0];
var changeTracker = new ChangeTrackingCollection<Product>(true);
// Act
changeTracker.Add(product);
// Assert
Assert.AreEqual(TrackingState.Added, product.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 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 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_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 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 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_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);
}
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 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);
}
