public void Maybe_Source_must_complete_materialized_future_with_None_when_stream_cancels()
{
this.AssertAllStagesStopped(() =>
{
var neverSource = Source.Maybe <object>();
var pubSink = Sink.AsPublisher <object>(false);
var t = neverSource.ToMaterialized(pubSink, Keep.Both).Run(Materializer);
var f = t.Item1;
var neverPub = t.Item2;
var c = this.CreateManualSubscriberProbe <object>();
neverPub.Subscribe(c);
var subs = c.ExpectSubscription();
subs.Request(1000);
c.ExpectNoMsg(TimeSpan.FromMilliseconds(300));
subs.Cancel();
f.Task.AwaitResult().Should().Be(null);
}, Materializer);
}
public void PrefixAndTail_must_work_even_if_tail_subscriber_arrives_after_substream_completion()
{
var pub = this.CreateManualPublisherProbe <int>();
var sub = this.CreateManualSubscriberProbe <int>();
var f =
Source.FromPublisher(pub)
.PrefixAndTail(1)
.RunWith(Sink.First <Tuple <IImmutableList <int>, Source <int, NotUsed> > >(), Materializer);
var s = pub.ExpectSubscription();
s.SendNext(0);
f.Wait(TimeSpan.FromSeconds(3)).Should().BeTrue();
var tail = f.Result.Item2;
var tailPub = tail.RunWith(Sink.AsPublisher <int>(false), Materializer);
s.SendComplete();
tailPub.Subscribe(sub);
sub.ExpectSubscriptionAndComplete();
}
public void FileSource_should_open_file_in_shared_mode_for_reading_multiple_times()
{
this.AssertAllStagesStopped(() =>
{
var testFile = TestFile();
var p1 = FileIO.FromFile(testFile).RunWith(Sink.AsPublisher <ByteString>(false), _materializer);
var p2 = FileIO.FromFile(testFile).RunWith(Sink.AsPublisher <ByteString>(false), _materializer);
var c1 = this.CreateManualSubscriberProbe <ByteString>();
var c2 = this.CreateManualSubscriberProbe <ByteString>();
p1.Subscribe(c1);
p2.Subscribe(c2);
var s1 = c1.ExpectSubscription();
var s2 = c2.ExpectSubscription();
s1.Request(5000);
s2.Request(5000);
c1.ExpectNext();
c2.ExpectNext();
}, _materializer);
}
public void A_Flow_must_materialize_into_Publisher_Subscriber()
{
var flow = Flow.Create <string>();
var t = MaterializeIntoSubscriberAndPublisher(flow, Materializer);
var flowIn = t.Item1;
var flowOut = t.Item2;
var c1 = this.CreateManualSubscriberProbe <string>();
flowOut.Subscribe(c1);
var source = Source.From(new[] { "1", "2", "3" }).RunWith(Sink.AsPublisher <string>(false), Materializer);
source.Subscribe(flowIn);
var sub1 = c1.ExpectSubscription();
sub1.Request(3);
c1.ExpectNext("1");
c1.ExpectNext("2");
c1.ExpectNext("3");
c1.ExpectComplete();
}
public void A_Graph_should_build_unzip_zip()
{
RunnableGraph.FromGraph(GraphDsl.Create(b =>
{
var zip = b.Add(new Zip <int, string>());
var unzip = b.Add(new UnZip <int, string>());
var sink = Sink.AsPublisher <Tuple <int, string> >(false).MapMaterializedValue(_ => NotUsed.Instance);
var source =
Source.From(new[]
{
new KeyValuePair <int, string>(1, "a"), new KeyValuePair <int, string>(2, "b"),
new KeyValuePair <int, string>(3, "c")
});
b.From(source).To(unzip.In);
b.From(unzip.Out0).Via(Flow.Create <int>().Select(x => x * 2)).To(zip.In0);
b.From(unzip.Out1).To(zip.In1);
b.From(zip.Out).To(sink);
return(ClosedShape.Instance);
})).Run(Materializer);
}
public void SplitWhen_must_support_cancelling_substreams()
{
this.AssertAllStagesStopped(() =>
{
WithSubstreamsSupport(5, 8, run: (masterSubscriber, masterSubscription, getSubFlow) =>
{
var s1 = new StreamPuppet(getSubFlow().RunWith(Sink.AsPublisher <int>(false), Materializer), this);
s1.Cancel();
var s2 = new StreamPuppet(getSubFlow().RunWith(Sink.AsPublisher <int>(false), Materializer), this);
s2.Request(4);
s2.ExpectNext(5);
s2.ExpectNext(6);
s2.ExpectNext(7);
s2.ExpectNext(8);
s2.Request(1);
s2.ExpectComplete();
masterSubscription.Request(1);
masterSubscriber.ExpectComplete();
});
}, Materializer);
}
private void WithSubstreamsSupport(int groupCount = 2, int elementCount = 6, int maxSubstream = -1,
Action <TestSubscriber.ManualProbe <Tuple <int, Source <int, NotUsed> > >, ISubscription, Func <int, Source <int, NotUsed> > > run = null)
{
var source = Source.From(Enumerable.Range(1, elementCount)).RunWith(Sink.AsPublisher <int>(false), Materializer);
var max = maxSubstream > 0 ? maxSubstream : groupCount;
var groupStream =
Source.FromPublisher(source)
.GroupBy(max, x => x % groupCount)
.Lift(x => x % groupCount)
.RunWith(Sink.AsPublisher <Tuple <int, Source <int, NotUsed> > >(false), Materializer);
var masterSubscriber = TestSubscriber.CreateManualProbe <Tuple <int, Source <int, NotUsed> > >(this);
groupStream.Subscribe(masterSubscriber);
var masterSubscription = masterSubscriber.ExpectSubscription();
run?.Invoke(masterSubscriber, masterSubscription, expectedKey =>
{
masterSubscription.Request(1);
var tuple = masterSubscriber.ExpectNext();
tuple.Item1.Should().Be(expectedKey);
return(tuple.Item2);
});
}
public void Select_should_not_blow_up_with_high_request_counts()
{
var probe = this.CreateManualSubscriberProbe <int>();
Source.From(new [] { 1 })
.Select(x => x + 1)
.Select(x => x + 1)
.Select(x => x + 1)
.Select(x => x + 1)
.Select(x => x + 1)
.RunWith(Sink.AsPublisher <int>(false), _materializer)
.Subscribe(probe);
var subscription = probe.ExpectSubscription();
for (int i = 1; i <= 10000; i++)
{
subscription.Request(int.MaxValue);
}
probe.ExpectNext(6);
probe.ExpectComplete();
}
public void GroupBy_must_support_cancelling_substreams()
{
this.AssertAllStagesStopped(() =>
{
WithSubstreamsSupport(2, run: (masterSubscriber, masterSubscription, getSubFlow) =>
{
new StreamPuppet(getSubFlow(1).RunWith(Sink.AsPublisher <int>(false), Materializer), this).Cancel();
var substream = new StreamPuppet(getSubFlow(0).RunWith(Sink.AsPublisher <int>(false), Materializer), this);
substream.Request(2);
substream.ExpectNext(2);
substream.ExpectNext(4);
substream.ExpectNoMsg(TimeSpan.FromMilliseconds(100));
substream.Request(2);
substream.ExpectNext(6);
substream.ExpectComplete();
masterSubscription.Request(1);
masterSubscriber.ExpectComplete();
});
}, Materializer);
}
public void SplitAfter_must_work_when_first_element_is_split_by()
{
this.AssertAllStagesStopped(() =>
{
WithSubstreamsSupport(1, 3, run: (masterSubscriber, masterSubscription, expectSubFlow) =>
{
var s1 = new StreamPuppet(expectSubFlow().RunWith(Sink.AsPublisher <int>(false), Materializer), this);
masterSubscriber.ExpectNoMsg(TimeSpan.FromMilliseconds(100));
s1.Request(3);
s1.ExpectNext(1);
s1.ExpectComplete();
var s2 = new StreamPuppet(expectSubFlow().RunWith(Sink.AsPublisher <int>(false), Materializer), this);
s2.Request(3);
s2.ExpectNext(2);
s2.ExpectNext(3);
s2.ExpectComplete();
masterSubscription.Request(1);
masterSubscriber.ExpectComplete();
});
}, Materializer);
}
public void FlowGraphs_when_used_together_should_allow_connecting_source_to_sink_directly()
{
var probe = TestSubscriber.CreateManualProbe <int>(this);
var inSource = Source.AsSubscriber <int>();
var outSink = Sink.AsPublisher <int>(false);
var source = Source.FromGraph(GraphDsl.Create(inSource, (b, src) => new SourceShape <int>(src.Outlet)));
var sink = Sink.FromGraph(GraphDsl.Create(outSink, (b, s) => new SinkShape <int>(s.Inlet)));
var t = RunnableGraph.FromGraph(GraphDsl.Create(source, sink, Keep.Both, (b, src, snk) =>
{
b.From(src.Outlet).To(snk.Inlet);
return(ClosedShape.Instance);
})).Run(Materializer);
var subscriber = t.Item1;
var publisher = t.Item2;
Source1.RunWith(Sink.AsPublisher <int>(false), Materializer).Subscribe(subscriber);
publisher.Subscribe(probe);
ValidateProbe(probe, 4, new[] { 0, 1, 2, 3 });
}
public void A_Flow_based_on_an_iterable_must_produce_OnError_when_iterator_throws()
{
var iterable = Enumerable.Range(1, 3).Select(x =>
{
if (x == 2)
{
throw new IllegalStateException("not two");
}
return(x);
});
var p = Source.From(iterable).RunWith(Sink.AsPublisher <int>(false), Materializer);
var c = this.CreateManualSubscriberProbe <int>();
p.Subscribe(c);
var sub = c.ExpectSubscription();
sub.Request(1);
c.ExpectNext(1);
c.ExpectNoMsg(TimeSpan.FromMilliseconds(100));
EventFilter.Exception <IllegalStateException>("not two").ExpectOne(() => sub.Request(2));
c.ExpectError().Message.Should().Be("not two");
sub.Request(2);
c.ExpectNoMsg(TimeSpan.FromMilliseconds(100));
}
public void A_Flow_must_be_materializable_several_times_with_fanout_publisher()
{
this.AssertAllStagesStopped(() =>
{
var flow = Source.From(new[] { 1, 2, 3 }).Select(i => i.ToString());
var p1 = flow.RunWith(Sink.AsPublisher <string>(true), Materializer);
var p2 = flow.RunWith(Sink.AsPublisher <string>(true), Materializer);
var s1 = this.CreateManualSubscriberProbe <string>();
var s2 = this.CreateManualSubscriberProbe <string>();
var s3 = this.CreateManualSubscriberProbe <string>();
p1.Subscribe(s1);
p2.Subscribe(s2);
p2.Subscribe(s3);
var sub1 = s1.ExpectSubscription();
var sub2 = s2.ExpectSubscription();
var sub3 = s3.ExpectSubscription();
sub1.Request(3);
s1.ExpectNext("1");
s1.ExpectNext("2");
s1.ExpectNext("3");
s1.ExpectComplete();
sub2.Request(3);
sub3.Request(3);
s2.ExpectNext("1");
s2.ExpectNext("2");
s2.ExpectNext("3");
s2.ExpectComplete();
s3.ExpectNext("1");
s3.ExpectNext("2");
s3.ExpectNext("3");
s3.ExpectComplete();
}, Materializer);
}
protected static IPublisher <TOut> ToPublisher <TOut>(Source <TOut, NotUsed> source, IMaterializer materializer)
{
return(source.RunWith(Sink.AsPublisher <TOut>(false), materializer));
}
public override IPublisher <int> CreatePublisher(long elements) => Source.Single(1).RunWith(Sink.AsPublisher <int>(false), Materializer);
private static IPublisher <TOut> ToFanoutPublisher <TOut, TMat>(Source <TOut, TMat> source,
ActorMaterializer materializer, int elasticity)
=>
source.RunWith(
Sink.AsPublisher <TOut>(true).WithAttributes(Attributes.CreateInputBuffer(elasticity, elasticity)),
materializer);
public void Flow_should_append_Sink()
{
var open = Flow.Create <int>().Select(x => x.ToString());
var closedSink = Flow.Create <string>().Select(x => x.GetHashCode()).To(Sink.AsPublisher <int>(false));
dynamic appended = open.To(closedSink);
Action compiler = () => appended.Run(Materializer);
compiler.ShouldThrow <RuntimeBinderException>();
compiler = () => appended.To(Sink.First <int>());
compiler.ShouldThrow <RuntimeBinderException>();
IntSeq.To(appended).Run(Materializer);
}
public void Source_should_accept_Sink() => OpenSource.To(Sink.AsPublisher <string>(false));
public override IPublisher <ByteString> CreatePublisher(long elements) => FileIO.FromFile(_file, 512) .Take(elements) .RunWith(Sink.AsPublisher <ByteString>(false), Materializer);
protected IPublisher <T> NonEmptyPublisher <T>(IEnumerable <T> elements)
{
return(Source.From(elements).RunWith(Sink.AsPublisher <T>(false), Materializer));
}
public override IPublisher <int> CreatePublisher(long elements) => Source.From(Enumerate(elements == 0, elements)).RunWith(Sink.AsPublisher <int>(true), Materializer);
private static IPublisher <TOut> ToPublisher <TOut, TMat>(Source <TOut, TMat> source,
ActorMaterializer materializer) => source.RunWith(Sink.AsPublisher <TOut>(false), materializer);
private static Tuple <ISubscriber <TIn>, IPublisher <TOut> > MaterializeIntoSubscriberAndPublisher <TIn, TOut, TMat>(
Flow <TIn, TOut, TMat> flow, ActorMaterializer materializer)
=> flow.RunWith(Source.AsSubscriber <TIn>(), Sink.AsPublisher <TOut>(false), materializer);
public override IPublisher <int> CreatePublisher(long elements) => Source.From(Enumerate(elements / 2)) .Concat(Source.From(Enumerate((elements + 1) / 2))) .RunWith(Sink.AsPublisher <int>(false), Materializer);