public void ExpectSubscriptions_should_work_for_grouped_subscription_and_unsubscription()
{
using (var s = new MarbleScheduler())
{
s.ExpectSubscriptions(new Subscription(20, 20)).ToBe("--(^!)");
}
}
public void Dispose_can_be_called_even_if_start_was_called()
{
using (var s = new MarbleScheduler())
{
s.Start();
}
}
public void Should_expect_empty_observable()
{
var scheduler = new MarbleScheduler();
scheduler.ExpectObservable(Observable.Empty <string>()).ToBe("|", new { });
scheduler.Flush();
}
public void Dispose_allows_for_not_calling_start()
{
using (var s = new MarbleScheduler())
{
s.ExpectSubscriptions(new Subscription()).ToBe("(^!)");
}
}
public void ExpectSubscriptions_should_work_for_empty_subscription()
{
using (var s = new MarbleScheduler())
{
s.ExpectSubscriptions(new Subscription(Subscription.Infinite)).ToBe("");
}
}
public void ExpectObservable_should_work_for_observable_throw()
{
using (var s = new MarbleScheduler())
{
s.ExpectObservable(Observable.Throw <char>(new Exception(), s)).ToBe("#");
}
}
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 ExpectObservable_should_work_for_observable_return()
{
using (var s = new MarbleScheduler())
{
s.ExpectObservable(Observable.Return('a', s)).ToBe("(a|)");
}
}
public void ExpectObservable_should_work_for_observable_empty()
{
using (var s = new MarbleScheduler())
{
s.ExpectObservable(Observable.Empty <int>(s)).ToBe("|", Dict.Empty <int>());
}
}
public void ExpectSubscriptions_should_work_for_subscription_not_at_zero()
{
using (var s = new MarbleScheduler())
{
s.ExpectSubscriptions(new Subscription(20)).ToBe("--^");
}
}
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 ExpectSubscriptions_can_be_called_multiple_times_in_single_test()
{
using (var s = new MarbleScheduler())
{
s.ExpectSubscriptions(new Subscription(20, 20)).ToBe("--(^!)");
s.ExpectSubscriptions(new Subscription(0, 0)).ToBe("(^!)");
s.ExpectSubscriptions(new Subscription(0, 10)).ToBe("^!");
}
}
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_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 ExpectObservable_should_accept_unsubscription_marble_diagram()
{
using (var s = new MarbleScheduler())
{
var source = s.Hot("---^-a-b-|");
var unsubscribe = "---!";
var expected = "--a";
s.ExpectObservable(source, unsubscribe).ToBe(expected);
}
}
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_detect_testable_observable_of_strings()
{
// given
var cold = new MarbleScheduler().CreateColdObservable("--a--");
// when
var result = ReflectionHelper.IsTestableObservable(cold);
// then
Check.That(result).IsTrue();
}
public void Ensure()
{
using (var s = new MarbleScheduler())
{
var e1 = s.Hot("----a--^--b-------c--|");
var e2 = s.Hot("---d-^--e---------f-----|");
var expected = "---(be)----c-f-----|";
s.ExpectObservable(e1.Merge(e2)).ToBe(expected);
}
}
public void Markers()
{
using (var s = new MarbleScheduler())
{
var e1 = s.Hot("-a");
var e2 = s.Hot("--b");
var expected = "-ab";
s.ExpectObservable(e1.Merge(e2)).ToBe(expected);
}
}
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 Start_can_be_called_at_most_once()
{
Action a = () =>
{
var s = new MarbleScheduler();
s.Start();
s.Start();
};
Assert.Throws <InvalidOperationException>(a);
}
public void ExpectObservable_should_support_testing_metastreams()
{
using (var s = new MarbleScheduler())
{
var x = s.Cold("-a-b|");
var y = s.Cold("-c-d|");
var myObservable = s.Hot("---x---y----|", Dict.Map('x', x, 'y', y));
var expected = "---x---y----|";
s.ExpectObservable(myObservable).ToBe(expected, Dict.Map('x', x, 'y', y));
}
}
public void FactMethodName()
{
using (var s = new MarbleScheduler())
{
var source = s.Cold("---a---b-|");
var subs = "^--!";
var d = source.Subscribe();
s.ScheduleAbsolute(30, () => d.Dispose());
s.ExpectSubscriptions(source.Subscriptions).ToBe(subs);
}
}
public void Should_retrieve_notifications_from_string_testable_observable()
{
// given
object cold = new MarbleScheduler().CreateColdObservable("--a--");
// when
var notifications = ReflectionHelper.RetrieveNotificationsFromTestableObservable(cold);
// then
Check.That(notifications).HasSize(1);
Check.That(notifications[0].Time).IsEqualTo(20);
Check.That(notifications[0].Value.Value).IsEqualTo("a");
}
public void Should_retrieve_completed_notification_from_testable_observable()
{
// given
object cold = new MarbleScheduler().CreateColdObservable("---|");
// when
var notifications = ReflectionHelper.RetrieveNotificationsFromTestableObservable(cold);
// then
Check.That(notifications).HasSize(1);
Check.That(notifications[0].Time).IsEqualTo(30);
Check.That(notifications[0].Value.Kind).IsEqualTo(NotificationKind.OnCompleted);
}
public void Should_retrieve_error_notification_from_testable_observable()
{
// given
object cold = new MarbleScheduler().CreateColdObservable <object>("---#", null, new Exception("omg"));
// when
var notifications = ReflectionHelper.RetrieveNotificationsFromTestableObservable(cold);
// then
Check.That(notifications).HasSize(1);
Check.That(notifications[0].Time).IsEqualTo(30);
Check.That(notifications[0].Value.Kind).IsEqualTo(NotificationKind.OnError);
}
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();
}
