public void GroupBy_must_fail_when_exceeding_maxSubstreams()
{
this.AssertAllStagesStopped(() =>
{
var f = Flow.Create <int>().GroupBy(1, x => x % 2).PrefixAndTail(0).MergeSubstreams();
var t = ((Flow <int, Tuple <IImmutableList <int>, Source <int, NotUsed> >, NotUsed>)f)
.RunWith(TestSource.SourceProbe <int>(this), TestSink.SinkProbe <Tuple <IImmutableList <int>, Source <int, NotUsed> > >(this), Materializer);
var up = t.Item1;
var down = t.Item2;
down.Request(2);
up.SendNext(1);
var first = down.ExpectNext();
var s1 = new StreamPuppet(first.Item2.RunWith(Sink.AsPublisher <int>(false), Materializer), this);
s1.Request(1);
s1.ExpectNext(1);
up.SendNext(2);
var ex = down.ExpectError();
ex.Message.Should().Contain("too many substreams");
s1.ExpectError(ex);
}, Materializer);
}
public void Expand_must_work_properly_with_finite_extrapolations()
{
var t = TestSource.SourceProbe <int>(this)
.Expand(i => Enumerable.Range(0, 4).Select(x => Tuple.Create(i, x)).Take(3).GetEnumerator())
.ToMaterialized(this.SinkProbe <Tuple <int, int> >(), Keep.Both)
.Run(Materializer);
var source = t.Item1;
var sink = t.Item2;
source.SendNext(1);
sink.Request(4)
.ExpectNext(Tuple.Create(1, 0), Tuple.Create(1, 1), Tuple.Create(1, 2))
.ExpectNoMsg(TimeSpan.FromMilliseconds(100));
source.SendNext(2).SendComplete();
sink.ExpectNext(Tuple.Create(2, 0)).ExpectComplete();
}
public void ItShouldPublishMultipleMessagesToSns()
{
var responseMessageStrings = Enumerable.Range(0, 3).Select(i => String.Format("message-id-{0}", i));
var expectedResponseMessages = ImmutableList.CreateRange(responseMessageStrings.Select(s => CreatePublishResponse(s)));
var snsService = Substitute.For <IAmazonSimpleNotificationService>();
snsService.PublishAsync(Arg.Any <PublishRequest>())
.Returns(
Task.FromResult(expectedResponseMessages.First()),
expectedResponseMessages.Skip(1).Select(t => Task.FromResult(t)).ToArray());
var val = TestSource.SourceProbe <string>(this).Via(SnsPublisher.PlainFlow("topic-Arn", snsService)).ToMaterialized(Sink.Seq <PublishResponse>(), Keep.Both).Run(this._materializer);
foreach (var rms in responseMessageStrings)
{
val.Item1.SendNext(rms);
}
val.Item1.SendComplete();
var task = val.Item2.Wait(TimeSpan.FromSeconds(1)).Should().BeTrue();
val.Item2.Result.Should().BeEquivalentTo(expectedResponseMessages);
snsService.ReceivedWithAnyArgs(3);
}
public void A_Flow_using_Join_must_allow_for_concat_cycle()
{
this.AssertAllStagesStopped(() =>
{
var flow = Flow.FromGraph(GraphDsl.Create(TestSource.SourceProbe <string>(this), Sink.First <string>(), Keep.Both, (b, source, sink) =>
{
var concat = b.Add(Concat.Create <string>(2));
var broadcast = b.Add(new Broadcast <string>(2, true));
b.From(source).To(concat.In(0));
b.From(concat.Out).To(broadcast.In);
b.From(broadcast.Out(0)).To(sink);
return(new FlowShape <string, string>(concat.In(1), broadcast.Out(1)));
}));
var tuple = flow.Join(Flow.Create <string>()).Run(Materializer);
var probe = tuple.Item1;
var t = tuple.Item2;
probe.SendNext("lonely traveler");
t.Wait(TimeSpan.FromSeconds(3)).Should().BeTrue();
t.Result.Should().Be("lonely traveler");
probe.SendComplete();
}, Materializer);
}
