public void Remove_BeforeAdd_HasNoEffect(LWW_OptimizedSetWithVCElement <TestType> element)
{
var lwwSet = new LWW_OptimizedSetWithVC <TestType>();
var newLwwSet = lwwSet.Remove(element.Value, element.VectorClock);
Assert.Same(lwwSet, newLwwSet);
}
public void Add_AddsElementToAddsSet(TestType value, Node node)
{
var clock = ImmutableSortedDictionary <Node, long> .Empty;
var lwwSet = new LWW_OptimizedSetWithVC <TestType>();
var add = new LWW_OptimizedSetWithVCElement <TestType>(value, new VectorClock(clock.Add(node, 0)), false);
lwwSet = lwwSet.Assign(add.Value, new VectorClock(clock.Add(node, 0)));
Assert.Contains(add, lwwSet.Elements);
}
public void Lookup_AddedAndNotRemoved_ReturnsTrue(LWW_OptimizedSetWithVCElement <TestType> element)
{
var clock = ImmutableSortedDictionary <Node, long> .Empty;
var lwwSet = new LWW_OptimizedSetWithVC <TestType>();
lwwSet = lwwSet.Assign(element.Value, element.VectorClock);
var lookup = lwwSet.Lookup(element.Value);
Assert.True(lookup);
}
public void Add_NoExistingValues_AddsElementToTheRepository(TestType value, Node node)
{
var clock = ImmutableSortedDictionary <Node, long> .Empty;
_lwwSetService.DownstreamAssign(value, new VectorClock(clock.Add(node, 0)));
var repositoryValues = _repository.GetElements();
var element = new LWW_OptimizedSetWithVCElement <TestType>(value, new VectorClock(clock.Add(node, 0)), false);
Assert.Contains(element, repositoryValues);
}
public void Add_ConcurrentAdds_AddsOnlyOne(TestType value, Node node)
{
var clock = ImmutableSortedDictionary <Node, long> .Empty;
var lwwSet = new LWW_OptimizedSetWithVC <TestType>();
var firstAdd = new LWW_OptimizedSetWithVCElement <TestType>(value, new VectorClock(clock.Add(node, 0)), false);
var secondAdd = new LWW_OptimizedSetWithVCElement <TestType>(value, new VectorClock(clock.Add(node, 0)), false);
lwwSet = lwwSet.Assign(firstAdd.Value, firstAdd.VectorClock);
lwwSet = lwwSet.Assign(secondAdd.Value, secondAdd.VectorClock);
Assert.Equal(1, lwwSet.Elements.Count(e => Equals(e.Value, value)));
}
public void Remove_AddExistsWithLowerTimestamp_AddsElementToTheRepository(TestType value, Node node)
{
var clock = ImmutableSortedDictionary <Node, long> .Empty;
var removeElement = new LWW_OptimizedSetWithVCElement <TestType>(value, new VectorClock(clock.Add(node, 1)), true);
_lwwSetService.LocalAssign(value, new VectorClock(clock.Add(node, 0)));
_lwwSetService.LocalRemove(value, new VectorClock(clock.Add(node, 1)));
var repositoryValues = _repository.GetElements();
Assert.Single(repositoryValues);
Assert.Contains(removeElement, repositoryValues);
}
public void Lookup_Added_ReturnsTrue(TestType value, Node node)
{
var clock = ImmutableSortedDictionary <Node, long> .Empty;
var addElement = new LWW_OptimizedSetWithVCElement <TestType>(value, new VectorClock(clock.Add(node, 0)), false);
_lwwSetService.Merge(new HashSet <LWW_OptimizedSetWithVCElement <TestType> > {
addElement
}.ToImmutableHashSet());
var lookup = _lwwSetService.Lookup(value);
Assert.True(lookup);
}
public void Remove_RemovesElementToRemovesSet(TestType value, Node node)
{
var clock = ImmutableSortedDictionary <Node, long> .Empty;
var lwwSet = new LWW_OptimizedSetWithVC <TestType>();
var add = new LWW_OptimizedSetWithVCElement <TestType>(value, new VectorClock(clock.Add(node, 0)), false);
var remove = new LWW_OptimizedSetWithVCElement <TestType>(value, new VectorClock(clock.Add(node, 1)), true);
lwwSet = lwwSet.Assign(add.Value, add.VectorClock);
lwwSet = lwwSet.Remove(remove.Value, remove.VectorClock);
Assert.DoesNotContain(add, lwwSet.Elements);
Assert.Contains(remove, lwwSet.Elements);
}
public void Add_AddSameElementTwiceWithDifferentTimestamp_UpdatesTimestamp(TestType value, Node node)
{
var clock = ImmutableSortedDictionary <Node, long> .Empty;
var lwwSet = new LWW_OptimizedSetWithVC <TestType>();
var firstAdd = new LWW_OptimizedSetWithVCElement <TestType>(value, new VectorClock(clock.Add(node, 0)), false);
var secondAdd = new LWW_OptimizedSetWithVCElement <TestType>(value, new VectorClock(clock.Add(node, 1)), false);
lwwSet = lwwSet.Assign(firstAdd.Value, firstAdd.VectorClock);
lwwSet = lwwSet.Assign(secondAdd.Value, secondAdd.VectorClock);
Assert.True(lwwSet.Elements.Count(e => Equals(e, firstAdd)) == 0);
Assert.True(lwwSet.Elements.Count(e => Equals(e, secondAdd)) == 1);
}
public void Remove_RemoveSameElementTwiceWithDifferentTimestamp_AddsOneElements(TestType value, Node node)
{
var clock = ImmutableSortedDictionary <Node, long> .Empty;
var lwwSet = new LWW_OptimizedSetWithVC <TestType>();
var add = new LWW_OptimizedSetWithVCElement <TestType>(value, new VectorClock(clock.Add(node, 0)), false);
var firstRemove = new LWW_OptimizedSetWithVCElement <TestType>(value, new VectorClock(clock.Add(node, 1)), true);
var secondRemove = new LWW_OptimizedSetWithVCElement <TestType>(value, new VectorClock(clock.Add(node, 2)), true);
lwwSet = lwwSet.Assign(add.Value, add.VectorClock);
lwwSet = lwwSet.Remove(firstRemove.Value, firstRemove.VectorClock);
lwwSet = lwwSet.Remove(secondRemove.Value, secondRemove.VectorClock);
Assert.True(lwwSet.Elements.Count(e => Equals(e.Value, value)) == 1);
}
public void Lookup_AddedAndRemoved_ReturnsFalse(TestType value, Node node)
{
var clock = ImmutableSortedDictionary <Node, long> .Empty;
var lwwSet = new LWW_OptimizedSetWithVC <TestType>();
var add = new LWW_OptimizedSetWithVCElement <TestType>(value, new VectorClock(clock.Add(node, 0)), false);
var remove = new LWW_OptimizedSetWithVCElement <TestType>(value, new VectorClock(clock.Add(node, 1)), true);
lwwSet = lwwSet.Assign(add.Value, add.VectorClock);
lwwSet = lwwSet.Remove(remove.Value, remove.VectorClock);
var lookup = lwwSet.Lookup(value);
Assert.False(lookup);
}
public void Add_WithExistingValues_AddsElementToTheRepository(HashSet <LWW_OptimizedSetWithVCElement <TestType> > elements, TestType value, Node node)
{
var clock = ImmutableSortedDictionary <Node, long> .Empty;
_repository.PersistElements(elements.ToImmutableHashSet());
var element = new LWW_OptimizedSetWithVCElement <TestType>(value, new VectorClock(clock.Add(node, 0)), false);
_lwwSetService.Merge(new HashSet <LWW_OptimizedSetWithVCElement <TestType> > {
element
}.ToImmutableHashSet());
var repositoryValues = _repository.GetElements();
Assert.Contains(element, repositoryValues);
}
public void Merge_MergesAddsAndRemoves(TestType one, TestType two, TestType three, Node node)
{
var clock = ImmutableSortedDictionary <Node, long> .Empty;
var elementOne = new LWW_OptimizedSetWithVCElement <TestType>(one, new VectorClock(clock.Add(node, 0)), false);
var elementTwo = new LWW_OptimizedSetWithVCElement <TestType>(two, new VectorClock(clock.Add(node, 1)), true);
var elementThree = new LWW_OptimizedSetWithVCElement <TestType>(one, new VectorClock(clock.Add(node, 2)), true);
var elementFour = new LWW_OptimizedSetWithVCElement <TestType>(three, new VectorClock(clock.Add(node, 3)), false);
var elementFive = new LWW_OptimizedSetWithVCElement <TestType>(two, new VectorClock(clock.Add(node, 0)), true);
var lwwSet = new LWW_OptimizedSetWithVC <TestType>(new[] { elementOne, elementTwo }.ToImmutableHashSet());
var newLwwSet = lwwSet.Merge(new[] { elementThree, elementFour, elementFive }.ToImmutableHashSet());
Assert.Equal(5, newLwwSet.Elements.Count);
Assert.Contains(newLwwSet.Elements, e => Equals(e, elementTwo));
Assert.Contains(newLwwSet.Elements, e => Equals(e, elementThree));
Assert.Contains(newLwwSet.Elements, e => Equals(e, elementFour));
}
public void Merge_IsIdempotent(TestType value, Node node)
{
var clock = ImmutableSortedDictionary <Node, long> .Empty;
var removeElement = new LWW_OptimizedSetWithVCElement <TestType>(value, new VectorClock(clock.Add(node, 1)), true);
_lwwSetService.Merge(new HashSet <LWW_OptimizedSetWithVCElement <TestType> > {
removeElement
}.ToImmutableHashSet());
_lwwSetService.Merge(new HashSet <LWW_OptimizedSetWithVCElement <TestType> > {
removeElement
}.ToImmutableHashSet());
_lwwSetService.Merge(new HashSet <LWW_OptimizedSetWithVCElement <TestType> > {
removeElement
}.ToImmutableHashSet());
var repositoryValues = _repository.GetElements();
Assert.Single(repositoryValues);
Assert.Contains(removeElement, repositoryValues);
}
