Esempio n. 1
0
        public void GetChangeSet_CorrectWhenItemUpdate()
        {
            var expectedOldValue = "My old value";
            var expectedItem     = new TestItem
            {
                StringValue = expectedOldValue
            };
            var subject = new ChangeContainerItem <TestItem>(expectedItem, ChangeTarget.Collection);

            var expectedNewValue = "New value";

            expectedItem.StringValue = expectedNewValue;

            var path   = ChangePath.Create("Path");
            var result = subject.GetChangeSet(path);

            var expectedPath = path.AppendProperty(nameof(TestItem.StringValue));

            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(expectedOldValue, value.OldValue);
            Assert.Same(expectedNewValue, value.NewValue);
        }
Esempio n. 2
0
        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);
        }
Esempio n. 3
0
        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);
        }
Esempio n. 4
0
        public void GetChangeSet_ThrowsIfUpdateNonTrackChanges()
        {
            var expectedOldValue = "My old value";
            var expectedItem     = new TestItem
            {
                StringValue = expectedOldValue
            };
            var subject = new ChangeContainerItem <string>("Value", ChangeTarget.Collection, ChangeAction.Update);

            Assert.Throws <InvalidOperationException>(() => subject.GetChangeSet(ChangePath.Empty));
        }
Esempio n. 5
0
        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);
        }
Esempio n. 6
0
        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);
        }