public void OAPHShouldFireChangeNotifications()
{
var input = new[] {1, 2, 3, 3, 4}.ToObservable();
var output = new List<int>();
(new TestScheduler()).With(sched => {
var fixture = new ObservableAsPropertyHelper<int>(input,
x => output.Add(x), -5);
sched.Start();
// Note: Why doesn't the list match the above one? We're supposed
// to suppress duplicate notifications, of course :)
(new[] { -5, 1, 2, 3, 4 }).AssertAreEqual(output);
});
}
public void AsyncGetTest()
{
var input = new[] { 1, 1, 1, 1, 1 };
var sched = new TestScheduler();
var delay = TimeSpan.FromSeconds(1.0);
var fixture = new ObservableAsyncMRUCache<int, int>(x => Observable.Return(x*5).Delay(delay, sched), 5, 2, null, sched);
int result = 0;
input.ToObservable(sched).SelectMany<int, int>(x => (IObservable<int>)fixture.AsyncGet(x)).Subscribe(x => result += x);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(500)));
Assert.Equal(0, result);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(1200)));
Assert.Equal(25, result);
sched.Start();
Assert.Equal(25, result);
}
public void MessageBusSmokeTest()
{
var input = new[] {1, 2, 3, 4};
var result = (new TestScheduler()).With(sched => {
var source = new Subject<int>();
var fixture = new MessageBus();
fixture.RegisterMessageSource(source, "Test");
Assert.False(fixture.IsRegistered(typeof (int)));
Assert.False(fixture.IsRegistered(typeof (int), "Foo"));
var output = fixture.Listen<int>("Test").CreateCollection();
input.Run(source.OnNext);
sched.Start();
return output;
});
input.AssertAreEqual(result);
}
public void CacheShouldQueueOnceWeHitOurConcurrentLimit()
{
var input = new[] { 1, 2, 3, 4, 1 };
var sched = new TestScheduler();
var delay = TimeSpan.FromSeconds(1.0);
var fixture = new ObservableAsyncMRUCache<int, int>(x => Observable.Return(x*5).Delay(delay, sched), 5, 2, null, sched);
int result = 0;
input.ToObservable(sched).SelectMany<int, int>(x => (IObservable<int>)fixture.AsyncGet(x)).Subscribe(x => result += x);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(500)));
Assert.Equal(0, result);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(1500)));
Assert.Equal(1*5 + 2*5 + 1*5, result);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(2500)));
Assert.Equal(1*5 + 2*5 + 3*5 + 4*5 + 1*5, result);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(5000)));
Assert.Equal(1*5 + 2*5 + 3*5 + 4*5 + 1*5, result);
}
public void GetTest()
{
(new TestScheduler()).With(sched => {
var input = new[] {1, 1, 1, 1, 1};
var delay = TimeSpan.FromSeconds(1.0);
var fixture = new ObservableAsyncMRUCache<int, int>(x => Observable.Return(x*5).Delay(delay, sched), 5, 2);
int result = 0;
var t = new Thread(() => {
// We use this side thread because there's no way to tell
// the cache to Run the Test Scheduler. So the side thread
// will do the waiting while the main thread advances the
// Scheduler
foreach (int x in input.Select(x => fixture.Get(x))) {
result += x;
}
});
t.Start();
sched.Start();
sched.AdvanceToMs(500);
// NB: The Thread.Sleep is to let our other thread catch up
Thread.Sleep(100);
Assert.Equal(0, result);
sched.AdvanceToMs(1200);
Thread.Sleep(100);
Assert.Equal(25, result);
sched.Start();
t.Join();
Assert.Equal(25, result);
});
}
public void ObservableCanExecuteShouldShowUpInCommand()
{
var input = new[] {true, false, false, true, false, true};
var result = (new TestScheduler()).With(sched => {
var can_execute = new Subject<bool>();
var fixture = createCommand(can_execute, sched);
var changes_as_observable = fixture.CanExecuteObservable.CreateCollection();
int change_event_count = 0;
fixture.CanExecuteChanged += (o, e) => { change_event_count++; };
input.Run(x => {
can_execute.OnNext(x);
sched.Start();
Assert.Equal(x, fixture.CanExecute(null));
});
// N.B. We check against '5' instead of 6 because we're supposed to
// suppress changes that aren't actually changes i.e. false => false
sched.AdvanceToMs(10 * 1000);
return changes_as_observable;
});
input.DistinctUntilChanged().AssertAreEqual(result.ToList());
}
public void MultipleSubscribesShouldntResultInMultipleNotifications()
{
var input = new[] { 1, 2, 1, 2 };
var sched = new TestScheduler();
var fixture = createCommand(null, sched);
var odd_list = new List<int>();
var even_list = new List<int>();
fixture.Where(x => ((int)x) % 2 != 0).Subscribe(x => odd_list.Add((int)x));
fixture.Where(x => ((int)x) % 2 == 0).Subscribe(x => even_list.Add((int)x));
input.Run(x => fixture.Execute(x));
sched.AdvanceToMs(1000);
new[]{1,1}.AssertAreEqual(odd_list);
new[]{2,2}.AssertAreEqual(even_list);
}
public void RegisterMemoizedFunctionSmokeTest()
{
var input = new[] { 1, 1, 1, 1, 1, 2, 2, 2, 2, 2 };
var output = new[] { 5, 5, 5, 5, 5, 10, 10, 10, 10, 10 };
var sched = new EventLoopScheduler();
var results = new List<Timestamped<int>>();
var start = sched.Now;
sched.With(_ => {
var fixture = new ReactiveAsyncCommand(null, 5, sched);
fixture.RegisterMemoizedFunction(x => { Thread.Sleep(1000); return ((int) x) * 5; }, 50, null, sched)
.Timestamp()
.Subscribe(x => results.Add(x));
Assert.True(fixture.CanExecute(1));
foreach (var i in input) {
Assert.True(fixture.CanExecute(i));
fixture.Execute(i);
}
Thread.Sleep(2500);
});
Assert.Equal(10, results.Count);
results.Select(x => x.Timestamp - start)
.Run(x => { });
output.AssertAreEqual(results.Select(x => x.Value));
Assert.False(results.Any(x => x.Timestamp - start > new TimeSpan(0, 0, 3)));
}
public void MultipleSubscribersShouldntDecrementRefcountBelowZero()
{
(new TestScheduler()).With(sched => {
var fixture = new ReactiveAsyncCommand();
var results = new List<int>();
bool[] subscribers = new[] { false, false, false, false, false };
var output = fixture.RegisterAsyncObservable(_ =>
Observable.Return(5).Delay(TimeSpan.FromMilliseconds(5000), sched));
output.Subscribe(x => results.Add(x));
Enumerable.Range(0, 5).Run(x => output.Subscribe(_ => subscribers[x] = true));
Assert.True(fixture.CanExecute(null));
fixture.Execute(null);
sched.AdvanceToMs(2000);
Assert.False(fixture.CanExecute(null));
sched.AdvanceToMs(6000);
Assert.True(fixture.CanExecute(null));
Assert.True(results.Count == 1);
Assert.True(results[0] == 5);
Assert.True(subscribers.All(x => x == true));
});
}
public void GetValueShouldActuallyReturnTheValue()
{
var input = new[] {"Foo", "Bar", "Baz"};
var output = new List<string>();
var output2 = new List<string>();
(new TestScheduler()).With(sched => {
var fixture = new TestFixture();
// Two cases: Changed is guaranteed to *not* set ObservedChange.Value
fixture.Changed.Subscribe(x => {
output.Add((string) x.GetValue());
});
// ...whereas ObservableForProperty *is* guaranteed to.
fixture.ObservableForProperty(x => x.IsOnlyOneWord).Subscribe(x => {
output2.Add(x.GetValue());
});
foreach (var v in input) { fixture.IsOnlyOneWord = v; }
sched.AdvanceToMs(1000);
input.AssertAreEqual(output);
input.AssertAreEqual(output2);
});
}
public void ValueTest()
{
var input = new[] {"Foo", "Bar", "Baz"};
IEnumerable<string> output = null;
IEnumerable<string> output2 = null;
(new TestScheduler()).With(sched => {
var fixture = new TestFixture();
// Same deal as above
output = fixture.Changed.Value<object, object, string>().CreateCollection();
output2 = fixture.ObservableForProperty(x => x.IsOnlyOneWord).Value().CreateCollection();
foreach (var v in input) { fixture.IsOnlyOneWord = v; }
sched.AdvanceToMs(1000);
input.AssertAreEqual(output);
input.AssertAreEqual(output2);
});
}
public void CacheShouldEatExceptionsAndMarshalThemToObservable()
{
/* This is a bit tricky:
*
* 5,2 complete at t=1000 simultaneously
* 10,0 get queued up, 0 fails immediately (delay() doesn't delay the OnError),
* so 10 completes at t=2000
* The 7 completes at t=3000
*/
var input = new[] { 5, 2, 10, 0/*boom!*/, 7 };
var sched = new TestScheduler();
Observable.Throw<int>(new Exception("Foo")).Subscribe(x => {
Console.WriteLine(x);
}, ex => {
Console.WriteLine(ex);
}, () => {
Console.WriteLine("Completed");
});
var delay = TimeSpan.FromSeconds(1.0);
var fixture = new ObservableAsyncMRUCache<int, int>(x =>
(x == 0 ? Observable.Throw<int>(new Exception("Boom!")) : Observable.Return(10 * x)).Delay(delay, sched), 5, 2, null, sched);
Exception exception = null;
int completed = 0;
input.ToObservable()
.SelectMany(x => fixture.AsyncGet(x))
.Subscribe(x => {
this.Log().InfoFormat("Result = {0}", x);
completed++;
}, ex => exception = exception ?? ex);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(500)));
Assert.Null(exception);
Assert.Equal(0, completed);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(1500)));
Assert.NotNull(exception);
Assert.Equal(2, completed);
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(7500)));
Assert.NotNull(exception);
Assert.Equal(4, completed);
this.Log().Info(exception);
}
public void CachedValuesTest()
{
var input = new[] { 1, 2, 1, 3, 1 };
var sched = new TestScheduler();
var delay = TimeSpan.FromSeconds(1.0);
var fixture = new ObservableAsyncMRUCache<int, int>(x => Observable.Return(x*5).Delay(delay, sched), 2, 2);
var results = input.ToObservable().SelectMany(fixture.AsyncGet).CreateCollection();
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(500)));
Assert.Equal(0, fixture.CachedValues().Count());
sched.AdvanceTo(sched.FromTimeSpan(TimeSpan.FromMilliseconds(1500)));
var output = fixture.CachedValues().ToArray();
Assert.IsTrue(output.Length == 2);
Assert.Equal(input.Length, results.Count);
}
