242 lines
8.7 KiB
C#
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);
|
|
}
|
|
|
|
}
|
|
}
|