public void HasChanges_TrueWhenAdd() { var subject = new ChangeTrackingCollection <TestItem>(); subject.Add(ChangeTrackingObject.CreateTrackable <TestItem>()); Assert.True(subject.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 GetChangeSet_CorrectWhenDirectUpdate() { var originalItem = ChangeTrackingObject.CreateTrackable <TestItem>(); originalItem.StringValue = "New value"; var subject = new ChangeContainerItem <TestItem>(originalItem, ChangeTarget.Collection); var expectedItem = ChangeTrackingObject.CreateTrackable <TestItem>(); subject.Item = expectedItem; var expectedPath = ChangePath.Create("Path"); var result = subject.GetChangeSet(expectedPath); var kvp = Assert.Single(result); Assert.Equal(ChangeTarget.Object, kvp.Key.Target); Assert.Contains(expectedPath, result as IDictionary <ChangePath, List <ChangeValue> >); var values = result[expectedPath]; var value = Assert.Single(values); Assert.Equal(ChangeAction.Update, value.Action); Assert.Same(originalItem, value.OldValue); Assert.Same(expectedItem, value.NewValue); }
public void HasChanges_TrueWhenChanges() { var subject = ChangeTrackingObject.CreateTrackable <TestObject>(); subject.StringValue = "NewValue"; Assert.True(subject.HasChanges); }
public void HasChanges_TrueWhenChangesToItem() { var item = ChangeTrackingObject.CreateTrackable <TestItem>(); var subject = new ChangeContainerItem <TestItem>(item, ChangeTarget.Object); item.StringValue = "Updated value"; Assert.True(subject.HasChanges); }
public void GetChangeSet_NullWhenNoChanges() { var expectedItem = ChangeTrackingObject.CreateTrackable <TestItem>(); var subject = new ChangeContainerItem <TestItem>(expectedItem, ChangeTarget.Collection); var result = subject.GetChangeSet(ChangePath.Create("path")); Assert.Null(result); }
public void Ctor_EntitySet() { var expectedEntity = ChangeTrackingObject.CreateTrackable <TestEntity>(); var mockSubject = new Mock <BaseEntityDataPackage <TestEntity> >( MockBehavior.Strict, expectedEntity); Assert.Same(expectedEntity, mockSubject.Object.Entity); }
public void GetValue_Success() { var expectedValue = "My expected value"; var subject = ChangeTrackingObject.CreateTrackable <TestObject>(); subject.StringValue = expectedValue; var result = subject.TestGetValue <string>(nameof(subject.StringValue)); Assert.Equal(expectedValue, result); }
public void HasChanges_FalseAtStart() { var expectedItems = new List <TestItem> { ChangeTrackingObject.CreateTrackable <TestItem>() }; var subject = new ChangeTrackingCollection <TestItem>(expectedItems); Assert.False(subject.HasChanges); }
public void Action_ItemHasChanges_ReturnsUpdate() { var expectedItem = ChangeTrackingObject.CreateTrackable <TestItem>(); expectedItem.StringValue = "Updated value"; Assert.True(expectedItem.HasChanges); var subject = new ChangeContainerItem <TestItem>(expectedItem, ChangeTarget.Object); Assert.Equal(ChangeAction.Update, subject.Action); }
public void HasChanges_TrueWhenItemChange() { var item = ChangeTrackingObject.CreateTrackable <TestItem>(); var expectedItems = new List <TestItem> { item }; var subject = new ChangeTrackingCollection <TestItem>(expectedItems); item.StringValue = "New value"; Assert.True(subject.HasChanges); }
public void GetChangeSet_HasChangeFalseWhenCommit() { var expectedItem = ChangeTrackingObject.CreateTrackable <TestItem>(); var subject = new ChangeContainerItem <TestItem>(expectedItem, ChangeTarget.Collection); expectedItem.StringValue = "New value"; subject.GetChangeSet(ChangePath.Create("path"), true); Assert.False(subject.HasChanges); Assert.False(expectedItem.HasChanges); }
public void Ctor_ItemsDictionaryParamWithChanges_HasChangesTrue() { var expectedUpdate = ChangeTrackingObject.CreateTrackable <TestItem>(); var expectedItems = new Dictionary <string, TestItem> { { "Test1", new TestItem() }, { "Test2", expectedUpdate } }; expectedUpdate.StringValue = "new value"; var subject = new ChangeTrackingDictionary <string, TestItem>(expectedItems); Assert.True(subject.HasChanges); }
public void GetChangeSet_GeneratesCorrectChangeSetForITracksChanges() { var path = ChangePath.Create("Key"); var expectedPath = path.AppendProperty(nameof(NestedObject.StringValue)); var nested = ChangeTrackingObject.CreateTrackable <NestedObject>(); var subject = new ChangeContainerValue(nested); nested.StringValue = "My new value;"; var changes = subject.GetChangeSet(path); Assert.Single(changes); Assert.True(changes.ContainsKey(expectedPath)); }
public void Reset_RevertsItemChanges() { var expectedItem = ChangeTrackingObject.CreateTrackable <TestItem>(); var subject = new ChangeContainerItem <TestItem>(expectedItem, ChangeTarget.Collection); subject.Item.StringValue = "My new value"; Assert.True(subject.HasChanges); Assert.Equal(ChangeAction.Update, subject.Action); subject.Reset(); Assert.Same(expectedItem, subject.Item); Assert.False(subject.HasChanges); Assert.Equal(ChangeAction.None, subject.Action); }
public void GetChangeSet_CorrectWhenRemove() { var expectedItem = ChangeTrackingObject.CreateTrackable <TestItem>(); var expectedChangeAction = ChangeAction.Remove; var subject = new ChangeContainerItem <TestItem>(expectedItem, ChangeTarget.Collection, expectedChangeAction); var expectedPath = ChangePath.Create("Path"); var result = subject.GetChangeSet(expectedPath); var kvp = Assert.Single(result); Assert.Equal(ChangeTarget.Object, kvp.Key.Target); Assert.Contains(expectedPath, result as IDictionary <ChangePath, List <ChangeValue> >); var values = result[expectedPath]; var value = Assert.Single(values); Assert.Equal(expectedChangeAction, value.Action); Assert.Null(value.NewValue); Assert.Same(expectedItem, value.OldValue); }
public void GetValue_ReturnsDefaultWhenNotSet() { var subject = ChangeTrackingObject.CreateTrackable <TestObject>(); var result = subject.TestGetValue <int>("someproperty"); Assert.Equal(default, result);
public void GetValue_ThrowsWhenNull() { var subject = ChangeTrackingObject.CreateTrackable <TestObject>(); Assert.Throws <ArgumentNullException>(() => subject.TestGetValue <string>(null)); }
public async Task UpdateAsync_PipelineExecuted() { var updatingCalled = false; var updatedCalled = false; var executeUpdateCalled = false; var mockProcessorUpdating = new Mock <IProcessor <EntityUpdatingPackage <TestEntity> > >(MockBehavior.Strict); mockProcessorUpdating.SetupGet(p => p.Stage).Returns(new NumericPriorityStage(0)); mockProcessorUpdating .Setup(p => p.ProcessAsync(It.IsAny <EntityUpdatingPackage <TestEntity> >(), It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask) .Callback(() => { Assert.False(updatedCalled); Assert.False(executeUpdateCalled); updatingCalled = true; }); var mockProcessorUpdated = new Mock <IProcessor <EntityUpdatedPackage <TestEntity> > >(MockBehavior.Strict); mockProcessorUpdated.SetupGet(p => p.Stage).Returns(new NumericPriorityStage(0)); mockProcessorUpdated .Setup(p => p.ProcessAsync(It.IsAny <EntityUpdatedPackage <TestEntity> >(), It.IsAny <CancellationToken>())) .Returns(Task.CompletedTask) .Callback(() => { Assert.True(updatingCalled); Assert.True(executeUpdateCalled); updatedCalled = true; }); var mockProcessorProvider = new Mock <IProcessorProvider>(MockBehavior.Strict); mockProcessorProvider .Setup(p => p.GetProcessors <EntityUpdatingPackage <TestEntity> >()) .Returns(new List <IProcessor <EntityUpdatingPackage <TestEntity> > > { mockProcessorUpdating.Object }); mockProcessorProvider .Setup(p => p.GetProcessors <EntityUpdatedPackage <TestEntity> >()) .Returns(new List <IProcessor <EntityUpdatedPackage <TestEntity> > > { mockProcessorUpdated.Object }); ChangeSet expectedChangeSet = null; var expectedPipeline = new ProcessorPipeline(mockProcessorProvider.Object); var mockSubject = new Mock <Repository <TestEntity> >(MockBehavior.Strict, expectedPipeline); mockSubject .Protected() .Setup <Task <ChangeSet> >("ExecuteUpdateAsync", ItExpr.IsAny <TestEntity>(), ItExpr.IsAny <ChangeSet>(), It.IsAny <CancellationToken>()) .Callback <TestEntity, ChangeSet, CancellationToken>((e, cs, ct) => { expectedChangeSet = cs; Assert.True(updatingCalled); Assert.False(updatedCalled); executeUpdateCalled = true; }) .Returns(Task.FromResult(expectedChangeSet)); var expectedEntity = ChangeTrackingObject.CreateTrackable <TestEntity>(); expectedEntity.StringValue = "NewValue"; var result = await mockSubject.Object.UpdateAsync(expectedEntity, CancellationToken.None); mockProcessorProvider.Verify(p => p.GetProcessors <EntityUpdatingPackage <TestEntity> >(), Times.Once); mockProcessorProvider.Verify(p => p.GetProcessors <EntityUpdatedPackage <TestEntity> >(), Times.Once); mockProcessorUpdating.Verify(p => p.ProcessAsync( It.Is <EntityUpdatingPackage <TestEntity> >(v => ReferenceEquals(v.Entity, expectedEntity)), It.IsAny <CancellationToken>()), Times.Once()); mockProcessorUpdated.Verify(p => p.ProcessAsync( It.Is <EntityUpdatedPackage <TestEntity> >(v => ReferenceEquals(v.Entity, expectedEntity)), It.IsAny <CancellationToken>()), Times.Once()); mockSubject .Protected() .Verify("ExecuteUpdateAsync", Times.Once(), ItExpr.Is <TestEntity>(v => ReferenceEquals(v, expectedEntity)), ItExpr.Is <ChangeSet>(v => ReferenceEquals(v, expectedChangeSet)), ItExpr.IsAny <CancellationToken>()); }
public void HasChanges_FalseOnInitialize() { var subject = ChangeTrackingObject.CreateTrackable <TestObject>(); Assert.False(subject.HasChanges); }