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);
        }
Exemple #4
0
        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);
        }