Files
spark/src/client/spark_test/api/ApiUpdateTests.cs
T

242 lines
8.7 KiB
C#

using bts.api.core;
using System.Collections.Generic;
using bts.test;
using System;
using System.Reactive.Linq;
using System.Threading.Tasks;
using System.Linq;
using System.Reactive.Concurrency;
namespace mbts.api.Test {
[TestGroup]
public class ApiUpdateTests {
int _id = 0;
List<Item> _item_pool;
public ApiUpdateTests() {
// Generate a pool of items
_item_pool = Enumerable.Range(1, 50).Select(i => mkitem()).ToList();
}
class Item : IEquatable<Item> {
public Item(int id, string name) {
this.id = id;
this.name = name;
}
public int id { get; }
public string name { get; }
public override string ToString() => $"{id}-{name}";
public override bool Equals(object obj) {
if (obj is Item i) {
return this.Equals(i);
}
return false;
}
public override int GetHashCode() {
return ToString().GetHashCode();
}
public bool Equals(Item other) {
return id == other.id && name == other.name;
}
}
static int id(Item i) => i.id;
Item mkitem() {
return new Item(++_id, Guid.NewGuid().ToString().Substring(0,8));
}
IObservable<Update<Item, int>> validate_incremental(IObservable<Update<Item, int>> source) {
// strip the state from source and turn it back into a 'raw' update
// then use the (well tested) reconstitute function to re-build the state from the increments
return source.Select(u => {
var r = new RawUpdate<Item>();
r.added_items.AddRange(u.added);
r.added_keys.AddRange(u.added.Select(id));
r.changed_items.AddRange(u.changed);
r.changed_keys.AddRange(u.changed.Select(id));
r.removed_keys.AddRange(u.removed.Select(id));
return r;
}).reconstitute(id);
}
async Task validate_naggle(IObservable<RawUpdate<Item>> raw) {
var total = raw.ToEnumerable().Count();
// Validate that update is right at each point
// This will mostly be collapsing to add()
for (var count = 1; count < total; ++count) {
var orig = raw.Take(count).reconstitute(id).ToEnumerable().Last();
var nag = await
validate_incremental(
raw
.Take(count)
.reconstitute(i => i.id)
.Naggle(TimeSpan.FromMilliseconds(1), CurrentThreadScheduler.Instance)).LastAsync();
Assert.SequenceEqual(orig.all.OrderBy(id), nag.all.OrderBy(id));
}
// Do it again with TableUpdate
for (var count = 1; count < total; ++count) {
var orig = raw.Take(count).reconstitute(id).Table().ToEnumerable().Last();
var nag = await
validate_incremental(
raw
.Take(count)
.reconstitute(i => i.id)
.Naggle(TimeSpan.FromMilliseconds(1), CurrentThreadScheduler.Instance))
.Table()
.LastAsync();
Assert.SequenceEqual(orig.state.Values.OrderBy(id), nag.state.Values.OrderBy(id));
}
// collapse rolling window
var update_list = raw.reconstitute(id).ToEnumerable().ToList();
var window = 10;
for (int x = 0; x+window < total; x += 5) {
var start = update_list[x];
var end = update_list[x + window];
var super_update = update_list.Skip(x).Take(window+1).Aggregate((u1, u2) => u1.merge(u2));
start.merge(super_update);
Assert.SequenceEqual(end.all, super_update.all);
}
}
[Test]
public async Task test_add() {
// Add 1 item 10x
var raw = Observable.Create<RawUpdate<Item>>(observer => {
RawUpdate<Item> rup = new RawUpdate<Item>();
for (int x = 0; x < 50; ++x) {
rup.Clear();
var item = _item_pool[x];
rup.added_items.Add(item);
rup.added_keys.Add(item.id);
observer.OnNext(rup);
}
observer.OnCompleted();
return Disposable.empty;
});
await validate_naggle(raw);
}
[Test]
public Task test_remove() {
// Add 20 items, then remove 10 one at a time
var raw = Observable.Create<RawUpdate<Item>>(observer => {
RawUpdate<Item> rup = new RawUpdate<Item>();
// add 20 items
rup.added_items.AddRange(_item_pool.Take(20));
rup.added_keys.AddRange(_item_pool.Take(20).Select(id));
observer.OnNext(rup);
for (int x = 0; x < 50; x+=2) {
rup.Clear();
var item = _item_pool[x];
rup.removed_keys.Add(item.id);
observer.OnNext(rup);
}
observer.OnCompleted();
return Disposable.empty;
});
return validate_naggle(raw);
}
[Test]
public Task test_update() {
// Add 20 items, then change all of their names to Taha
var raw = Observable.Create<RawUpdate<Item>>(observer => {
RawUpdate<Item> rup = new RawUpdate<Item>();
// add 20 items
rup.added_items.AddRange(_item_pool.Take(20));
rup.added_keys.AddRange(_item_pool.Take(20).Select(id));
observer.OnNext(rup);
for (int x = 0; x < 20; x++) {
rup.Clear();
var item = _item_pool[x];
var item2 = new Item(item.id, "Taha");
rup.changed_items.Add(item2);
rup.changed_keys.Add(item2.id);
observer.OnNext(rup);
}
observer.OnCompleted();
return Disposable.empty;
});
return validate_naggle(raw);
}
[Test]
public async Task test_random_walk() {
// Split items in half.
// Permute one collection in the direction of the other
var raw = Observable.Create<RawUpdate<Item>>((observer) => {
Random r = new Random(42);
var even = _item_pool.Where(i => i.id % 2 == 0).Take(10).ToList();
var odd = _item_pool.Where(i => i.id % 2 == 1).ToList();
RawUpdate<Item> rup = new RawUpdate<Item>();
rup.added_items.AddRange(even);
rup.added_keys.AddRange(even.Select(i => i.id));
observer.OnNext(rup);
for (var x = 0; x < 200; ++x) {
rup = new RawUpdate<Item>();
switch (r.Next(0, 3)) {
case 0: // add
if (odd.Count > 0) {
even.Add(odd[0]);
rup.added_items.Add(odd[0]);
rup.added_keys.Add(odd[0].id);
odd.RemoveAt(0);
observer.OnNext(rup);
}
break;
case 1: // remove
if (even.Count > 0) {
var item = r.choose(even);
even.Remove(item);
rup.removed_keys.Add(item.id);
observer.OnNext(rup);
}
break;
case 2: // change
if (even.Count > 0) {
var item = r.choose(even);
var item2 = new Item(item.id, "Jake");
var index = even.IndexOf(item);
even[index] = item2;
rup.changed_items.Add(item2);
rup.changed_keys.Add(item2.id);
observer.OnNext(rup);
}
break;
}
}
observer.OnCompleted();
return Disposable.empty;
});
// Since this is deterministic randomness get the final collection
await validate_naggle(raw);
}
[Test]
public void test_merge_begin_end_state() {
int key(string s) => s[0];
var empty = new string[0];
var a2 = new Update<string, int>(new[] { "a2" }, empty, new[] { new Change<string>("a1", "a2") }, empty, key);
var a3 = new Update<string, int>(new[] { "a3" }, empty, new[] { new Change<string>("a2", "a3") }, empty, key);
var merged = a2.merge(a3);
Assert.SequenceEqual(new[] { new Change<string>("a1", "a3") }, merged.changes);
}
}
}