public override IPublisher <int?> CreatePublisher(long elements)
{
var actorRef =
System.ActorOf(Props.Create(() => new TestPublisher(elements)).WithDispatcher("akka.test.stream-dispatcher"));
return(ActorPublisher.Create <int?>(actorRef));
}
public void ActorPublisher_should_signal_error()
{
var probe = CreateTestProbe();
var actorRef = Sys.ActorOf(TestPublisher.Props(probe.Ref));
var s = this.CreateManualProbe <string>();
ActorPublisher.Create <string>(actorRef).Subscribe(s);
actorRef.Tell(new Err("wrong"));
s.ExpectSubscription();
s.ExpectError().Message.Should().Be("wrong");
}
public void ActorPublisher_should_signal_immediate_onComplete()
{
var probe = CreateTestProbe();
var actorRef = Sys.ActorOf(TestPublisher.Props(probe.Ref));
actorRef.Tell(Complete.Instance);
var s = this.CreateManualProbe <string>();
ActorPublisher.Create <string>(actorRef).Subscribe(s);
s.ExpectSubscriptionAndComplete();
}
public void ActorPublisher_should_signal_onComplete_when_actor_is_stopped()
{
var probe = CreateTestProbe();
var actorRef = Sys.ActorOf(TestPublisher.Props(probe.Ref));
var s = this.CreateManualProbe <string>();
ActorPublisher.Create <string>(actorRef).Subscribe(s);
s.ExpectSubscription();
actorRef.Tell(PoisonPill.Instance);
s.ExpectComplete();
}
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 ActorPublisher_should_be_able_to_define_a_subscription_timeout_which_is_cancelled_by_the_first_incoming_Subscriber()
{
var timeout = TimeSpan.FromMilliseconds(500);
var sub = this.CreateManualProbe <int>();
var pub = ActorPublisher.Create <int>(ActorOf(TimeoutingPublisher.Props(TestActor, timeout)));
// subscribe right away, should cancel subscription-timeout
pub.Subscribe(sub);
sub.ExpectSubscription();
ExpectNoMsg(TimeSpan.FromSeconds(1));
}
public void ActorPublisher_should_only_allow_one_subscriber()
{
var probe = CreateTestProbe();
var actorRef = Sys.ActorOf(TestPublisher.Props(probe.Ref));
var s = this.CreateManualProbe <string>();
ActorPublisher.Create <string>(actorRef).Subscribe(s);
s.ExpectSubscription();
var s2 = this.CreateManualProbe <string>();
ActorPublisher.Create <string>(actorRef).Subscribe(s2);
s2.ExpectSubscriptionAndError().Should().BeOfType <IllegalStateException>();
}
public void ActorPublisher_should_signal_onComplete()
{
var probe = CreateTestProbe();
var actorRef = Sys.ActorOf(TestPublisher.Props(probe.Ref));
var s = this.CreateProbe <string>();
ActorPublisher.Create <string>(actorRef).Subscribe(s);
s.Request(3);
actorRef.Tell(new Produce("elem-1"));
actorRef.Tell(Complete.Instance);
s.ExpectNext("elem-1");
s.ExpectComplete();
}
public void ActorPublisher_should_terminate_after_signalling_OnErrorThenStop()
{
var probe = CreateTestProbe();
var actorRef = Sys.ActorOf(TestPublisher.Props(probe.Ref));
var s = this.CreateManualProbe <string>();
ActorPublisher.Create <string>(actorRef).Subscribe(s);
s.ExpectSubscription();
probe.Watch(actorRef);
actorRef.Tell(new ErrThenStop("wrong"));
s.ExpectError().Message.Should().Be("wrong");
probe.ExpectTerminated(actorRef, TimeSpan.FromSeconds(3));
}
public void ActorPublisher_should_not_terminate_after_signaling_onError()
{
var probe = CreateTestProbe();
var actorRef = Sys.ActorOf(TestPublisher.Props(probe.Ref));
var s = this.CreateManualSubscriberProbe <string>();
ActorPublisher.Create <string>(actorRef).Subscribe(s);
s.ExpectSubscription();
probe.Watch(actorRef);
actorRef.Tell(new Err("wrong"));
s.ExpectError().Message.Should().Be("wrong");
probe.ExpectNoMsg(TimeSpan.FromMilliseconds(200));
}
public void ActorPublisher_should_accumulate_demand()
{
var probe = CreateTestProbe();
var actorRef = Sys.ActorOf(TestPublisher.Props(probe.Ref));
var p = ActorPublisher.Create <string>(actorRef);
var s = this.CreateProbe <string>();
p.Subscribe(s);
s.Request(2);
probe.ExpectMsg <TotalDemand>().Elements.Should().Be(2);
s.Request(3);
probe.ExpectMsg <TotalDemand>().Elements.Should().Be(5);
s.Cancel();
}
public void ActorPublisher_should_drop_onNext_elements_after_cancel()
{
var probe = CreateTestProbe();
var actorRef = Sys.ActorOf(TestPublisher.Props(probe.Ref));
var p = ActorPublisher.Create <string>(actorRef);
var s = this.CreateProbe <string>();
p.Subscribe(s);
s.Request(2);
actorRef.Tell(new Produce("elem-1"));
s.Cancel();
actorRef.Tell(new Produce("elem-2"));
s.ExpectNext("elem-1");
s.ExpectNoMsg(TimeSpan.FromMilliseconds(300));
}
public void ActorPublisher_should_terminate_after_signalling_onCompleteThenStop()
{
var probe = CreateTestProbe();
var actorRef = Sys.ActorOf(TestPublisher.Props(probe.Ref));
var s = this.CreateProbe <string>();
ActorPublisher.Create <string>(actorRef).Subscribe(s);
var sub = s.ExpectSubscription();
sub.Request(3);
probe.ExpectMsg <TotalDemand>().Elements.Should().Be(3);
probe.Watch(actorRef);
actorRef.Tell(new Produce("elem-1"));
actorRef.Tell(CompleteThenStop.Instance);
s.ExpectNext("elem-1");
s.ExpectComplete();
probe.ExpectTerminated(actorRef, TimeSpan.FromSeconds(3));
}
public void ActorPublisher_should_remember_requested_after_restart()
{
var probe = CreateTestProbe();
var actorRef = Sys.ActorOf(TestPublisher.Props(probe.Ref));
var p = ActorPublisher.Create <string>(actorRef);
var s = this.CreateProbe <string>();
p.Subscribe(s);
s.Request(3);
probe.ExpectMsg <TotalDemand>().Elements.Should().Be(3);
actorRef.Tell(new Produce("elem-1"));
actorRef.Tell(Boom.Instance);
actorRef.Tell(new Produce("elem-2"));
s.ExpectNext("elem-1");
s.ExpectNext("elem-2");
s.Request(5);
probe.ExpectMsg <TotalDemand>().Elements.Should().Be(6);
s.Cancel();
}
public void ActorPublisher_should_be_able_to_define_a_subscription_timeout_after_which_it_should_shut_down()
{
var materializer = Sys.Materializer();
this.AssertAllStagesStopped(() =>
{
var timeout = TimeSpan.FromMilliseconds(150);
var a = ActorOf(TimeoutingPublisher.Props(TestActor, timeout));
var pub = ActorPublisher.Create <int>(a);
// don't subscribe for `timeout` millis, so it will shut itself down
ExpectMsg("timed-out");
// now subscribers will already be rejected, while the actor could perform some clean-up
var sub = this.CreateManualProbe <int>();
pub.Subscribe(sub);
sub.ExpectSubscriptionAndError();
ExpectMsg("cleaned-up");
// termination is tiggered by user code
Watch(a);
ExpectTerminated(a);
}, materializer);
}