public void RetryConcat_tolerate_killswitch_terminations_inside_the_flow_after_start()
{
var innerFlow = RetryFlow <int>().ViaMaterialized(KillSwitches.Single <Tuple <Result <int>, int> >(), Keep.Right);
var t = this.SourceProbe <int>()
.Select(i => Tuple.Create(i, i * i))
.ViaMaterialized(Retry.Concat(100, innerFlow, x =>
{
if (x % 4 == 0)
{
return new[] { Tuple.Create(x / 2, x / 4) }
}
;
var sqrt = (int)Math.Sqrt(x);
return(new[] { Tuple.Create(sqrt, x) });
}), Keep.Both)
.ToMaterialized(this.SinkProbe <Tuple <Result <int>, int> >(), Keep.Both)
.Run(Sys.Materializer());
var source = t.Item1.Item1;
var killSwitch = t.Item1.Item2;
var sink = t.Item2;
sink.Request(99);
source.SendNext(1);
sink.ExpectNext().Item1.Value.Should().Be(2);
source.SendNext(2);
sink.ExpectNext().Item1.Value.Should().Be(2);
killSwitch.Abort(FailedElement.Exception);
sink.ExpectError().InnerException.Should().Be(FailedElement.Exception);
}
public void RetryConcat_squares_by_division()
{
var t = this.SourceProbe <int>()
.Select(i => Tuple.Create(i, i * i))
.Via(Retry.Concat(100, RetryFlow <int>(), x =>
{
if (x % 4 == 0)
{
return new[] { Tuple.Create(x / 2, x / 4) }
}
;
var sqrt = (int)Math.Sqrt(x);
return(new[] { Tuple.Create(sqrt, x) });
}))
.ToMaterialized(this.SinkProbe <Tuple <Result <int>, int> >(), Keep.Both)
.Run(Sys.Materializer());
var source = t.Item1;
var sink = t.Item2;
sink.Request(99);
source.SendNext(1);
sink.ExpectNext().Item1.Value.Should().Be(2);
source.SendNext(2);
sink.ExpectNext().Item1.Value.Should().Be(2);
source.SendNext(4);
sink.ExpectNext().Item1.Value.Should().Be(2);
sink.ExpectNoMsg(TimeSpan.FromSeconds(3));
source.SendComplete();
sink.ExpectComplete();
}
public void RetryConcat_tolerate_killswitch_terminations_inside_the_flow_on_start()
{
var t = this.SourceProbe <int>()
.ViaMaterialized(KillSwitches.Single <int>(), Keep.Right)
.Select(i => Tuple.Create(i, i))
.Via(Retry.Concat(100, RetryFlow <int>(), x => new[] { Tuple.Create(x, x + 1) }))
.ToMaterialized(this.SinkProbe <Tuple <Result <int>, int> >(), Keep.Both)
.Run(Sys.Materializer());
var killSwitch = t.Item1;
var sink = t.Item2;
sink.Request(99);
killSwitch.Abort(FailedElement.Exception);
sink.ExpectError().InnerException.Should().Be(FailedElement.Exception);
}
public void RetryConcat_should_concat_incremented_ints_and_modulo_3_incremented_ints_from_retries()
{
var t = this.SourceProbe <int>()
.Select(i => Tuple.Create(i, i))
.Via(Retry.Concat(100, RetryFlow <int>(), os =>
{
var s = (os + 1) % 3;
if (os < 42)
{
return new[] { Tuple.Create(os + 1, os + 1), Tuple.Create(s, s) }
}
;
if (os == 42)
{
return(new Tuple <int, int> [0]);
}
return(null);
}))
.ToMaterialized(this.SinkProbe <Tuple <Result <int>, int> >(), Keep.Both)
.Run(Sys.Materializer());
var source = t.Item1;
var sink = t.Item2;
sink.Request(99);
source.SendNext(1);
sink.ExpectNext().Item1.Value.Should().Be(2);
source.SendNext(2);
sink.ExpectNext().Item1.Value.Should().Be(4);
sink.ExpectNext().Item1.Value.Should().Be(2);
sink.ExpectNext().Item1.Value.Should().Be(2);
source.SendNext(44);
sink.ExpectNext().Item1.Value.Should().Be(FailedElement.Value);
source.SendNext(42);
sink.ExpectNoMsg();
source.SendComplete();
sink.ExpectComplete();
}
public void RetryConcat_should_swallow_failed_elements_that_are_retried_with_an_empty_seq()
{
var t = this.SourceProbe <int>()
.Select(i => Tuple.Create(i, i))
.Via(Retry.Concat(100, RetryFlow <int>(), _ => Enumerable.Empty <Tuple <int, int> >()))
.ToMaterialized(this.SinkProbe <Tuple <Result <int>, int> >(), Keep.Both)
.Run(Sys.Materializer());
var source = t.Item1;
var sink = t.Item2;
sink.Request(99);
source.SendNext(1);
sink.ExpectNext().Item1.Value.Should().Be(2);
source.SendNext(2);
sink.ExpectNoMsg();
source.SendNext(3);
sink.ExpectNext().Item1.Value.Should().Be(4);
source.SendNext(4);
sink.ExpectNoMsg();
source.SendComplete();
sink.ExpectComplete();
}
