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>(); }