public void FlushScheduler()
{
if (_scheduler != null)
{
_scheduler.Flush();
}
}
public void Should_expect_empty_observable()
{
var scheduler = new MarbleScheduler();
scheduler.ExpectObservable(Observable.Empty <string>()).ToBe("|", new { });
scheduler.Flush();
}
public void Should_expect_one_value_observable()
{
var scheduler = new MarbleScheduler();
scheduler.ExpectObservable(Observable.Return("hello")).ToBe("(h|)", new { h = "hello" });
scheduler.Flush();
}
public void Should_parse_a_simple_time_marble_string_to_a_number()
{
var scheduler = new MarbleScheduler();
var time = scheduler.CreateTime("-----|");
Check.That(time).IsEqualTo(TimeSpan.FromTicks(50));
scheduler.Flush();
}
public void Should_expect_never_observable()
{
var scheduler = new MarbleScheduler();
scheduler.ExpectObservable(Observable.Never <string>()).ToBe("-", new { });
scheduler.ExpectObservable(Observable.Never <string>()).ToBe("---", new { });
scheduler.Flush();
}
public void Should_expect_observable_on_error()
{
var scheduler = new MarbleScheduler();
var source = scheduler.CreateColdObservable <Unit>("---#", null, new Exception());
scheduler.ExpectObservable(source).ToBe("---#", null, new Exception());
scheduler.Flush();
}
public void Should_use_unsubscription_diagram()
{
var scheduler = new MarbleScheduler();
var source = scheduler.CreateHotObservable("---^-a-b-|");
var unsubscribe = "---!";
var expected = "--a";
scheduler.ExpectObservable(source, unsubscribe).ToBe(expected);
scheduler.Flush();
}
public void Should_demo_with_a_simple_operator()
{
var scheduler = new MarbleScheduler();
var sourceEvents = scheduler.CreateColdObservable("a-b-c-|");
var upperEvents = sourceEvents.Select(s => s.ToUpper());
scheduler.ExpectObservable(upperEvents).ToBe("A-B-C-|");
scheduler.Flush();
}
public void Should_fail_when_event_values_differ()
{
var scheduler = new MarbleScheduler();
Check.ThatCode(() =>
{
scheduler.ExpectObservable(Observable.Return("hello")).ToBe("h", new { h = "bye" });
scheduler.Flush();
}).ThrowsAny();
}
public void Should_throw_if_not_given_good_marble_input()
{
var scheduler = new MarbleScheduler();
Action badMarbleInput = () => scheduler.CreateTime("-a-b-c-#");
Check.ThatCode(badMarbleInput).ThrowsAny();
scheduler.Flush();
}
public void Should_fail_when_observables_end_with_different_error_types()
{
var scheduler = new MarbleScheduler();
Check.ThatCode(() =>
{
var source = _scheduler.CreateColdObservable <Unit>("---#", null, new ArgumentException());
scheduler.ExpectObservable(source).ToBe("---#", null, new Exception());
scheduler.Flush();
}).ThrowsAny();
}
public void Should_fail_when_event_timing_differs()
{
var scheduler = new MarbleScheduler();
Action timingDiffer = () =>
{
scheduler.ExpectObservable(Observable.Return("hello")).ToBe("--h", new { h = "hello" });
scheduler.Flush();
};
Check.ThatCode(timingDiffer).ThrowsAny();
}
public void Should_create_a_hot_observable()
{
var scheduler = new MarbleScheduler();
var expected = new[] { "A", "B" };
var source = scheduler.CreateHotObservable <string>("--a---b--|", new { a = "A", b = "B" });
var i = 0;
source.Subscribe(x => Check.That(x).IsEqualTo(expected[i++]));
scheduler.Start();
Check.That(i).IsEqualTo(2);
scheduler.Flush();
}
public async Task should_stop_stream_after_10_seconds()
{
// given
var scheduler = new MarbleScheduler();
var quoteSource = Observable.Never <string>();
// when
var server = CreateServer(quoteSource, scheduler);
var stream = await server.GetEvents();
// then
scheduler.ExpectObservable(stream).ToBe("----------|");
scheduler.Flush();
}
public void Should_support_testing_metastreams()
{
var scheduler = new MarbleScheduler();
var x = scheduler.CreateColdObservable("-a-b|");
var y = scheduler.CreateColdObservable("-c-d|");
var myObservable = scheduler.CreateHotObservable <IObservable <string> >("---x---y----|", new { x = x, y = y });
var expected = "---x---y----|";
var expectedx = scheduler.CreateColdObservable("-a-b|");
var expectedy = scheduler.CreateColdObservable("-c-d|");
scheduler.ExpectObservable(myObservable).ToBe(expected, new { x = expectedx, y = expectedy });
scheduler.Flush();
}
public async Task should_forward_forex_data()
{
// given
var scheduler = new MarbleScheduler();
var forexSource = scheduler.CreateHotObservable <string>("--f--", new { f = new Quote("EUR/USD", 1.4).ToJson() });
// when
var forexStream = await Create(forexSource).GetEvents();
// then
scheduler.ExpectObservable(forexStream.Take(1))
.ToBe("--(v|)", new { v = 1.4 });
scheduler.Flush();
}
public async Task should_send_a_stock_message_when_receiving_a_quote()
{
// given
var scheduler = new MarbleScheduler();
var quoteSource = scheduler.CreateHotObservable <string>("--q--", new { q = new Quote("GOOGL", 705.8673).ToJson() });
// when
var server = CreateServer(quoteSource, scheduler);
var stream = await server.GetEvents();
// then
scheduler.ExpectObservable(stream.Select(s => s.CompanyName).Concat(Observable.Never <string>()))
.ToBe("--s--", new { s = "Alphabet Inc" });
scheduler.Flush();
}
public void Should_expect_subscription_on_a_cold_observable()
{
var scheduler = new MarbleScheduler();
var source = scheduler.CreateColdObservable("---a---b-|");
var subscription = source.Subscribe();
scheduler.ScheduleAbsolute(subscription, 90, (sched, sub) =>
{
sub.Dispose();
return(Disposable.Empty);
});
var subs = "^--------!";
scheduler.ExpectSubscription(source.Subscriptions).ToBe(subs);
scheduler.Flush();
}
public void Should_demo_metastreams_with_windows()
{
var scheduler = new MarbleScheduler();
var input = "a---b---c---d-|";
var myObservable = scheduler.CreateColdObservable(input);
var result = myObservable.Window(2, 1);
var aWindow = scheduler.CreateColdObservable("a---(b|)");
var bWindow = scheduler.CreateColdObservable("----b---(c|)");
var cWindow = scheduler.CreateColdObservable("----c---(d|)");
var dWindow = scheduler.CreateColdObservable("----d-|");
var eWindow = scheduler.CreateColdObservable("--|");
var expected = "(ab)c---d---e-|";
scheduler.ExpectObservable(result).ToBe(expected, new { a = aWindow, b = bWindow, c = cWindow, d = dWindow, e = eWindow });
scheduler.Flush();
}
public async Task should_send_a_stock_message_only_once_when_receiving_two_quotes_for_the_same_stock()
{
// given
var scheduler = new MarbleScheduler();
var quoteSource = scheduler.CreateHotObservable <string>("--f-s-t--", new
{
f = new Quote("GOOGL", 705.8673).ToJson(),
s = new Quote("GOOGL", 705.8912).ToJson(),
t = new Quote("IBM", 106.344).ToJson()
});
// when
var server = CreateServer(quoteSource, scheduler);
var stream = await server.GetEvents();
// then
scheduler.ExpectObservable(stream.Select(s => s.CompanyName).Concat(Observable.Never <string>()))
.ToBe("--g---i--", new
{
g = "Alphabet Inc",
i = "International Business Machines Corp."
});
scheduler.Flush();
}
