public void GroupTokenIsNotNullWhenGroupsChangeToEmpty()
{
var response = new PersistentResponse();
var groupSet = new DiffSet <string>(new string[] { "b", "d" });
groupSet.DetectChanges();
groupSet.Remove("b");
groupSet.Remove("d");
var serializer = JsonUtility.CreateDefaultSerializer();
var protectedData = new Mock <IProtectedData>();
protectedData.Setup(m => m.Protect(It.IsAny <string>(), It.IsAny <string>()))
.Returns <string, string>((value, purpose) => value);
protectedData.Setup(m => m.Unprotect(It.IsAny <string>(), It.IsAny <string>()))
.Returns <string, string>((value, purpose) => value);
Connection.PopulateResponseState(response, groupSet, serializer, protectedData.Object, connectionId: "myconnection");
Assert.NotNull(response.GroupsToken);
var parts = response.GroupsToken.Split(new[] { ':' }, 2);
Assert.Equal(2, parts.Length);
Assert.Equal("myconnection", parts[0]);
var groups = serializer.Deserialize <string[]>(new JsonTextReader(new StringReader(parts[1])));
Assert.Equal(0, groups.Length);
}
public void GroupTokenIsNotNullWhenGroupsChangeToEmpty()
{
var response = new PersistentResponse();
var groupSet = new DiffSet<string>(new string[] { "b", "d" });
groupSet.DetectChanges();
groupSet.Remove("b");
groupSet.Remove("d");
var serializer = new Mock<IJsonSerializer>();
HashSet<string> results = null;
serializer.Setup(m => m.Serialize(It.IsAny<object>(), It.IsAny<TextWriter>()))
.Callback<object, TextWriter>((obj, tw) =>
{
results = new HashSet<string>((IEnumerable<string>)obj);
var jsonNet = new JsonNetSerializer();
jsonNet.Serialize(obj, tw);
});
var protectedData = new Mock<IProtectedData>();
protectedData.Setup(m => m.Protect(It.IsAny<string>(), It.IsAny<string>()))
.Returns<string, string>((value, purpose) => value);
protectedData.Setup(m => m.Unprotect(It.IsAny<string>(), It.IsAny<string>()))
.Returns<string, string>((value, purpose) => value);
Connection.PopulateResponseState(response, groupSet, serializer.Object, protectedData.Object, connectionId: "myconnection");
Assert.NotNull(response.GroupsToken);
var parts = response.GroupsToken.Split(new[] { ':' }, 2);
Assert.Equal(2, parts.Length);
Assert.Equal("myconnection", parts[0]);
Assert.Equal(0, results.Count);
}
public void GroupTokenIsNotNullWhenGroupsChange()
{
var response = new PersistentResponse();
var groupSet = new DiffSet<string>(new string[] { "a:1", "b:2", "c", "d" });
groupSet.DetectChanges();
groupSet.Add("g");
var serializer = JsonUtility.CreateDefaultSerializer();
string results = string.Empty;
var protectedData = new Mock<IProtectedData>();
protectedData.Setup(m => m.Protect(It.IsAny<string>(), It.IsAny<string>()))
.Returns<string, string>((value, purpose) =>
{
results = value;
return value;
});
protectedData.Setup(m => m.Unprotect(It.IsAny<string>(), It.IsAny<string>()))
.Returns<string, string>((value, purpose) => value);
Connection.PopulateResponseState(response, groupSet, serializer, protectedData.Object, connectionId: "myconnection");
Assert.NotNull(response.GroupsToken);
var parts = response.GroupsToken.Split(new[] { ':' }, 2);
Assert.Equal(2, parts.Length);
Assert.Equal("myconnection", parts[0]);
Assert.True(results.Contains("a:1"));
Assert.True(results.Contains("b:2"));
Assert.True(results.Contains("c"));
Assert.True(results.Contains("d"));
Assert.True(results.Contains("g"));
}
public void DetectChangesReturnsFalseNotChanged()
{
var diffSet = new DiffSet<int>(Enumerable.Empty<int>());
diffSet.Add(1);
diffSet.Remove(1);
var result = diffSet.DetectChanges();
Assert.False(result);
}
public void DetectChangesReturnsTrueIfChangedToNothing()
{
var diffSet = new DiffSet <int>(new[] { 1 });
diffSet.Remove(1);
var result = diffSet.DetectChanges();
Assert.True(result);
}
public void DetectChangesReturnsFalseIfItemsAlreadyInSet()
{
var diffSet = new DiffSet<int>(new[] { 0, 10, 20 });
diffSet.Add(0);
diffSet.Add(10);
diffSet.Add(20);
var result = diffSet.DetectChanges();
Assert.False(result);
}
public void DetectChangesReturnsFalseNotChanged()
{
var diffSet = new DiffSet <int>(Enumerable.Empty <int>());
diffSet.Add(1);
diffSet.Remove(1);
var result = diffSet.DetectChanges();
Assert.False(result);
}
public void AddingAndRemovingSameItemDoesNotShowUpInDiff()
{
// (0-100)
var diffSet = new DiffSet <int>(Enumerable.Range(0, 100));
Assert.True(diffSet.Add(100));
Assert.True(diffSet.Remove(98));
Assert.True(diffSet.Remove(99));
Assert.True(diffSet.Remove(100));
Assert.True(diffSet.Add(99));
Assert.True(diffSet.Add(98));
Assert.Equal(100, diffSet.GetSnapshot().Count);
// (0-100)
var changes = diffSet.DetectChanges();
Assert.False(changes);
for (int i = 0; i < 100; i++)
{
Assert.True(diffSet.Contains(i));
}
Assert.True(diffSet.Add(150));
Assert.True(diffSet.Add(200));
Assert.True(diffSet.Remove(50));
Assert.True(diffSet.Remove(200));
Assert.True(diffSet.Remove(150));
Assert.True(diffSet.Add(50));
Assert.Equal(100, diffSet.GetSnapshot().Count);
changes = diffSet.DetectChanges();
Assert.False(changes);
for (int i = 0; i < 100; i++)
{
Assert.True(diffSet.Contains(i));
}
}
public void DetectChangesReturnsFalseIfItemsAlreadyInSet()
{
var diffSet = new DiffSet <int>(new[] { 0, 10, 20 });
diffSet.Add(0);
diffSet.Add(10);
diffSet.Add(20);
var result = diffSet.DetectChanges();
Assert.False(result);
}
public void AddingAndRemovingSameItemMultipleTimesShowsUpOnceInTheDiff()
{
var diffSet = new DiffSet <int>(Enumerable.Range(0, 100));
Assert.False(diffSet.Add(0)); // no-op
Assert.True(diffSet.Remove(99));
Assert.False(diffSet.Remove(99)); // no-op
Assert.Equal(99, diffSet.GetSnapshot().Count);
var changes = diffSet.DetectChanges();
Assert.True(changes);
for (int i = 0; i < 99; i++)
{
Assert.True(diffSet.Contains(i));
}
Assert.False(diffSet.Add(1)); // no-op
Assert.True(diffSet.Add(99));
Assert.False(diffSet.Add(99)); // no-op
Assert.False(diffSet.Remove(101)); // no-op
Assert.True(diffSet.Remove(0));
Assert.False(diffSet.Remove(0)); // no-op
Assert.Equal(99, diffSet.GetSnapshot().Count);
changes = diffSet.DetectChanges();
Assert.True(changes);
Assert.True(diffSet.Contains(99));
Assert.False(diffSet.Contains(0));
for (int i = 1; i < 100; i++)
{
Assert.True(diffSet.Contains(i));
}
}
public void DetectChangesReturnsFalseNotChangedAgain()
{
var diffSet = new DiffSet<int>(new[] { 1 });
diffSet.Remove(1);
diffSet.Add(1);
var result = diffSet.DetectChanges();
var items = diffSet.GetSnapshot().ToList();
Assert.False(result);
Assert.Equal(1, items[0]);
Assert.Equal(1, items.Count);
}
public void DetectChangesReturnsTrueIfNoneToSome()
{
var diffSet = new DiffSet<int>(Enumerable.Empty<int>());
diffSet.Add(1);
diffSet.Remove(1);
diffSet.Add(5);
var result = diffSet.DetectChanges();
var items = diffSet.GetSnapshot().ToList();
Assert.True(result);
Assert.Equal(5, items[0]);
}
public void DetectChangesReturnsTrueIfNoneToSome()
{
var diffSet = new DiffSet <int>(Enumerable.Empty <int>());
diffSet.Add(1);
diffSet.Remove(1);
diffSet.Add(5);
var result = diffSet.DetectChanges();
var items = diffSet.GetSnapshot().ToList();
Assert.True(result);
Assert.Equal(5, items[0]);
}
public void DetectChangesReturnsFalseNotChangedAgain()
{
var diffSet = new DiffSet <int>(new[] { 1 });
diffSet.Remove(1);
diffSet.Add(1);
var result = diffSet.DetectChanges();
var items = diffSet.GetSnapshot().ToList();
Assert.False(result);
Assert.Equal(1, items[0]);
Assert.Equal(1, items.Count);
}
public void DetectChangesReturnsTrueIfItemsNotAlreadyInSet()
{
var diffSet = new DiffSet<int>(new[] { 0, 10, 20 });
diffSet.Add(50);
diffSet.Add(10);
diffSet.Add(30);
diffSet.Remove(10);
var result = diffSet.DetectChanges();
var list = diffSet.GetSnapshot().OrderBy(i => i).ToList();
Assert.True(result);
Assert.Equal(4, list.Count);
Assert.Equal(0, list[0]);
Assert.Equal(20, list[1]);
Assert.Equal(30, list[2]);
Assert.Equal(50, list[3]);
}
public void DetectChangesReturnsTrueIfItemsNotAlreadyInSet()
{
var diffSet = new DiffSet <int>(new[] { 0, 10, 20 });
diffSet.Add(50);
diffSet.Add(10);
diffSet.Add(30);
diffSet.Remove(10);
var result = diffSet.DetectChanges();
var list = diffSet.GetSnapshot().OrderBy(i => i).ToList();
Assert.True(result);
Assert.Equal(4, list.Count);
Assert.Equal(0, list[0]);
Assert.Equal(20, list[1]);
Assert.Equal(30, list[2]);
Assert.Equal(50, list[3]);
}
public void GroupTokenIsNullWhenNoNewGroups()
{
var response = new PersistentResponse();
var groupSet = new DiffSet<string>(new string[] { "a", "b", "c" });
// Get the first diff
groupSet.DetectChanges();
var serializer = JsonUtility.CreateDefaultSerializer();
var protectedData = new Mock<IProtectedData>();
protectedData.Setup(m => m.Protect(It.IsAny<string>(), It.IsAny<string>()))
.Returns<string, string>((value, purpose) => value);
protectedData.Setup(m => m.Unprotect(It.IsAny<string>(), It.IsAny<string>()))
.Returns<string, string>((value, purpose) => value);
Connection.PopulateResponseState(response, groupSet, serializer, protectedData.Object, connectionId: null);
Assert.Null(response.GroupsToken);
}
public void GroupTokenIsNullWhenNoNewGroups()
{
var response = new PersistentResponse();
var groupSet = new DiffSet <string>(new string[] { "a", "b", "c" });
// Get the first diff
groupSet.DetectChanges();
var serializer = new JsonNetSerializer();
var protectedData = new Mock <IProtectedData>();
protectedData.Setup(m => m.Protect(It.IsAny <string>(), It.IsAny <string>()))
.Returns <string, string>((value, purpose) => value);
protectedData.Setup(m => m.Unprotect(It.IsAny <string>(), It.IsAny <string>()))
.Returns <string, string>((value, purpose) => value);
Connection.PopulateResponseState(response, groupSet, serializer, protectedData.Object, connectionId: null);
Assert.Null(response.GroupsToken);
}
public void GroupTokenIsNotNullWhenGroupsChange()
{
var response = new PersistentResponse();
var groupSet = new DiffSet <string>(new string[] { "a:1", "b:2", "c", "d" });
groupSet.DetectChanges();
groupSet.Add("g");
var serializer = new Mock <IJsonSerializer>();
HashSet <string> results = null;
serializer.Setup(m => m.Serialize(It.IsAny <object>(), It.IsAny <TextWriter>()))
.Callback <object, TextWriter>((obj, tw) =>
{
results = new HashSet <string>((IEnumerable <string>)obj);
var jsonNet = new JsonNetSerializer();
jsonNet.Serialize(obj, tw);
});
var protectedData = new Mock <IProtectedData>();
protectedData.Setup(m => m.Protect(It.IsAny <string>(), It.IsAny <string>()))
.Returns <string, string>((value, purpose) => value);
protectedData.Setup(m => m.Unprotect(It.IsAny <string>(), It.IsAny <string>()))
.Returns <string, string>((value, purpose) => value);
Connection.PopulateResponseState(response, groupSet, serializer.Object, protectedData.Object, connectionId: "myconnection");
Assert.NotNull(response.GroupsToken);
var parts = response.GroupsToken.Split(new[] { ':' }, 2);
Assert.Equal(2, parts.Length);
Assert.Equal("myconnection", parts[0]);
Assert.True(results.Contains("a:1"));
Assert.True(results.Contains("b:2"));
Assert.True(results.Contains("c"));
Assert.True(results.Contains("d"));
Assert.True(results.Contains("g"));
}
public void InitialValueCombineWithChangesInFirstDiff()
{
var diffSet = new DiffSet <int>(Enumerable.Range(0, 100));
Assert.True(diffSet.Add(-1));
Assert.True(diffSet.Add(100));
Assert.True(diffSet.Remove(0));
Assert.True(diffSet.Remove(-1));
Assert.Equal(100, diffSet.GetSnapshot().Count);
var changes = diffSet.DetectChanges();
var items = diffSet.GetSnapshot();
Assert.True(changes);
Assert.Equal(100, items.Count);
Assert.False(diffSet.Contains(0));
for (int i = 1; i <= 100; i++)
{
Assert.True(diffSet.Contains(i));
}
}
public void GroupTokenIsNotNullWhenGroupsChange()
{
var response = new PersistentResponse();
var groupSet = new DiffSet <string>(new string[] { "a:1", "b:2", "c", "d" });
groupSet.DetectChanges();
groupSet.Add("g");
var serializer = JsonUtility.CreateDefaultSerializer();
string results = string.Empty;
var protectedData = new Mock <IProtectedData>();
protectedData.Setup(m => m.Protect(It.IsAny <string>(), It.IsAny <string>()))
.Returns <string, string>((value, purpose) =>
{
results = value;
return(value);
});
protectedData.Setup(m => m.Unprotect(It.IsAny <string>(), It.IsAny <string>()))
.Returns <string, string>((value, purpose) => value);
Connection.PopulateResponseState(response, groupSet, serializer, protectedData.Object, connectionId: "myconnection");
Assert.NotNull(response.GroupsToken);
var parts = response.GroupsToken.Split(new[] { ':' }, 2);
Assert.Equal(2, parts.Length);
Assert.Equal("myconnection", parts[0]);
Assert.True(results.Contains("a:1"));
Assert.True(results.Contains("b:2"));
Assert.True(results.Contains("c"));
Assert.True(results.Contains("d"));
Assert.True(results.Contains("g"));
}
public void GroupTokenIsNotNullWhenGroupsChangeToEmpty()
{
var response = new PersistentResponse();
var groupSet = new DiffSet<string>(new string[] { "b", "d" });
groupSet.DetectChanges();
groupSet.Remove("b");
groupSet.Remove("d");
var serializer = JsonUtility.CreateDefaultSerializer();
var protectedData = new Mock<IProtectedData>();
protectedData.Setup(m => m.Protect(It.IsAny<string>(), It.IsAny<string>()))
.Returns<string, string>((value, purpose) => value);
protectedData.Setup(m => m.Unprotect(It.IsAny<string>(), It.IsAny<string>()))
.Returns<string, string>((value, purpose) => value);
Connection.PopulateResponseState(response, groupSet, serializer, protectedData.Object, connectionId: "myconnection");
Assert.NotNull(response.GroupsToken);
var parts = response.GroupsToken.Split(new[] { ':' }, 2);
Assert.Equal(2, parts.Length);
Assert.Equal("myconnection", parts[0]);
var groups = serializer.Deserialize<string[]>(new JsonTextReader(new StringReader(parts[1])));
Assert.Equal(0, groups.Length);
}
public void InitialValueCombineWithChangesInFirstDiff()
{
var diffSet = new DiffSet<int>(Enumerable.Range(0, 100));
Assert.True(diffSet.Add(-1));
Assert.True(diffSet.Add(100));
Assert.True(diffSet.Remove(0));
Assert.True(diffSet.Remove(-1));
Assert.Equal(100, diffSet.GetSnapshot().Count);
var changes = diffSet.DetectChanges();
var items = diffSet.GetSnapshot();
Assert.True(changes);
Assert.Equal(100, items.Count);
Assert.False(diffSet.Contains(0));
for (int i = 1; i <= 100; i++)
{
Assert.True(diffSet.Contains(i));
}
}
internal static void PopulateResponseState(PersistentResponse response,
DiffSet<string> groupSet,
IJsonSerializer serializer,
IProtectedData protectedData,
string connectionId)
{
bool anyChanges = groupSet.DetectChanges();
if (anyChanges)
{
// Create a protected payload of the sorted list
IEnumerable<string> groups = groupSet.GetSnapshot();
// Remove group prefixes before any thing goes over the wire
string groupsString = connectionId + ':' + serializer.Stringify(PrefixHelper.RemoveGroupPrefixes(groups)); ;
// The groups token
response.GroupsToken = protectedData.Protect(groupsString, Purposes.Groups);
}
}
public void DetectChangesReturnsTrueIfChangedToNothing()
{
var diffSet = new DiffSet<int>(new[] { 1 });
diffSet.Remove(1);
var result = diffSet.DetectChanges();
Assert.True(result);
}
public void AddingAndRemovingSameItemMultipleTimesShowsUpOnceInTheDiff()
{
var diffSet = new DiffSet<int>(Enumerable.Range(0, 100));
Assert.False(diffSet.Add(0)); // no-op
Assert.True(diffSet.Remove(99));
Assert.False(diffSet.Remove(99)); // no-op
Assert.Equal(99, diffSet.GetSnapshot().Count);
var changes = diffSet.DetectChanges();
Assert.True(changes);
for (int i = 0; i < 99; i++)
{
Assert.True(diffSet.Contains(i));
}
Assert.False(diffSet.Add(1)); // no-op
Assert.True(diffSet.Add(99));
Assert.False(diffSet.Add(99)); // no-op
Assert.False(diffSet.Remove(101)); // no-op
Assert.True(diffSet.Remove(0));
Assert.False(diffSet.Remove(0)); // no-op
Assert.Equal(99, diffSet.GetSnapshot().Count);
changes = diffSet.DetectChanges();
Assert.True(changes);
Assert.True(diffSet.Contains(99));
Assert.False(diffSet.Contains(0));
for (int i = 1; i < 100; i++)
{
Assert.True(diffSet.Contains(i));
}
}
public void AddingAndRemovingSameItemDoesNotShowUpInDiff()
{
// (0-100)
var diffSet = new DiffSet<int>(Enumerable.Range(0, 100));
Assert.True(diffSet.Add(100));
Assert.True(diffSet.Remove(98));
Assert.True(diffSet.Remove(99));
Assert.True(diffSet.Remove(100));
Assert.True(diffSet.Add(99));
Assert.True(diffSet.Add(98));
Assert.Equal(100, diffSet.GetSnapshot().Count);
// (0-100)
var changes = diffSet.DetectChanges();
Assert.False(changes);
for (int i = 0; i < 100; i++)
{
Assert.True(diffSet.Contains(i));
}
Assert.True(diffSet.Add(150));
Assert.True(diffSet.Add(200));
Assert.True(diffSet.Remove(50));
Assert.True(diffSet.Remove(200));
Assert.True(diffSet.Remove(150));
Assert.True(diffSet.Add(50));
Assert.Equal(100, diffSet.GetSnapshot().Count);
changes = diffSet.DetectChanges();
Assert.False(changes);
for (int i = 0; i < 100; i++)
{
Assert.True(diffSet.Contains(i));
}
}
