public void IdleTimeoutBidi_must_signal_error_to_all_outputs()
{
this.AssertAllStagesStopped(() =>
{
var upWrite = TestPublisher.CreateProbe <string>(this);
var upRead = TestSubscriber.CreateProbe <int>(this);
var downWrite = TestPublisher.CreateProbe <int>(this);
var downRead = TestSubscriber.CreateProbe <string>(this);
RunnableGraph.FromGraph(GraphDsl.Create(b =>
{
var timeoutStage = b.Add(BidiFlow.BidirectionalIdleTimeout <string, int>(TimeSpan.FromSeconds(2)));
b.From(Source.FromPublisher <string>(upWrite)).To(timeoutStage.Inlet1);
b.From(timeoutStage.Outlet1).To(Sink.FromSubscriber(downRead));
b.From(timeoutStage.Outlet2).To(Sink.FromSubscriber(upRead));
b.From(Source.FromPublisher <int>(downWrite)).To(timeoutStage.Inlet2);
return(ClosedShape.Instance);
})).Run(Materializer);
var te = new TestException("test");
upWrite.SendError(te);
upRead.ExpectSubscriptionAndError().ShouldBeEquivalentTo(te);
downRead.ExpectSubscriptionAndError().ShouldBeEquivalentTo(te);
downWrite.ExpectCancellation();
}, Materializer);
}
public void IdleTimeoutBidi_must_not_signal_error_if_traffic_is_one_way()
{
this.AssertAllStagesStopped(() =>
{
var upstreamWriter = TestPublisher.CreateProbe <int>(this);
var downstreamWriter = TestPublisher.CreateProbe <string>(this);
var upstream = Flow.FromSinkAndSource(Sink.Ignore <string>(),
Source.FromPublisher <int>(upstreamWriter), Keep.Left);
var downstream = Flow.FromSinkAndSource(Sink.Ignore <int>(),
Source.FromPublisher <string>(downstreamWriter), Keep.Left);
var assembly = upstream.JoinMaterialized(
BidiFlow.BidirectionalIdleTimeout <int, string>(TimeSpan.FromSeconds(2)),
Keep.Left).JoinMaterialized(downstream, Keep.Both);
var r = assembly.Run(Materializer);
var upFinished = r.Item1;
var downFinished = r.Item2;
upstreamWriter.SendNext(1);
Thread.Sleep(1000);
upstreamWriter.SendNext(1);
Thread.Sleep(1000);
upstreamWriter.SendNext(1);
Thread.Sleep(1000);
upstreamWriter.SendComplete();
downstreamWriter.SendComplete();
upFinished.Wait(TimeSpan.FromSeconds(3)).Should().BeTrue();
downFinished.Wait(TimeSpan.FromSeconds(3)).Should().BeTrue();
}, Materializer);
}
public void IdleTimeoutBidi_must_be_able_to_signal_timeout_once_no_traffic_on_either_sides()
{
this.AssertAllStagesStopped(() =>
{
var upWrite = TestPublisher.CreateProbe <string>(this);
var upRead = TestSubscriber.CreateProbe <int>(this);
var downWrite = TestPublisher.CreateProbe <int>(this);
var downRead = TestSubscriber.CreateProbe <string>(this);
RunnableGraph.FromGraph(GraphDsl.Create(b =>
{
var timeoutStage = b.Add(BidiFlow.BidirectionalIdleTimeout <string, int>(TimeSpan.FromSeconds(2)));
b.From(Source.FromPublisher <string>(upWrite)).To(timeoutStage.Inlet1);
b.From(timeoutStage.Outlet1).To(Sink.FromSubscriber(downRead));
b.From(timeoutStage.Outlet2).To(Sink.FromSubscriber(upRead));
b.From(Source.FromPublisher <int>(downWrite)).To(timeoutStage.Inlet2);
return(ClosedShape.Instance);
})).Run(Materializer);
// Request enough for the whole test
upRead.Request(100);
downRead.Request(100);
upWrite.SendNext("DATA1");
downRead.ExpectNext("DATA1");
Thread.Sleep(1500);
downWrite.SendNext(1);
upRead.ExpectNext(1);
Thread.Sleep(1500);
upWrite.SendNext("DATA2");
downRead.ExpectNext("DATA2");
Thread.Sleep(1000);
downWrite.SendNext(2);
upRead.ExpectNext(2);
upRead.ExpectNoMsg(TimeSpan.FromMilliseconds(500));
var error1 = upRead.ExpectError();
var error2 = downRead.ExpectError();
error1.Should().BeOfType <TimeoutException>();
error1.Message.Should().Be($"No elements passed in the last {TimeSpan.FromSeconds(2)}.");
error2.ShouldBeEquivalentTo(error1);
upWrite.ExpectCancellation();
downWrite.ExpectCancellation();
}, Materializer);
}
public void IdleTimeout_must_fail_if_time_between_elements_is_too_large()
{
this.AssertAllStagesStopped(() =>
{
var upstreamProbe = TestPublisher.CreateProbe <int>(this);
var downstreamProbe = this.CreateProbe <int>();
Source.FromPublisher <int>(upstreamProbe)
.IdleTimeout(TimeSpan.FromSeconds(1))
.RunWith(Sink.FromSubscriber(downstreamProbe), Materializer);
// Two seconds in overall, but won't timeout until time between elements is large enough
// (i.e. this works differently from completionTimeout)
for (var i = 1; i <= 4; i++)
{
upstreamProbe.SendNext(1);
downstreamProbe.RequestNext(1);
downstreamProbe.ExpectNoMsg(TimeSpan.FromMilliseconds(500)); // No timeout yet
}
var ex = downstreamProbe.ExpectError();
ex.Message.Should().Be($"No elements passed in the last {TimeSpan.FromSeconds(1)}.");
}, Materializer);
}
public void CompletionTimeout_must_fail_if_not_completed_until_timeout()
{
this.AssertAllStagesStopped(() =>
{
var upstreamProbe = TestPublisher.CreateProbe <int>(this);
var downstreamProbe = this.CreateProbe <int>();
Source.FromPublisher <int>(upstreamProbe)
.CompletionTimeout(TimeSpan.FromSeconds(2))
.RunWith(Sink.FromSubscriber(downstreamProbe), Materializer);
upstreamProbe.SendNext(1);
downstreamProbe.RequestNext(1);
downstreamProbe.ExpectNoMsg(TimeSpan.FromMilliseconds(500)); // No timeout yet
upstreamProbe.SendNext(2);
downstreamProbe.RequestNext(2);
downstreamProbe.ExpectNoMsg(TimeSpan.FromMilliseconds(500)); // No timeout yet
var ex = downstreamProbe.ExpectError();
ex.Message.Should().Be($"The stream has not been completed in {TimeSpan.FromSeconds(2)}.");
}, Materializer);
}
public override IPublisher <T> Create(MaterializationContext context, out TestPublisher.Probe <T> materializer)
{
materializer = TestPublisher.CreateProbe <T>(_testKit);
return(materializer);
}
