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 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 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 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 HasChanges_TrueWhenAdd() { var subject = new ChangeTrackingCollection <TestItem>(); subject.Add(ChangeTrackingObject.CreateTrackable <TestItem>()); Assert.True(subject.HasChanges); }
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 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 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 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 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 HasChanges_Added_Parent_Should_Return_True() { // Arrange var parent = new Parent("Parent"); var changeTracker = new ChangeTrackingCollection <Parent>(true); changeTracker.Add(parent); // Act bool hasChanges = parent.HasChanges(); // Assert Assert.True(hasChanges); }
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); }
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 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 GetChanges_Should_Return_Added_Items() { // Arrange var database = new MockNorthwind(); var changeTracker = new ChangeTrackingCollection <Product>(true); var product = database.Products[0]; changeTracker.Add(product); // Act var changes = changeTracker.GetChanges(); // Assert Assert.Equal(TrackingState.Added, changes.First().TrackingState); }
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 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 ShouldNotTrackAddedItemAsModified() { Initialize(); var listItemToAdd = new PocoListItemAdapter(new PocoListItem()); var c = new ChangeTrackingCollection <PocoListItemAdapter>(_listItems); c.Add(listItemToAdd); listItemToAdd.Description = "modified entry"; Assert.True(listItemToAdd.IsChanged); Assert.Equal(3, c.Count); Assert.Equal(1, c.AddedItems.Count); Assert.Equal(0, c.RemovedItems.Count); Assert.Equal(0, c.ModifiedItems.Count); Assert.True(c.IsChanged); }
public void Collection_Set_Tracking_Should_Enable_Tracking_For_Children() { // Arrange var parent = _family.Parent; var changeTracker = new ChangeTrackingCollection <Parent>(); changeTracker.Add(parent); // Act changeTracker.Tracking = true; // Assert Assert.IsTrue(changeTracker.Tracking); IEnumerable <bool> trackings = GetTrackings(parent); Assert.IsTrue(trackings.All(t => t)); }
public void Collection_Added_Set_State_As_Deleted_Should_Mark_Children_As_Unchanged() { // Arrange var parent = _family.Parent; var changeTracker = new ChangeTrackingCollection <Parent>(true); changeTracker.Add(parent); // Act changeTracker.Remove(parent); // Assert Assert.AreEqual(TrackingState.Unchanged, parent.TrackingState); IEnumerable <TrackingState> trackings = GetStates(parent); Assert.IsTrue(trackings.All(t => t == TrackingState.Unchanged)); }
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 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 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 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 Should_Track_Removed_Items() { var listItemToRemove = _listItems.First(); var c = new ChangeTrackingCollection <PocoListItemAdapter>(_listItems); Assert.AreEqual(2, c.Count); Assert.IsFalse(c.IsChanged); c.Remove(listItemToRemove); 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(listItemToRemove, c.RemovedItems.First()); Assert.IsTrue(c.IsChanged); c.Add(listItemToRemove); Assert.AreEqual(2, c.Count); Assert.AreEqual(0, c.AddedItems.Count); Assert.AreEqual(0, c.RemovedItems.Count); Assert.AreEqual(0, c.ModifiedItems.Count); Assert.IsFalse(c.IsChanged); }
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.True(product.ModifiedProperties == null || product.ModifiedProperties.Count == 0); }
public void GetChangeSet_CommitFalse_ContainsAdds() { var subject = new ChangeTrackingCollection <TestItem>(); var expectedItem = new TestItem(); subject.Add(expectedItem); var basePath = ChangePath.Create("path"); var result = subject.GetChangeSet(basePath); var expectedPath = basePath.AppendIndex(0); 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.Add, value.Action); Assert.Null(value.OldValue); Assert.Same(expectedItem, value.NewValue); }
public void Modified_Added_Items_Should_Be_Marked_As_Added() { // 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++; // Assert Assert.Equal(TrackingState.Added, product.TrackingState); }
public void ShouldTrackModifiedItems() { var emailToRemove = _emails.First(); var trackingCollection = new ChangeTrackingCollection <EmailWrapper>(_emails); Assert.AreEqual(2, trackingCollection.Count); Assert.IsFalse(trackingCollection.IsChanged); trackingCollection.Remove(emailToRemove); 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(emailToRemove, trackingCollection.RemovedItems.First()); Assert.IsTrue(trackingCollection.IsChanged); trackingCollection.Add(emailToRemove); Assert.AreEqual(2, trackingCollection.Count); Assert.AreEqual(0, trackingCollection.AddedItems.Count); Assert.AreEqual(0, trackingCollection.RemovedItems.Count); Assert.AreEqual(0, trackingCollection.ModifiedItems.Count); Assert.IsFalse(trackingCollection.IsChanged); }
public void Added_Items_With_Enumerable_Ctor_Should_Be_Marked_As_Added() { // Arrange var database = new MockNorthwind(); var products = new List <Product> { database.Products[0] }; var changeTracker = new ChangeTrackingCollection <Product>(products); var product = new Product { ProductId = 100, ProductName = "Test Beverage", CategoryId = 1, Category = database.Categories[0], UnitPrice = 10M }; // Act changeTracker.Add(product); // Assert Assert.Equal(TrackingState.Added, product.TrackingState); }
public void ShouldTrackAddedItems() { var emailToAdd = new FriendEmailWrapper(new FriendEmail()); var c = new ChangeTrackingCollection <FriendEmailWrapper>(_emails); Assert.AreEqual(2, c.Count); Assert.IsFalse(c.IsChanged); c.Add(emailToAdd); Assert.AreEqual(3, c.Count); Assert.AreEqual(1, c.AddedItems.Count); Assert.AreEqual(0, c.RemovedItems.Count); Assert.AreEqual(0, c.ModifiedItems.Count); Assert.AreEqual(emailToAdd, c.AddedItems.First()); Assert.IsTrue(c.IsChanged); c.Remove(emailToAdd); Assert.AreEqual(2, c.Count); Assert.AreEqual(0, c.AddedItems.Count); Assert.AreEqual(0, c.RemovedItems.Count); Assert.AreEqual(0, c.ModifiedItems.Count); Assert.IsFalse(c.IsChanged); }
public void ShouldRejectChanges() { var emailToModify = _emails.First(); var emailToRemove = _emails.Skip(1).First(); var emailToAdd = new FriendEmailWrapper(new FriendEmail { Email = "*****@*****.**" }); var c = new ChangeTrackingCollection <FriendEmailWrapper>(_emails); c.Add(emailToAdd); c.Remove(emailToRemove); emailToModify.Email = "*****@*****.**"; Assert.AreEqual("*****@*****.**", emailToModify.EmailOriginalValue); Assert.AreEqual(2, c.Count); Assert.AreEqual(1, c.AddedItems.Count); Assert.AreEqual(1, c.ModifiedItems.Count); Assert.AreEqual(1, c.RemovedItems.Count); c.RejectChanges(); Assert.AreEqual(2, c.Count); Assert.IsTrue(c.Contains(emailToModify)); Assert.IsTrue(c.Contains(emailToRemove)); Assert.AreEqual(0, c.AddedItems.Count); Assert.AreEqual(0, c.ModifiedItems.Count); Assert.AreEqual(0, c.RemovedItems.Count); Assert.IsFalse(emailToModify.IsChanged); Assert.AreEqual("*****@*****.**", emailToModify.Email); Assert.AreEqual("*****@*****.**", emailToModify.EmailOriginalValue); Assert.IsFalse(c.IsChanged); }
public void ShouldAcceptChanges() { var emailToModify = _emails.First(); var emailToRemove = _emails.Skip(1).First(); var emailToAdd = new EmailWrapper(new Email { EmailAddress = "*****@*****.**" }); var c = new ChangeTrackingCollection <EmailWrapper>(_emails); c.Add(emailToAdd); c.Remove(emailToRemove); emailToModify.EmailAddress = "*****@*****.**"; Assert.AreEqual("*****@*****.**", emailToModify.EmailAddressOriginalValue); Assert.AreEqual(2, c.Count); Assert.AreEqual(1, c.AddedItems.Count); Assert.AreEqual(1, c.ModifiedItems.Count); Assert.AreEqual(1, c.RemovedItems.Count); c.AcceptChanges(); Assert.AreEqual(2, c.Count); Assert.IsTrue(c.Contains(emailToModify)); Assert.IsTrue(c.Contains(emailToAdd)); Assert.AreEqual(0, c.AddedItems.Count); Assert.AreEqual(0, c.ModifiedItems.Count); Assert.AreEqual(0, c.RemovedItems.Count); Assert.IsFalse(emailToModify.IsChanged); Assert.AreEqual("*****@*****.**", emailToModify.EmailAddress); Assert.AreEqual("*****@*****.**", emailToModify.EmailAddressOriginalValue); Assert.IsFalse(c.IsChanged); }
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 Added_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>(true); changeTracker.Add(order); // Act order.Customer = new Customer { CustomerId = "ABCD", CustomerName = "Test", TrackingState = TrackingState.Added // required to insert new customer }; // Assert Assert.Equal(TrackingState.Added, order.TrackingState); Assert.Equal(TrackingState.Added, order.Customer.TrackingState); Assert.True(order.HasChanges()); }
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 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 GetChanges_Should_Return_Added_Items() { // Arrange var database = new MockNorthwind(); var changeTracker = new ChangeTrackingCollection<Product>(true); var product = database.Products[0]; changeTracker.Add(product); // Act var changes = changeTracker.GetChanges(); // Assert Assert.AreEqual(TrackingState.Added, changes.First().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 HasChanges_Added_Parent_Should_Return_True() { // Arrange var parent = new Parent("Parent"); var changeTracker = new ChangeTrackingCollection<Parent>(true); changeTracker.Add(parent); // Act bool hasChanges = parent.HasChanges(); // Assert Assert.True(hasChanges); }
public void Added_Items_With_Enumerable_Ctor_Should_Be_Marked_As_Added() { // Arrange var database = new MockNorthwind(); var products = new List<Product> { database.Products[0] }; var changeTracker = new ChangeTrackingCollection<Product>(products); var product = new Product { ProductId = 100, ProductName = "Test Beverage", CategoryId = 1, Category = database.Categories[0], UnitPrice = 10M }; // Act changeTracker.Add(product); // Assert Assert.AreEqual(TrackingState.Added, product.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 Added_Order_With_Modified_Customer_Should_Mark_Customer_As_Modified() { // NOTE: Modified reference entity will remain modified if parent is added. // Arrange var database = new MockNorthwind(); var order = database.Orders[0]; var changeTracker = new ChangeTrackingCollection<Order>(true); changeTracker.Add(order); // Act order.Customer.CustomerName = "xxx"; // Assert Assert.Equal(TrackingState.Added, order.TrackingState); Assert.Equal(TrackingState.Modified, order.Customer.TrackingState); Assert.True(order.HasChanges()); }
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.AreEqual(TrackingState.Added, employee.TrackingState); Assert.IsTrue(employee.Territories.All(t => t.TrackingState == TrackingState.Added)); }
public void Added_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>(true); changeTracker.Add(order); var customer = order.Customer; // Act order.Customer = null; // Assert Assert.Equal(TrackingState.Added, order.TrackingState); Assert.Equal(TrackingState.Unchanged, customer.TrackingState); Assert.True(order.HasChanges()); }
/// <summary> /// Serialize the object into JSON. /// </summary> /// <param name="writer">JSON writer.</param> /// <param name="value">PropertyValue to be serialized.</param> /// <param name="serializer">JSON serializer.</param> public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) { if (value == null) { return; } ChangeTrackingCollection<GraphObject> graphObjects = value as ChangeTrackingCollection<GraphObject>; if (graphObjects == null) { if (!(value is IEnumerable)) { throw new ArgumentException("parameter 'value' is not of type IEnumerable."); } graphObjects = new ChangeTrackingCollection<GraphObject>(); IEnumerable iEnumerableValue = value as IEnumerable; foreach (object valueObject in iEnumerableValue) { GraphObject graphObject = valueObject as GraphObject; if (graphObject == null) { throw new ArgumentException( "Each value in the ChangeTrackingCollection should be of type GraphObject."); } graphObjects.Add(graphObject); } } if (graphObjects.Count > 0) { throw new ArgumentException("Updating links is not supported from entity."); } writer.WriteNull(); }
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); }
/// <summary> /// Read JSON string to the object. /// </summary> /// <param name="reader">JSON reader.</param> /// <param name="objectType">Object type.</param> /// <param name="existingValue">Existing value.</param> /// <param name="serializer">Json serializer</param> /// <returns>Deserialized object.</returns> /// <remarks> /// 1. Check if this is an array or a single element. /// If Array, deserialize each element as DirectoryObject and return the list /// 2. Deserialize using the default property set /// 3. Find the non-deserialized properties and add them to the Dictionary. /// </remarks> public override object ReadJson( JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { if (reader.TokenType == JsonToken.StartArray) { JToken jsonToken = JArray.ReadFrom(reader); List<JToken> jsonTokens = jsonToken.ToList(); // This converter can only handle an array of graph objects. // Not native types. When deserializing an expanded link, all linked objects will be // deserialized as GraphObject. ChangeTrackingCollection<GraphObject> resultObjects = new ChangeTrackingCollection<GraphObject>(); AadJsonConverter jsonConverter = new AadJsonConverter(); foreach (JToken arrayToken in jsonTokens) { GraphObject resultElement = JsonConvert.DeserializeObject( arrayToken.ToString(), typeof(GraphObject), jsonConverter) as GraphObject; resultObjects.Add(resultElement); } return resultObjects; } // Load the JSON into a JsonObject so that we can inspect the odata.type property. Object resultObject; JObject jsonObject = JObject.Load(reader); List<JProperty> jsonProperties = jsonObject.Properties().ToList(); JProperty odataTypeProperty = jsonProperties.FirstOrDefault(x => x.Name == Constants.OdataTypeKey); // If there is odata.type value, use that to find the type to be deserialized into. // If not, use the type that was passed to the de-serializer. Type resultObjectType; if (odataTypeProperty != null && SerializationHelper.TryGetImplementationForAadType( odataTypeProperty.Value.ToString(), out resultObjectType) && typeof(GraphObject).IsAssignableFrom(resultObjectType)) { resultObject = Activator.CreateInstance(resultObjectType) as GraphObject; } else { resultObjectType = objectType; resultObject = Activator.CreateInstance(resultObjectType); } // Deserialize all known properties using the default JSON.NET serializer resultObject = JsonConvert.DeserializeObject(jsonObject.ToString(), resultObjectType); // TODO: If the odata type is null, should still try to deserialize additional values using // the graphObjectType. GraphObject graphObject = resultObject as GraphObject; if (graphObject != null && odataTypeProperty != null) { Dictionary<string, PropertyInfo> propertyNameToInfoMap = this.GetPropertyInfosForAadType(odataTypeProperty.Value.ToString(), resultObjectType); foreach (JProperty jsonProperty in jsonProperties) { PropertyInfo propertyInfo; if (!propertyNameToInfoMap.TryGetValue(jsonProperty.Name, out propertyInfo)) { graphObject.NonSerializedProperties[jsonProperty.Name] = jsonProperty.Value.ToString(); } } } return graphObject; }
public void Added_Order_With_New_Customer_Should_Mark_Customer_As_Unchanged() { // NOTE: Setting Order.Customer to a new customer will not automatically // mark it as Added, because Order has no way to tell if customer is new // or already exists. However, Customer can be marked as Added manually. // Arrange var database = new MockNorthwind(); var order = database.Orders[0]; var changeTracker = new ChangeTrackingCollection<Order>(true); changeTracker.Add(order); // Act // Because not marked as added, refers to existing customer order.Customer = new Customer { CustomerId = "ABCD", CustomerName = "Test" }; // Assert Assert.Equal(TrackingState.Added, order.TrackingState); Assert.Equal(TrackingState.Unchanged, order.Customer.TrackingState); Assert.True(order.HasChanges()); }
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 Added_Order_With_Unchanged_Customer_Should_Mark_Customer_As_Unchanged() { // NOTE: Referenced customer will remain unchanged because Order has no way to // tell if customer is new or already exists. However, Customer can be marked // as Added manually. (If it were 1-M or M-M, marking parent as added automatically // marks children as added.) // Arrange var database = new MockNorthwind(); var order = database.Orders[0]; var changeTracker = new ChangeTrackingCollection<Order>(true); changeTracker.Add(order); // Act // Assert Assert.Equal(TrackingState.Added, order.TrackingState); Assert.Equal(TrackingState.Unchanged, order.Customer.TrackingState); Assert.True(order.HasChanges()); }
public void Added_Parent_With_Modified_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); orderDetails[0].Quantity++; // Assert Assert.Equal(TrackingState.Added, order.TrackingState); Assert.Equal(TrackingState.Added, orderDetails[0].TrackingState); }