public void AutoRefreshGroup()
{
var items = Enumerable.Range(1, 100)
.Select(i => new Person("Person" + i, i))
.ToArray();
//result should only be true when all items are set to true
using (var list = new SourceList <Person>())
using (var results = list.Connect()
.AutoRefresh(p => p.Age)
.GroupOn(p => p.Age % 10)
.AsAggregator())
{
void CheckContent()
{
foreach (var grouping in items.GroupBy(p => p.Age % 10))
{
var childGroup = results.Data.Items.Single(g => g.GroupKey == grouping.Key);
var expected = grouping.OrderBy(p => p.Name);
var actual = childGroup.List.Items.OrderBy(p => p.Name);
actual.ShouldAllBeEquivalentTo(expected);
}
}
list.AddRange(items);
results.Data.Count.Should().Be(10);
results.Messages.Count.Should().Be(1);
CheckContent();
//move person from group 1 to 2
items[0].Age = items[0].Age + 1;
CheckContent();
//change the value and move to a grouping which does not yet exist
items[1].Age = -1;
results.Data.Count.Should().Be(11);
results.Data.Items.Last().GroupKey.Should().Be(-1);
results.Data.Items.Last().List.Count.Should().Be(1);
results.Data.Items.First().List.Count.Should().Be(9);
CheckContent();
//put the value back where it was and check the group was removed
items[1].Age = 1;
results.Data.Count.Should().Be(10);
CheckContent();
var groupOf3 = results.Data.Items.ElementAt(2);
IChangeSet <Person> changes = null;
groupOf3.List.Connect().Subscribe(c => changes = c);
//refresh an item which makes it belong to the same group - should then propagate a refresh
items[2].Age = 13;
changes.Should().NotBeNull();
changes.Count.Should().Be(1);
changes.First().Reason.Should().Be(ListChangeReason.Refresh);
changes.First().Item.Current.Should().BeSameAs(items[2]);
}
}
public void DeferUntilLoadedDoesNothingUntilDataHasBeenReceived()
{
bool updateReceived = false;
IChangeSet <Person, string>?result = null;
var cache = new SourceCache <Person, string>(p => p.Name);
var deferStream = cache.Connect().DeferUntilLoaded().Subscribe(
changes =>
{
updateReceived = true;
result = changes;
});
var person = new Person("Test", 1);
updateReceived.Should().BeFalse();
cache.AddOrUpdate(person);
updateReceived.Should().BeTrue();
if (result is null)
{
throw new InvalidOperationException(nameof(result));
}
result.Adds.Should().Be(1);
result.First().Current.Should().Be(person);
deferStream.Dispose();
}
private void OnSelectedNodesChanged(IChangeSet <NodeViewModel> changeset)
{
Change <NodeViewModel> change = changeset.First();
NodeViewModel view = change.Item.Current;
if (view == null)
{
return;
}
if (view.Outputs.Count > 0 && view.Outputs.Items.First().Editor is VectorValueEditorViewModel vec_model)
{
switch (change.Reason)
{
case ListChangeReason.Add:
EditorSelection.AddToSelection(vec_model.Value[0]);
break;
case ListChangeReason.Remove:
EditorSelection.RemoveFromSelection(vec_model.Value[0]);
break;
}
}
else if (view.Outputs.Items.First().Parent is CutNodeViewModel cut_model && changeset.Removes == 0)
{
OnUserRequestPreviewShot(cut_model.Cut);
}
}
public void Add()
{
var person = new Person("Adult1", 50);
_updater.AddOrUpdate(person);
IChangeSet <Person, string> updates = _updater.AsChangeSet();
_cache.Lookup("Adult1").Value.Should().Be(person);
_cache.Count.Should().Be(1);
1.Should().Be(updates.Count, "Should be 1 updates");
updates.First().Should().Be(new Change <Person, string>(ChangeReason.Add, person.Name, person), "Should be 1 updates");
}
public void DeferUntilLoadedDoesNothingUntilDataHasBeenReceived()
{
bool updateReceived = false;
IChangeSet <Person> result = null;
var cache = new SourceList <Person>();
var deferStream = cache.Connect().DeferUntilLoaded()
.Subscribe(changes =>
{
updateReceived = true;
result = changes;
});
Assert.IsFalse(updateReceived, "No update should be received");
cache.Add(new Person("Test", 1));
Assert.IsTrue(updateReceived, "Replace should be received");
Assert.AreEqual(1, result.Adds);
Assert.AreEqual(new Person("Test", 1), result.First().Item.Current);
deferStream.Dispose();
}
public void DeferUntilLoadedDoesNothingUntilDataHasBeenReceived()
{
bool updateReceived = false;
IChangeSet <Person> result = null;
var cache = new SourceList <Person>();
var deferStream = cache.Connect().DeferUntilLoaded()
.Subscribe(changes =>
{
updateReceived = true;
result = changes;
});
var person = new Person("Test", 1);
updateReceived.Should().BeFalse();
cache.Add(person);
updateReceived.Should().BeTrue();
result.Adds.Should().Be(1);
result.First().Item.Current.Should().Be(person);
deferStream.Dispose();
}
public void Add()
{
var person = new Person("Adult1", 50);
_updater.AddOrUpdate(person, "Adult1");
IChangeSet <Person, string> updates = _updater.AsChangeSet();
Assert.AreEqual(person, _cache.Lookup("Adult1").Value);
Assert.AreEqual(1, _cache.Count);
Assert.AreEqual(updates.Count, 1, "Should be 1 updates");
Assert.AreEqual(new Change <Person, string>(ChangeReason.Add, person.Name, person), updates.First(),
"Should be 1 updates");
}
