public void Equals_NotSameType_Fails()
{
var one = ChangePath.Create("one");
var two = new ChangeSet();
Assert.False(Equals(one, two));
}
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);
}
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 StartsWith_FalseWhenNotMatch()
{
var path1 = ChangePath.Create("Property1").AppendKey("123").AppendProperty("Property");
var path2 = ChangePath.Create("Property1").AppendKey("321");
Assert.False(path1.StartsWith(path2));
}
public void Equals_Fails()
{
var one = ChangePath.Create("one");
var two = ChangePath.Create("two");
Assert.NotEqual(one, two);
}
public void Equals_Success()
{
var one = ChangePath.Create("one");
var two = ChangePath.Create("one");
Assert.Equal(one, two);
}
public void StartsWith_TrueWhenIndexMatch()
{
var path1 = ChangePath.Create("Property1").AppendIndex("123").AppendProperty("Property");
var path2 = ChangePath.Create("Property1").AppendIndex("123");
Assert.True(path1.StartsWith(path2));
}
public void ToJsonPatch_Update_Complex_Success()
{
var path = "Test";
var expectedPath = $"/{path.ToCamelCase()}";
var expectedNewValue = new TestValue
{
StringValue = "My new complex value",
IntValue = 12345
};
var changes = ChangeSet.Create(
ChangePath.Create(path),
new ChangeValue
{
Action = ChangeAction.Update,
NewValue = expectedNewValue
});
var patch = changes.ToJsonPatch();
Assert.Single(patch);
var operation = patch[0];
Assert.Equal(OperationType.Replace, operation.OperationType);
Assert.Equal(expectedPath, operation.path);
Assert.Equal(expectedNewValue, operation.value);
}
public void GetChangeSet_CommitFalse_ContainsUpdates()
{
var expectedOldValue = "My old value";
var expectedNewValue = "The new value";
var expectedUpdate = new TestItem
{
StringValue = expectedOldValue
};
var expectedItems = new List <TestItem>
{
new TestItem(),
expectedUpdate,
new TestItem()
};
var subject = new ChangeTrackingCollection <TestItem>(expectedItems);
var path = ChangePath.Create("path");
var expectedPath = path.AppendIndex(1).AppendProperty(nameof(TestItem.StringValue));
expectedUpdate.StringValue = expectedNewValue;
var result = subject.GetChangeSet(path);
Assert.True(subject.HasChanges);
Assert.NotNull(result);
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.Equal(expectedNewValue, value.NewValue);
Assert.Equal(expectedOldValue, value.OldValue);
}
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 StartsWith_FalseWhenPathIsLonger()
{
var path1 = ChangePath.Create("Property1");
var path2 = ChangePath.Create("Property1").AppendKey("321");
Assert.False(path1.StartsWith(path2));
}
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 Create_Part_Success()
{
var expectedPart = new ChangePathProperty("value");
var path = ChangePath.Create(expectedPart);
Assert.Single(path.Parts);
Assert.Same(expectedPart, path.Parts[0]);
}
public void GetHashCode_EqualsTrue()
{
var one = ChangePath.Create("one").AppendProperty("two");
var two = ChangePath.Create("one").AppendProperty("two");
var hashOne = one.GetHashCode();
var hashTwo = two.GetHashCode();
Assert.Equal(hashOne, hashTwo);
}
public void Create_Property_Success()
{
var expectedValue = "test";
var path = ChangePath.Create(expectedValue);
Assert.Single(path.Parts);
Assert.True(path.Parts[0] is ChangePathProperty);
var cpp = path.Parts[0] as ChangePathProperty;
Assert.Equal(expectedValue, cpp.Property);
}
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 ToJsonPatch_IgnoresActionNone()
{
var changes = ChangeSet.Create(
ChangePath.Create("Test"),
new ChangeValue
{
Action = ChangeAction.None
});
var patch = changes.ToJsonPatch();
Assert.Empty(patch);
}
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 GetChangeSet_GeneratesCorrectChangeSet()
{
var expectedOldValue = "Initial Value";
var expectedNewValue = "New Value";
var expectedPath = ChangePath.Create("Key");
var subject = new ChangeContainerValue(expectedOldValue);
subject.CurrentValue = expectedNewValue;
var changes = subject.GetChangeSet(expectedPath);
Assert.Single(changes);
Assert.True(changes.ContainsKey(expectedPath));
Assert.Single(changes[expectedPath]);
Assert.Equal(ChangeAction.Update, changes[expectedPath][0].Action);
Assert.Equal(expectedOldValue, changes[expectedPath][0].OldValue);
Assert.Equal(expectedNewValue, changes[expectedPath][0].NewValue);
}
public void Merge_MergesEntries()
{
var expectetPathOne = ChangePath.Create("one");
var expectedPathTwo = ChangePath.Create("two");
var subject = new ChangeSet();
subject.Append(expectetPathOne, new ChangeValue());
var mergeMe = new ChangeSet();
mergeMe.Append(expectedPathTwo, new ChangeValue());
subject.Merge(mergeMe);
Assert.Equal(2, subject.Count);
Assert.Single(mergeMe);
Assert.Contains(expectetPathOne, subject as IDictionary <ChangePath, List <ChangeValue> >);
Assert.Contains(expectedPathTwo, subject as IDictionary <ChangePath, List <ChangeValue> >);
}
public void CommitChanges_CallsITracksChangesGetChangeSet()
{
var expectedPath = ChangePath.Create("MyPath");
var expectedChangeSet = new ChangeSet();
var mock = new Mock <ITracksChanges>(MockBehavior.Strict);
mock
.Setup(tc => tc.GetChangeSet(It.IsAny <ChangePath>(), It.IsAny <bool>()))
.Returns(expectedChangeSet);
var result = ITracksChangesExtensions.CommitChanges(mock.Object, expectedPath);
Assert.Same(expectedChangeSet, result);
mock.Verify(tc => tc.GetChangeSet(
It.Is <ChangePath>(v => v == expectedPath),
It.Is <bool>(v => v)),
Times.Once);
}
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 ToJsonPatch_Remove_Success()
{
var path = "Test";
var expectedPath = $"/{path.ToCamelCase()}";
var expectedNewValue = "My new value";
var changes = ChangeSet.Create(
ChangePath.Create(path),
new ChangeValue
{
Action = ChangeAction.Remove,
NewValue = expectedNewValue
});
var patch = changes.ToJsonPatch();
Assert.Single(patch);
var operation = patch[0];
Assert.Equal(OperationType.Remove, operation.OperationType);
Assert.Equal(expectedPath, operation.path);
Assert.Null(operation.value);
}