public void ActorSubscriberSpec_should_should_work_with_WatermarkRequestStrategy()
{
Source.From(Enumerable.Range(1, 17))
.RunWith(Sink.ActorSubscriber <int>(RequestStrategySubscriber.Props(TestActor, new WatermarkRequestStrategy(highWatermark: 10))), Sys.Materializer());
Enumerable.Range(1, 17).ForEach(n => ExpectMsg <OnNext>().Element.Should().Be(n));
ExpectMsg <OnComplete>();
}
public void ActorSubscriberSpec_should_support_custom_max_in_flight_request_strategy_with_child_workers()
{
var n = 117;
Source.From(Enumerable.Range(1, n))
.Select(i => new Msg(i, TestActor))
.RunWith(Sink.ActorSubscriber <Msg>(Streamer.Props), Sys.Materializer());
ReceiveN(n).ShouldAllBeEquivalentTo(Enumerable.Range(1, n).Select(i => new Done(i)));
}
public void ActorSubscriberSpec_should_terminate_after_cancel()
{
var actorRef = Source.From(Enumerable.Range(1, 5))
.RunWith(Sink.ActorSubscriber <int>(ManualSubscriber.Props(TestActor)), Sys.Materializer());
Watch(actorRef);
actorRef.Tell("requestAndCancel");
ExpectTerminated(actorRef);
}
public void ActorSubscriber_should_signal_error()
{
var e = new Exception("simulated");
var actorRef = Source.FromEnumerator <int>(() => { throw e; })
.RunWith(Sink.ActorSubscriber <int>(ManualSubscriber.Props(TestActor)), Sys.Materializer());
actorRef.Tell("ready");
ExpectMsg <OnError>().Cause.Should().Be(e);
}
public void ActorSubscriberSpec_should_not_deliver_more_after_cancel()
{
var actorRef = Source.From(Enumerable.Range(1, 5))
.RunWith(Sink.ActorSubscriber <int>(ManualSubscriber.Props(TestActor)), Sys.Materializer());
actorRef.Tell("ready");
ExpectMsg <OnNext>().Element.Should().Be(1);
ExpectMsg <OnNext>().Element.Should().Be(2);
actorRef.Tell("requestAndCancel");
ExpectNoMsg(200);
}
public void ActorPublisher_should_work_in_a_GraphDsl()
{
var materializer = Sys.Materializer();
var probe1 = CreateTestProbe();
var probe2 = CreateTestProbe();
var senderRef1 = ActorOf(Sender.Props);
var source1 = Source.FromPublisher(ActorPublisher.Create <int>(senderRef1))
.MapMaterializedValue(_ => senderRef1);
var sink1 = Sink.FromSubscriber(ActorSubscriber.Create <string>(ActorOf(Receiver.Props(probe1.Ref))))
.MapMaterializedValue(_ => probe1.Ref);
var sink2 = Sink.ActorSubscriber <string>(Receiver.Props(probe2.Ref))
.MapMaterializedValue(_ => probe2.Ref);
var senderRef2 = RunnableGraph.FromGraph(GraphDsl.Create(
Source.ActorPublisher <int>(Sender.Props),
(builder, source2) =>
{
var merge = builder.Add(new Merge <int, int>(2));
var bcast = builder.Add(new Broadcast <string>(2));
builder.From(source1).To(merge.In(0));
builder.From(source2.Outlet).To(merge.In(1));
builder.From(merge.Out).Via(Flow.Create <int>().Select(i => i.ToString())).To(bcast.In);
builder.From(bcast.Out(0)).Via(Flow.Create <string>().Select(s => s + "mark")).To(sink1);
builder.From(bcast.Out(1)).To(sink2);
return(ClosedShape.Instance);
})).Run(materializer);
// the scala test is wrong
const int noOfMessages = 10;
for (var i = 0; i < noOfMessages; i++)
{
senderRef1.Tell(i);
senderRef2.Tell(i + noOfMessages);
}
var probe1Messages = new List <string>(noOfMessages * 2);
var probe2Messages = new List <string>(noOfMessages * 2);
for (var i = 0; i < noOfMessages * 2; i++)
{
probe1Messages.Add(probe1.ExpectMsg <string>());
probe2Messages.Add(probe2.ExpectMsg <string>());
}
probe1Messages.Should().BeEquivalentTo(Enumerable.Range(0, noOfMessages * 2).Select(i => i + "mark"));
probe2Messages.Should().BeEquivalentTo(Enumerable.Range(0, noOfMessages * 2).Select(i => i.ToString()));
}
public void ActorSubscriber_should_receive_requested_elements()
{
var actorRef = Source.From(new[] { 1, 2, 3 })
.RunWith(Sink.ActorSubscriber <int>(ManualSubscriber.Props(TestActor)), Sys.Materializer());
ExpectNoMsg(200);
actorRef.Tell("ready"); //requesting 2
ExpectMsg <OnNext>().Element.Should().Be(1);
ExpectMsg <OnNext>().Element.Should().Be(2);
ExpectNoMsg(200);
actorRef.Tell("ready");
ExpectMsg <OnNext>().Element.Should().Be(3);
ExpectMsg <OnComplete>();
}
public void ActorPublisher_should_work_together_with_Flow_and_ActorSubscriber_using_old_Collect_behaviour()
{
var materializer = Sys.Materializer();
this.AssertAllStagesStopped(() =>
{
var probe = CreateTestProbe();
var source = Source.ActorPublisher <int>(Sender.Props);
var sink = Sink.ActorSubscriber <string>(Receiver.Props(probe.Ref));
var t = source.Collect(n =>
{
if (n % 2 == 0)
{
return("elem-" + n);
}
return(null);
}).ToMaterialized(sink, Keep.Both).Run(materializer);
var snd = t.Item1;
var rcv = t.Item2;
for (var i = 1; i <= 3; i++)
{
snd.Tell(i);
}
probe.ExpectMsg("elem-2", TimeSpan.FromMinutes(10));
for (var n = 4; n <= 500; n++)
{
if (n % 19 == 0)
{
Thread.Sleep(50); // simulate bursts
}
snd.Tell(n);
}
for (var n = 4; n <= 500; n += 2)
{
probe.ExpectMsg("elem-" + n);
}
Watch(snd);
rcv.Tell(PoisonPill.Instance);
ExpectTerminated(snd);
}, materializer);
}
