public void CreateTestHandlerFor_WhenCalled_CreatesTestHandlerAndAddsItsToPublisher()
{
var publisher = new TestPublisher();
var handler = publisher.RegisterTestHandler<FooMessage>();
Assert.That(handler, Is.InstanceOf<TestHandler<FooMessage>>());
Assert.That(publisher.GetHandlerSource().ResolveHandlersFor<FooMessage>().First(), Is.SameAs(handler));
}
public void Creates_test_handler_and_adds_it_to_publisher()
{
var publisher = new TestPublisher();
var handler = publisher.RegisterTestHandler<TestMessage>();
Assert.That(handler, Is.InstanceOf<TestHandler<TestMessage>>());
Assert.That(((IHandlerSource)publisher.GetAssignee()).ResolveHandlersFor(typeof(TestMessage)).First(), Is.SameAs(handler));
}
public void A_Delay_must_deliver_elements_with_delay_for_slow_stream()
{
this.AssertAllStagesStopped(() =>
{
var c = TestSubscriber.CreateManualProbe <int>(this);
var p = TestPublisher.CreateManualProbe <int>(this);
Source.FromPublisher(p)
.Delay(TimeSpan.FromMilliseconds(300))
.To(Sink.FromSubscriber(c))
.Run(Materializer);
var cSub = c.ExpectSubscription();
var pSub = p.ExpectSubscription();
cSub.Request(100);
pSub.SendNext(1);
c.ExpectNoMsg(TimeSpan.FromMilliseconds(200));
c.ExpectNext(1);
pSub.SendNext(2);
c.ExpectNoMsg(TimeSpan.FromMilliseconds(200));
c.ExpectNext(2);
pSub.SendComplete();
c.ExpectComplete();
}, Materializer);
}
public void A_Delay_must_emit_early_when_buffer_is_full_and_in_EmitEarly_mode()
{
this.AssertAllStagesStopped(() =>
{
var c = TestSubscriber.CreateManualProbe <int>(this);
var p = TestPublisher.CreateManualProbe <int>(this);
Source.FromPublisher(p)
.Delay(TimeSpan.FromSeconds(10), DelayOverflowStrategy.EmitEarly)
.WithAttributes(Attributes.CreateInputBuffer(16, 16))
.To(Sink.FromSubscriber(c))
.Run(Materializer);
var cSub = c.ExpectSubscription();
var pSub = p.ExpectSubscription();
cSub.Request(20);
Enumerable.Range(1, 16).ForEach(i => pSub.SendNext(i));
c.ExpectNoMsg(TimeSpan.FromMilliseconds(300));
pSub.SendNext(17);
c.ExpectNext(1, TimeSpan.FromMilliseconds(100));
// fail will terminate despite of non empty internal buffer
pSub.SendError(new SystemException());
}, Materializer);
}
public void Throttle_for_single_cost_elements_must_emit_single_element_per_tick()
{
this.AssertAllStagesStopped(() =>
{
var upstream = TestPublisher.CreateProbe <int>(this);
var downstream = TestSubscriber.CreateProbe <int>(this);
Source.FromPublisher(upstream)
.Throttle(1, TimeSpan.FromMilliseconds(300), 0, ThrottleMode.Shaping)
.RunWith(Sink.FromSubscriber(downstream), Materializer);
downstream.Request(2);
upstream.SendNext(1);
downstream.ExpectNoMsg(TimeSpan.FromMilliseconds(150));
downstream.ExpectNext(1);
upstream.SendNext(2);
downstream.ExpectNoMsg(TimeSpan.FromMilliseconds(150));
downstream.ExpectNext(2);
upstream.SendComplete();
downstream.ExpectComplete();
}, Materializer);
}
public void Conflate_must_restart_when_aggregate_throws_and_a_RestartingDecider_is_used()
{
var sourceProbe = TestPublisher.CreateProbe <string>(this);
var sinkProbe = TestSubscriber.CreateProbe <string>(this);
var latch = new TestLatch();
var conflate = Flow.Create <string>().ConflateWithSeed(i => i, (state, elem) =>
{
if (elem == "two")
{
latch.Open();
throw new TestException("two is a three letter word");
}
return(state + elem);
}).WithAttributes(ActorAttributes.CreateSupervisionStrategy(Deciders.RestartingDecider));
var graph = Source.FromPublisher(sourceProbe)
.Via(conflate)
.To(Sink.FromSubscriber(sinkProbe))
.WithAttributes(Attributes.CreateInputBuffer(4, 4));
RunnableGraph.FromGraph(graph).Run(Materializer);
var sub = sourceProbe.ExpectSubscription();
sub.ExpectRequest(4);
sub.SendNext("one");
sub.SendNext("two");
sub.SendNext("three");
sub.SendComplete();
//"one" should be lost
latch.Ready(TimeSpan.FromSeconds(3));
sinkProbe.RequestNext("three");
}
public void Buffer_must_accept_elements_that_fit_in_the_buffer_while_downstream_is_silent()
{
var publisher = TestPublisher.CreateProbe <int>(this);
var subscriber = TestSubscriber.CreateManualProbe <int>(this);
Source.FromPublisher(publisher)
.Buffer(100, OverflowStrategy.Backpressure)
.To(Sink.FromSubscriber(subscriber))
.Run(Materializer);
var sub = subscriber.ExpectSubscription();
// Fill up buffer
Enumerable.Range(1, 100).ForEach(i => publisher.SendNext(i));
// drain
Enumerable.Range(1, 100).ForEach(i =>
{
sub.Request(1);
subscriber.ExpectNext(i);
});
sub.Cancel();
}
public void Batch_must_aggregate_elements_while_downstream_is_silent()
{
var publisher = TestPublisher.CreateProbe <int>(this);
var subscriber = TestSubscriber.CreateProbe <List <int> >(this);
Source.FromPublisher(publisher).Batch(long.MaxValue, i => new List <int> {
i
}, (ints, i) =>
{
ints.Add(i);
return(ints);
}).To(Sink.FromSubscriber(subscriber)).Run(Materializer);
var sub = subscriber.ExpectSubscription();
for (var i = 1; i <= 10; i++)
{
publisher.SendNext(i);
}
subscriber.ExpectNoMsg(TimeSpan.FromSeconds(1));
sub.Request(1);
subscriber.ExpectNext().ShouldAllBeEquivalentTo(new [] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 });
sub.Cancel();
}
public void A_Balance_must_cancel_upstream_when_downstream_cancel()
{
this.AssertAllStagesStopped(() =>
{
var p1 = TestPublisher.CreateManualProbe <int>(this);
var c1 = TestSubscriber.CreateManualProbe <int>(this);
var c2 = TestSubscriber.CreateManualProbe <int>(this);
RunnableGraph.FromGraph(GraphDsl.Create(b =>
{
var balance = b.Add(new Balance <int>(2));
var source = Source.FromPublisher(p1.Publisher);
b.From(source).To(balance.In);
b.From(balance.Out(0)).To(Sink.FromSubscriber(c1));
b.From(balance.Out(1)).To(Sink.FromSubscriber(c2));
return(ClosedShape.Instance);
})).Run(Materializer);
var bsub = p1.ExpectSubscription();
var sub1 = c1.ExpectSubscription();
var sub2 = c2.ExpectSubscription();
sub1.Request(1);
p1.ExpectRequest(bsub, 16);
bsub.SendNext(1);
c1.ExpectNext(1);
sub2.Request(1);
bsub.SendNext(2);
c2.ExpectNext(2);
sub1.Cancel();
sub2.Cancel();
bsub.ExpectCancellation();
}, Materializer);
}
public async Task RunAsync_CanFilterHealthChecks()
{
// Arrange
var publishers = new TestPublisher[]
{
new TestPublisher(),
new TestPublisher(),
};
var service = CreateService(publishers, configure: (options) =>
{
options.Predicate = (r) => r.Name == "one";
});
try
{
await service.StartAsync();
// Act
await service.RunAsync().TimeoutAfter(TimeSpan.FromSeconds(10));
// Assert
for (var i = 0; i < publishers.Length; i++)
{
var report = Assert.Single(publishers[i].Entries).report;
Assert.Equal(new[] { "one", }, report.Entries.Keys.OrderBy(k => k));
}
}
finally
{
await service.StopAsync();
Assert.False(service.IsTimerRunning);
Assert.True(service.IsStopping);
}
}
public async Task RunAsync_WaitsForCompletion_Single()
{
// Arrange
var sink = new TestSink();
var unblock = new TaskCompletionSource <object?>(TaskCreationOptions.RunContinuationsAsynchronously);
var publishers = new TestPublisher[]
{
new TestPublisher()
{
Wait = unblock.Task,
},
};
var service = CreateService(publishers, sink: sink);
try
{
await service.StartAsync();
// Act
var running = service.RunAsync();
await publishers[0].Started.TimeoutAfter(TimeSpan.FromSeconds(10));
unblock.SetResult(null);
await running.TimeoutAfter(TimeSpan.FromSeconds(10));
// Assert
Assert.True(service.IsTimerRunning);
Assert.False(service.IsStopping);
for (var i = 0; i < publishers.Length; i++)
{
var report = Assert.Single(publishers[i].Entries).report;
Assert.Equal(new[] { "one", "two", }, report.Entries.Keys.OrderBy(k => k));
}
}
finally
{
await service.StopAsync();
Assert.False(service.IsTimerRunning);
Assert.True(service.IsStopping);
}
Assert.Collection(
sink.Writes,
entry => { Assert.Equal(HealthCheckPublisherEventIds.HealthCheckPublisherProcessingBegin, entry.EventId); },
entry => { Assert.Equal(DefaultHealthCheckEventIds.HealthCheckProcessingBegin, entry.EventId); },
entry => { Assert.Equal(DefaultHealthCheckEventIds.HealthCheckBegin, entry.EventId); },
entry => { Assert.Contains(entry.EventId, new[] { DefaultHealthCheckEventIds.HealthCheckBegin, DefaultHealthCheckEventIds.HealthCheckEnd }); },
entry => { Assert.Contains(entry.EventId, new[] { DefaultHealthCheckEventIds.HealthCheckBegin, DefaultHealthCheckEventIds.HealthCheckEnd }); },
entry => { Assert.Equal(DefaultHealthCheckEventIds.HealthCheckEnd, entry.EventId); },
entry => { Assert.Equal(DefaultHealthCheckEventIds.HealthCheckProcessingEnd, entry.EventId); },
entry => { Assert.Equal(HealthCheckPublisherEventIds.HealthCheckPublisherBegin, entry.EventId); },
entry => { Assert.Equal(HealthCheckPublisherEventIds.HealthCheckPublisherEnd, entry.EventId); },
entry => { Assert.Equal(HealthCheckPublisherEventIds.HealthCheckPublisherProcessingEnd, entry.EventId); });
}
public void When_publishing_to_a_class()
{
var publisher = new TestPublisher();
Experiment
.On(() => true)
.Try(() => true)
.Publish(publisher)
.Run();
publisher.Results.Matched.ShouldBe(true);
}
public void FireNormal_Setup()
{
_publisher = new TestPublisher();
_normalSubscriber = new NormalSubscriber(_publisher);
}
public void FireWeak_Setup()
{
_publisher = new TestPublisher();
_subscriber = new TestSubscriber(_publisher);
}
public NormalSubscriber(TestPublisher publisher)
{
Publisher = publisher;
publisher.TheEvent += OnTheEvent;
}
protected IPublisher <T> SoonToCompletePublisher <T>()
{
return(TestPublisher.LazyEmpty <T>());
}
protected IPublisher <T> SoonToFailPublisher <T>()
{
return(TestPublisher.LazyError <T>(TestException()));
}
protected IPublisher <T> CompletedPublisher <T>()
{
return(TestPublisher.Empty <T>());
}
protected IPublisher <T> FailedPublisher <T>()
{
return(TestPublisher.Error <T>(TestException()));
}
public override IPublisher <T> CreateFailedPublisher()
=> TestPublisher.Error <T>(new Exception("Unable to serve subscribers right now!"));
public void SplitWhen_must_support_cancelling_both_master_and_substream()
{
this.AssertAllStagesStopped(() =>
{
var inputs = TestPublisher.CreateProbe <int>(this);
var substream = TestSubscriber.CreateProbe <int>(this);
var masterStream = TestSubscriber.CreateProbe <NotUsed>(this);
Source.FromPublisher(inputs)
.SplitWhen(x => x == 2)
.Lift()
.Select(x => x.RunWith(Sink.FromSubscriber(substream), Materializer))
.RunWith(Sink.FromSubscriber(masterStream), Materializer);
masterStream.Request(1);
inputs.SendNext(1);
substream.Cancel();
masterStream.ExpectNext(NotUsed.Instance);
masterStream.ExpectNoMsg(TimeSpan.FromMilliseconds(100));
masterStream.Cancel();
inputs.ExpectCancellation();
var inputs2 = TestPublisher.CreateProbe <int>(this);
Source.FromPublisher(inputs2)
.SplitWhen(x => x == 2)
.Lift()
.Select(x => x.RunWith(Sink.Cancelled <int>(), Materializer))
.RunWith(Sink.Cancelled <NotUsed>(), Materializer);
inputs2.ExpectCancellation();
var inputs3 = TestPublisher.CreateProbe <int>(this);
var masterStream3 = TestSubscriber.CreateProbe <Source <int, NotUsed> >(this);
Source.FromPublisher(inputs3)
.SplitWhen(x => x == 2)
.Lift()
.RunWith(Sink.FromSubscriber(masterStream3), Materializer);
masterStream3.Request(1);
inputs3.SendNext(1);
var src = masterStream3.ExpectNext();
src.RunWith(Sink.Cancelled <int>(), Materializer);
masterStream3.Request(1);
inputs3.SendNext(2);
var src2 = masterStream3.ExpectNext();
var substream4 = TestSubscriber.CreateProbe <int>(this);
src2.RunWith(Sink.FromSubscriber(substream4), Materializer);
substream4.RequestNext(2);
substream4.ExpectNoMsg(TimeSpan.FromMilliseconds(100));
masterStream3.ExpectNoMsg(TimeSpan.FromMilliseconds(100));
inputs3.ExpectRequest();
inputs3.ExpectRequest();
inputs3.ExpectNoMsg(TimeSpan.FromMilliseconds(100));
substream4.Cancel();
inputs3.ExpectNoMsg(TimeSpan.FromMilliseconds(100));
masterStream3.ExpectNoMsg(TimeSpan.FromMilliseconds(100));
masterStream3.Cancel();
inputs3.ExpectCancellation();
}, Materializer);
}
public async Task PublishAsyncSendsAMessageThatMatchesTheCommand()
{
using (var messageBody = new MemoryStream())
{
var message = default(BrokeredMessage);
var configuration = new ServiceBusQueueCommandPublisherConfiguration <ProcessOrder>();
Func <BrokeredMessage, Instant?, Task> sendMessage = (msg, time) =>
{
msg.GetBody <Stream>().CopyTo(messageBody);
messageBody.Seek(0, SeekOrigin.Begin);
message = msg.Clone();
return(Task.CompletedTask);
};
var command = new ProcessOrder
{
OrderId = "ABC123",
PartnerCode = "SQUIRE",
Assets = new Dictionary <string, string> {
{ "one", "val1" }, { "two", "val2" }
},
Emulation = null,
Id = Guid.NewGuid(),
CorrelationId = Guid.NewGuid().ToString(),
OccurredTimeUtc = new DateTime(2017, 01, 05, 5, 10, 30, DateTimeKind.Utc),
CurrentUser = null,
Sequence = 65
};
var testPublisher = new TestPublisher <ProcessOrder>(Mock.Of <ILogger>(), configuration, sendMessage);
await testPublisher.PublishAsync(command);
message.CorrelationId.Should().Be(command.CorrelationId, "because the correlation id should have been copied to the message");
message.MessageId.Should().Be(command.Id.ToString(), "because the command id should have been copied to the message");
message.ContentType.Should().Be(MimeTypes.Json, "becaue the message should have the correct type");
var serializer = new JsonSerializer {
ContractResolver = new CamelCasePropertyNamesContractResolver()
};
serializer.Converters.Add(new StringEnumConverter());
var messageCommand = default(ProcessOrder);
using (var reader = new StreamReader(messageBody))
using (var jsonReader = new JsonTextReader(reader))
{
messageCommand = serializer.Deserialize <ProcessOrder>(jsonReader);
reader.Close();
jsonReader.Close();
}
messageCommand.ShouldBeEquivalentTo(command, "because the commands should match");
messageBody?.Close();
message?.Dispose();
}
}
public void SetUp()
{
_publisher = new TestPublisher();
_handler = _publisher.RegisterTestHandler <DeploymentTaskCompletedEvent>();
}
