public void VerifyPublishedMessageWithRabbitMq()
{
const int waitSeconds = 60;
var subscriber = new TestSubscriber();
//Attach our test subscriber to the bus.
var unsubscribe = _testRabbitMqBus.SubscribeConsumer(() => subscriber);
Publisher.Publisher.Publish();
var second = 0;
//Crappy Polling...
while (second < waitSeconds)
{
if (subscriber.MessageRecieved)
{
break;
}
Thread.Sleep(1000);
second++;
}
unsubscribe.Invoke();
Assert.IsTrue(subscriber.MessageRecieved);
Assert.IsNotNull(subscriber.TheMessage);
// TODO: Some other validation
Assert.IsNotNull(subscriber.TheMessage.Message.StartsWith("hello"));
}
public void VerifyPublishedMessageWithLoopback()
{
const int waitSeconds = 60;
var subscriber = new TestSubscriber();
using (ShimsContext.Create())
{
// Replace the bus instance with our loopback version
Publisher.Fakes.ShimBusDepot.BusGet =
() => _testLoopbackBus;
// Subscribe our instance of the TestSubscriber
BusDepot.Bus.SubscribeConsumer(() => subscriber);
Publisher.Publisher.Publish();
var second = 0;
//Crappy polling...
while (second < waitSeconds)
{
if (subscriber.MessageRecieved)
{
break;
}
Thread.Sleep(1000);
second++;
}
Assert.IsTrue(subscriber.MessageRecieved);
Assert.IsNotNull(subscriber.TheMessage);
// TODO: Some other validation
Assert.IsNotNull(subscriber.TheMessage.Message.StartsWith("hello"));
}
}
private static void ValidateProbe(TestSubscriber.ManualProbe<int> probe, int requests, IEnumerable<int> result)
{
var subscription = probe.ExpectSubscription();
var collected = Enumerable.Range(1, requests).Select(_ =>
{
subscription.Request(1);
return probe.ExpectNext();
});
collected.ShouldAllBeEquivalentTo(result);
probe.ExpectComplete();
}
public void WhenSubscriptionIsDisposed_ThenDoesNotNotifySubscriber()
{
var foo = new Foo();
var manager = new PropertyChangeManager(foo);
var subscriber = new TestSubscriber("Name", 1);
var subscription = manager.SubscribeChanged((Expression<Func<Foo, object>>)(x => x.Name), (Action<Foo>)(subscriber.SubscriptionHandler));
manager.NotifyChanged<Foo>(x => x.Name);
Assert.Equal(1, subscriber.ActualCalls);
subscription.Dispose();
GC.Collect();
manager.NotifyChanged<Foo>(x => x.Name);
}
public void Expand_musst_pass_through_elements_unchanged_when_there_is_no_rate_differenc()
{
// Shadow the fuzzed materializer (see the ordering guarantee needed by the for loop below).
var materializer = ActorMaterializer.Create(Sys, Settings.WithFuzzingMode(false));
var publisher = TestPublisher.CreateProbe <int>(this);
var subscriber = TestSubscriber.CreateProbe <int>(this);
// Simply repeat the last element as an extrapolation step
Source.FromPublisher(publisher)
.Expand(i => Enumerable.Repeat(i, 200).GetEnumerator())
.To(Sink.FromSubscriber(subscriber))
.Run(materializer);
for (var i = 1; i <= 100; i++)
{
// Order is important here: If the request comes first it will be extrapolated!
publisher.SendNext(i);
subscriber.RequestNext(i);
}
subscriber.Cancel();
}
public async Task It_Gets_And_Observes_IsExecuting()
{
var receivedValues = new List <bool>();
var strategy = new TestCommandStrategy();
var command = new DynamicCommand(DefaultCommandName, strategy);
var testSubscriber = new TestSubscriber <bool>(onNext: t => receivedValues.Add(t));
var subscription = command
.GetAndObserveIsExecuting()
.Subscribe(testSubscriber);
using (subscription)
{
await command.Execute();
receivedValues.Count().Should().Be(3);
receivedValues[0].Should().BeFalse();
receivedValues[1].Should().BeTrue();
receivedValues[2].Should().BeFalse();
}
}
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 = TestSubscriber.CreateManualProbe <string>(this);
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 Throttle_for_single_cost_elements_must_not_send_downstream_if_upstream_does_not_emit_element()
{
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.ExpectNext(1);
downstream.ExpectNoMsg(TimeSpan.FromMilliseconds(300));
upstream.SendNext(2);
downstream.ExpectNext(2);
upstream.SendComplete();
downstream.ExpectComplete();
}, Materializer);
}
public void Expand_musst_do_not_drop_last_element()
{
var publisher = TestPublisher.CreateProbe <int>(this);
var subscriber = TestSubscriber.CreateProbe <int>(this);
// Simply repeat the last element as an extrapolation step
Source.FromPublisher(publisher)
.Expand(i => Enumerable.Repeat(i, 200).GetEnumerator())
.To(Sink.FromSubscriber(subscriber))
.Run(Materializer);
publisher.SendNext(1);
subscriber.RequestNext(1);
publisher.SendNext(2);
publisher.SendComplete();
// The request below is otherwise in race with the above sendNext(2) (and completion)
subscriber.ExpectNoMsg(TimeSpan.FromMilliseconds(500));
subscriber.RequestNext(2);
subscriber.ExpectComplete();
}
public void An_Interleave_for_Flow_must_pass_along_early_cancellation()
{
this.AssertAllStagesStopped(() =>
{
var up1 = TestPublisher.CreateManualProbe <int>(this);
var up2 = TestPublisher.CreateManualProbe <int>(this);
var down = TestSubscriber.CreateManualProbe <int>(this);
var t = Source.AsSubscriber <int>()
.InterleaveMaterialized(Source.AsSubscriber <int>(), 2, Tuple.Create)
.ToMaterialized(Sink.FromSubscriber(down), Keep.Left)
.Run(Materializer);
var graphSubscriber1 = t.Item1;
var graphSubscriber2 = t.Item2;
var downstream = down.ExpectSubscription();
downstream.Cancel();
up1.Subscribe(graphSubscriber1);
up2.Subscribe(graphSubscriber2);
up1.ExpectSubscription().ExpectCancellation();
up2.ExpectSubscription().ExpectCancellation();
}, Materializer);
}
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 = TestSubscriber.CreateManualProbe <object>(this);
neverPub.Subscribe(c);
var subs = c.ExpectSubscription();
subs.Request(1000);
c.ExpectNoMsg(TimeSpan.FromMilliseconds(300));
subs.Cancel();
f.Task.Wait(500).Should().BeTrue();
f.Task.Result.Should().Be(null);
}, Materializer);
}
public void A_Merge_must_work_in_the_happy_case()
{
this.AssertAllStagesStopped(() =>
{
// Different input sizes(4 and 6)
var source1 = Source.From(Enumerable.Range(0, 4));
var source2 = Source.From(Enumerable.Range(4, 6));
var source3 = Source.From(new List <int>());
var probe = TestSubscriber.CreateManualProbe <int>(this);
RunnableGraph.FromGraph(GraphDsl.Create(b =>
{
var m1 = b.Add(new Merge <int>(2));
var m2 = b.Add(new Merge <int>(2));
var sink = Sink.FromSubscriber(probe);
b.From(source1).To(m1.In(0));
b.From(m1.Out).Via(Flow.Create <int>().Select(x => x * 2)).To(m2.In(0));
b.From(m2.Out).Via(Flow.Create <int>().Select(x => x / 2).Select(x => x + 1)).To(sink);
b.From(source2).To(m1.In(1));
b.From(source3).To(m2.In(1));
return(ClosedShape.Instance);
})).Run(Materializer);
var subscription = probe.ExpectSubscription();
var collected = new List <int>();
for (var i = 1; i <= 10; i++)
{
subscription.Request(1);
collected.Add(probe.ExpectNext());
}
collected.ShouldAllBeEquivalentTo(Enumerable.Range(1, 10));
probe.ExpectComplete();
}, Materializer);
}
public void Buffer_must_fail_upstream_if_buffer_is_full_and_configured_so()
{
this.AssertAllStagesStopped(() =>
{
var publisher = TestPublisher.CreateProbe <int>(this);
var subscriber = TestSubscriber.CreateManualProbe <int>(this);
Source.FromPublisher(publisher)
.Buffer(100, OverflowStrategy.Fail)
.To(Sink.FromSubscriber(subscriber))
.Run(Materializer);
var sub = subscriber.ExpectSubscription();
// Fill up buffer
Enumerable.Range(1, 100).ForEach(i => publisher.SendNext(i));
// drain
for (var i = 1; i <= 10; i++)
{
sub.Request(1);
subscriber.ExpectNext(i);
}
// overflow the buffer
for (var i = 101; i <= 111; i++)
{
publisher.SendNext(i);
}
publisher.ExpectCancellation();
var actualError = subscriber.ExpectError();
actualError.Should().BeOfType <BufferOverflowException>();
actualError.Message.Should().Be("Buffer overflow (max capacity was 100)");
}, Materializer);
}
public void ZipWith_must_work_with_up_to_9_inputs()
{
// the jvm version uses 19 inputs but we have only 9
this.AssertAllStagesStopped(() =>
{
var probe = TestSubscriber.CreateManualProbe <string>(this);
RunnableGraph.FromGraph(GraphDsl.Create(b =>
{
Func <int, string, int, string, int, string, int, string, int, string> sum9 =
(i1, s1, i2, s2, i3, s3, i4, s4, i5) => i1 + s1 + i2 + s2 + i3 + s3 + i4 + s4 + i5;
// odd input ports will be Int, even input ports will be String
var zipWith = b.Add(ZipWith.Apply(sum9));
b.From(Source.Single(1)).To(zipWith.In0);
b.From(Source.Single("2")).To(zipWith.In1);
b.From(Source.Single(3)).To(zipWith.In2);
b.From(Source.Single("4")).To(zipWith.In3);
b.From(Source.Single(5)).To(zipWith.In4);
b.From(Source.Single("6")).To(zipWith.In5);
b.From(Source.Single(7)).To(zipWith.In6);
b.From(Source.Single("8")).To(zipWith.In7);
b.From(Source.Single(9)).To(zipWith.In8);
b.From(zipWith.Out).To(Sink.FromSubscriber(probe));
return(ClosedShape.Instance);
})).Run(Materializer);
var subscription = probe.ExpectSubscription();
subscription.Request(1);
probe.ExpectNext(Enumerable.Range(1, 9).Aggregate("", (s, i) => s + i));
probe.ExpectComplete();
}, Materializer);
}
public void UnicastProcessor_Online_Fused_Scheduled_2()
{
for (int i = 0; i < 10000; i++)
{
var up = new UnicastProcessor <int>();
var ts = new TestSubscriber <int>(fusionMode: FuseableHelper.ANY);
int[] wait = { 2 };
Task.Run(() =>
{
Interlocked.Decrement(ref wait[0]);
while (Volatile.Read(ref wait[0]) != 0)
{
;
}
up.OnNext(1, 2);
up.OnNext(3, 4);
up.OnNext(5, 6);
up.OnComplete();
});
Interlocked.Decrement(ref wait[0]);
while (Volatile.Read(ref wait[0]) != 0)
{
;
}
up.Subscribe(ts);
ts
.AwaitTerminalEvent(TimeSpan.FromSeconds(5))
.AssertResult(1, 2, 3, 4, 5, 6);
}
}
public void Buffer_must_drop_tail_elements_if_buffer_is_full_and_configured_so()
{
var publisher = TestPublisher.CreateProbe <int>(this);
var subscriber = TestSubscriber.CreateManualProbe <int>(this);
Source.FromPublisher(publisher)
.Buffer(100, OverflowStrategy.DropTail)
.To(Sink.FromSubscriber(subscriber))
.Run(Materializer);
var sub = subscriber.ExpectSubscription();
// Fill up buffer
Enumerable.Range(1, 200).ForEach(i => publisher.SendNext(i));
// The next request would be otherwise in race with the last onNext in the above loop
subscriber.ExpectNoMsg(TimeSpan.FromMilliseconds(500));
// drain
for (var i = 1; i <= 99; i++)
{
sub.Request(1);
subscriber.ExpectNext(i);
}
sub.Request(1);
subscriber.ExpectNext(200);
sub.Request(1);
subscriber.ExpectNoMsg(TimeSpan.FromSeconds(1));
publisher.SendNext(-1);
sub.Request(1);
subscriber.ExpectNext(-1);
sub.Cancel();
}
public void A_Flow_with_SelectAsyncUnordered_must_signal_task_failure()
{
this.AssertAllStagesStopped(() =>
{
var latch = new TestLatch(1);
var c = TestSubscriber.CreateManualProbe <int>(this);
Source.From(Enumerable.Range(1, 5))
.SelectAsyncUnordered(4, n => Task.Run(() =>
{
if (n == 3)
{
throw new TestException("err1");
}
latch.Ready(TimeSpan.FromSeconds(10));
return(n);
}))
.To(Sink.FromSubscriber(c)).Run(Materializer);
var sub = c.ExpectSubscription();
sub.Request(10);
c.ExpectError().InnerException.Message.Should().Be("err1");
latch.CountDown();
}, Materializer);
}
public void LockstepEmitLast()
{
var dp1 = new DirectProcessor <int>();
var dp2 = new DirectProcessor <int>();
TestSubscriber <int> ts = dp1.Sample(dp2, true).Test();
ts.AssertEmpty();
dp1.OnNext(1);
dp1.OnNext(2);
dp2.OnNext(100);
ts.AssertValues(2);
dp2.OnNext(100);
ts.AssertValues(2);
dp1.OnNext(3);
dp1.OnNext(4);
dp2.OnNext(200);
ts.AssertValues(2, 4);
dp1.OnNext(5);
dp2.OnComplete();
ts.AssertResult(2, 4, 5);
Assert.IsFalse(dp1.HasSubscribers);
Assert.IsFalse(dp2.HasSubscribers);
}
public void An_Interleave_for_Flow_must_work_in_the_happy_case()
{
this.AssertAllStagesStopped(() =>
{
var probe = TestSubscriber.CreateManualProbe <int>(this);
Source.From(Enumerable.Range(0, 4))
.Interleave(Source.From(Enumerable.Range(4, 3)), 2)
.Interleave(Source.From(Enumerable.Range(7, 5)), 3)
.RunWith(Sink.FromSubscriber(probe), Materializer);
var subscription = probe.ExpectSubscription();
var collected = new List <int>();
for (var i = 1; i <= 12; i++)
{
subscription.Request(1);
collected.Add(probe.ExpectNext());
}
collected.ShouldAllBeEquivalentTo(new[] { 0, 1, 4, 7, 8, 9, 5, 2, 3, 10, 11, 6 });
probe.ExpectComplete();
}, Materializer);
}
public void TestNotifyEachWithMilliseconds()
{
MockTimeSource mockTimeSource = new MockTimeSource(new DateTime(2010, 1, 1));
using (TestSubscriber subscriber = new TestSubscriber()) {
using (Scheduler scheduler = new Scheduler(mockTimeSource)) {
scheduler.NotifyEach(1000, 1000, subscriber.Callback);
mockTimeSource.AdvanceTime(TimeSpan.FromMilliseconds(4000));
// Wait for 4 invocations of the callback. We might not catch each trigger
// of the AutoResetEvent, but we know that it will be 4 at most.
for (int invocation = 0; invocation < 4; ++invocation)
{
Assert.IsTrue(subscriber.WaitForCallback(1000));
if (subscriber.CallbackCount == 4)
{
break;
}
}
}
}
}
public void GroupBy_and_SplitWhen_must_timeout_and_stop_groupBy_parent_actor_if_none_of_the_substreams_are_actually_consumed()
{
this.AssertAllStagesStopped(() =>
{
var subscriber = TestSubscriber.CreateManualProbe <Tuple <int, Source <int, NotUsed> > >(this);
var publisherProbe = TestPublisher.CreateProbe <int>(this);
var publisher =
Source.FromPublisher(publisherProbe)
.GroupBy(2, x => x % 2)
.Lift(x => x % 2).RunWith(Sink.FromSubscriber(subscriber), Materializer);
var downstreamSubscription = subscriber.ExpectSubscription();
downstreamSubscription.Request(100);
publisherProbe.SendNext(1);
publisherProbe.SendNext(2);
publisherProbe.SendNext(3);
publisherProbe.SendComplete();
subscriber.ExpectNext();
subscriber.ExpectNext();
}, Materializer);
}
void can_handle_threaded_messages()
{
var bus = new Dispatcher("test", 2);
using (var sub = new TestSubscriber(bus)) {
sub.Subscribe(
new AdHocHandler <CountedTestMessage>(_ => Interlocked.Increment(ref _msgCount)));
var messages = new IMessage[_count];
for (int i = 0; i < _count; i++)
{
messages[i] = new CountedTestMessage(i);
}
for (int i = 0; i < _count; i++)
{
bus.Publish(messages[i]);
}
AssertEx.IsOrBecomesTrue(
() => _msgCount == _count,
1000,
$"Expected message count to be {_count} Messages, found {_msgCount }");
}
}
public void ExecuteSubjectTest()
{
var subscriber = new TestSubscriber();
MessageSenderService.ExecuteSubject.Subscribe(subscriber);
var messageSenderService = new MessageSenderService();
var testMessage = new TestMessage
{
Title = "Test Message"
};
messageSenderService.Send <TestMessageSender, TestMessage>(testMessage);
Thread.Sleep(TimeSpan.FromSeconds(1));
Assert.AreEqual(1, TestSubscriber.ActionContexts.Count);
var actionContext = TestSubscriber.ActionContexts[0];
var data = JsonConvert.DeserializeObject <TestMessage>(actionContext.Data);
Assert.AreEqual(testMessage.Title, data.Title);
Assert.AreEqual("Message Sent", actionContext.Action);
Assert.AreEqual(typeof(TestMessageSender), actionContext.MessageSenderType);
Assert.AreEqual(typeof(TestMessage), actionContext.MessageType);
}
public async Task TestMethod2()
{
var serializer = new JsonMessageSerializer <TestEvent>();
File.Delete("TestMethod2.txt");
var store = new EventStore <TestEvent>("TestMethod2.txt", serializer);
var anEvent = new TestEvent
{
TestProperty = "hello"
};
var testSubscriber = new TestSubscriber();
CancellationTokenSource cts = new CancellationTokenSource();
var readTask = store.ReadAsync(testSubscriber, cts.Token);
await Task.Delay(100);
await store.WriteEventAsync(anEvent);
await Task.Delay(1000);
cts.Cancel();
await readTask;
Assert.AreEqual("hello", testSubscriber.TestProperty);
}
public OutboundRouterBehaviorTests()
{
var services = new ServiceCollection();
_testSubscriber = new TestSubscriber();
services.AddSilverback()
.WithConnectionToMessageBroker(
options => options
.AddBroker <TestBroker>()
.AddBroker <TestOtherBroker>())
.AddSingletonSubscriber(_testSubscriber);
services.AddNullLogger();
_serviceProvider = services.BuildServiceProvider();
_behavior = (OutboundRouterBehavior)_serviceProvider.GetServices <IBehavior>()
.First(s => s is OutboundRouterBehavior);
_routingConfiguration =
(OutboundRoutingConfiguration)_serviceProvider.GetRequiredService <IOutboundRoutingConfiguration>();
_broker = _serviceProvider.GetRequiredService <TestBroker>();
_otherBroker = _serviceProvider.GetRequiredService <TestOtherBroker>();
}
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 = TestSubscriber.CreateManualProbe <int>(this);
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 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 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 PrefixAndTail_must_handle_OnError_when_no_substream_is_open()
{
this.AssertAllStagesStopped(() =>
{
var publisher = TestPublisher.CreateManualProbe <int>(this);
var subscriber = TestSubscriber.CreateManualProbe <Tuple <IImmutableList <int>, Source <int, NotUsed> > >(this);
Source.FromPublisher(publisher)
.PrefixAndTail(3)
.To(Sink.FromSubscriber(subscriber))
.Run(Materializer);
var upstream = publisher.ExpectSubscription();
var downstream = subscriber.ExpectSubscription();
downstream.Request(1);
upstream.ExpectRequest();
upstream.SendNext(1);
upstream.SendError(TestException);
subscriber.ExpectError().Should().Be(TestException);
}, Materializer);
}
public void FlowGraphs_when_turned_into_sources_should_be_reusable_multiple_times()
{
var probe = TestSubscriber.CreateManualProbe <int>(this);
var source =
Source.FromGraph(GraphDsl.Create(Source.From(Enumerable.Range(1, 5)),
(b, s) =>
{
var o = b.From(s.Outlet).Via(Flow.Create <int>().Select(x => x * 2));
return(new SourceShape <int>(o.Out));
}));
RunnableGraph.FromGraph(GraphDsl.Create(source, source, Keep.Both, (b, s1, s2) =>
{
var merge = b.Add(new Merge <int>(2));
b.From(s1.Outlet).To(merge.In(0));
b.From(merge.Out)
.To(Sink.FromSubscriber(probe).MapMaterializedValue(_ => Tuple.Create(NotUsed.Instance, NotUsed.Instance)));
b.From(s2.Outlet).Via(Flow.Create <int>().Select(x => x * 10)).To(merge.In(1));
return(ClosedShape.Instance);
})).Run(Materializer);
ValidateProbe(probe, 10, new[] { 2, 4, 6, 8, 10, 20, 40, 60, 80, 100 });
}
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 PrefixAndTail_must_handle_master_stream_cancellation()
{
this.AssertAllStagesStopped(() =>
{
var publisher = TestPublisher.CreateManualProbe <int>(this);
var subscriber = TestSubscriber.CreateManualProbe <Tuple <IImmutableList <int>, Source <int, NotUsed> > >(this);
Source.FromPublisher(publisher)
.PrefixAndTail(3)
.To(Sink.FromSubscriber(subscriber))
.Run(Materializer);
var upstream = publisher.ExpectSubscription();
var downstream = subscriber.ExpectSubscription();
downstream.Request(1);
upstream.ExpectRequest();
upstream.SendNext(1);
downstream.Cancel();
upstream.ExpectCancellation();
}, 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 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 WhenAddedPropertyChangedHandlerTargetIsNotAlive_ThenDoesNotNotify()
{
var foo = new Foo();
var manager = new PropertyChangeManager(foo);
var subscriber = new TestSubscriber("Name", 1);
manager.AddHandler(subscriber.PropertyChangedHandler);
manager.NotifyChanged<Foo>(x => x.Name);
Assert.Equal(1, subscriber.ActualCalls);
subscriber = null;
GC.Collect();
manager.NotifyChanged<Foo>(x => x.Name);
}
static void Main(string[] args)
{
var bus = Configure.With().Log4Net()
.DefaultBuilder()
//.InMemorySubscriptionStorage()
//
.MsmqTransport()
.RavenPersistence("NServiceBus.Persistence", "NServiceBusKarlTest")
.RavenSubscriptionStorage()
//.DontUseTransactions()
//.MessageForwardingInCaseOfFault()
//.MsmqSubscriptionStorage()
.UnicastBus()
/* if you do not do this there will be no messages placed in the
* subscription queue to allow MsmqSubscriptionStorage to work
* Interestingly enough if you use InMemorySubscriptionStorage
* subscriptions will work. If you remove LoadMessageHandlers
* the subscriptions are already in the queue, so it knows to forward
* the messages to the existing handlers.
*
* If i had more energy I would submit a patch for nservicebus, but
* really??
*/
.LoadMessageHandlers()
.AllowSubscribeToSelf()
.CreateBus()
.Start();
var myListener = new TestSubscriber(bus);
bus.Subscribe(typeof(TestDomainMessage));
IStoreEvents store = Wireup.Init()
.LogToConsoleWindow()
//.UsingInMemoryPersistence()
.UsingSqlPersistence("Test")
.WithDialect(new MsSqlDialect())
.InitializeStorageEngine()
.UsingBinarySerialization()
.UsingAsynchronousDispatchScheduler(new MyDispatcher(bus))
.Build();
try
{
PopulateStore(store, bus);
}
catch (Exception)
{
Console.Error.WriteLine("Done.");
}
Console.ReadKey();
}
public void TestNotifyAt() {
MockTimeSource mockTimeSource = new MockTimeSource(new DateTime(2010, 1, 1));
using(TestSubscriber subscriber = new TestSubscriber()) {
using(Scheduler scheduler = new Scheduler(mockTimeSource)) {
scheduler.NotifyAt(makeUtc(new DateTime(2010, 1, 2)), subscriber.Callback);
mockTimeSource.AdvanceTime(TimeSpan.FromDays(1));
Assert.IsTrue(subscriber.WaitForCallback(1000));
}
}
}
public void TestNotifyAtWithDateTimeAdjustment() {
MockTimeSource mockTimeSource = new MockTimeSource(new DateTime(2010, 1, 1));
using(TestSubscriber subscriber = new TestSubscriber()) {
using(Scheduler scheduler = new Scheduler(mockTimeSource)) {
scheduler.NotifyAt(makeUtc(new DateTime(2010, 1, 2)), subscriber.Callback);
// Let 12 hours pass, after that, we simulate a time synchronization
// that puts the system 12 hours ahead of the original time.
mockTimeSource.AdvanceTime(TimeSpan.FromHours(12));
mockTimeSource.AdjustTime(new DateTime(2010, 1, 2));
Assert.IsTrue(subscriber.WaitForCallback(1000));
}
}
}
public void TestThrowOnNotifyAtWithUnspecifiedDateTimeKind() {
using(TestSubscriber subscriber = new TestSubscriber()) {
using(Scheduler scheduler = new Scheduler()) {
Assert.Throws<ArgumentException>(
delegate() {
scheduler.NotifyAt(new DateTime(2000, 1, 1), subscriber.Callback);
}
);
}
}
}
public void Unsubscribe_MultipleInstances_SameClass()
{
// Arrange
var bus = new MessageBus();
// Subscribe two objects of the same type.
var subscriber1 = new TestSubscriber();
bus.Subscribe<Object>(subscriber1.Handler);
var subscriber2 = new TestSubscriber();
bus.Subscribe<Object>(subscriber2.Handler);
// Act
// Unsubscribe the second of the objects and make sure the other first one still gets messages.
bus.Unsubscribe<Object>(subscriber2.Handler);
var message = new Object();
bus.Publish<Object>(message);
// Assert
Assert.AreEqual(0, subscriber2.Messages.Count);
Assert.AreEqual(1, subscriber1.Messages.Count);
}
public void TestCancelFinalNotification() {
MockTimeSource mockTimeSource = new MockTimeSource(new DateTime(2010, 1, 1));
using(TestSubscriber subscriber = new TestSubscriber()) {
using(Scheduler scheduler = new Scheduler(mockTimeSource)) {
scheduler.Cancel(
scheduler.NotifyIn(TimeSpan.FromHours(12), subscriber.Callback)
);
mockTimeSource.AdvanceTime(TimeSpan.FromHours(14));
Thread.Sleep(1);
}
}
}
public void TestTwoNotificationsAtSameTime() {
MockTimeSource mockTimeSource = new MockTimeSource(new DateTime(2010, 1, 1));
using(TestSubscriber subscriber1 = new TestSubscriber()) {
using(TestSubscriber subscriber2 = new TestSubscriber()) {
using(Scheduler scheduler = new Scheduler(mockTimeSource)) {
scheduler.NotifyIn(60000, subscriber1.Callback);
scheduler.NotifyIn(60000, subscriber2.Callback);
mockTimeSource.AdvanceTime(TimeSpan.FromMilliseconds(60000));
Assert.IsTrue(subscriber1.WaitForCallback(1000));
Assert.IsTrue(subscriber2.WaitForCallback(1000));
}
}
}
}
public void TestCancelNotification() {
MockTimeSource mockTimeSource = new MockTimeSource(new DateTime(2010, 1, 1));
using(TestSubscriber subscriber1 = new TestSubscriber()) {
using(TestSubscriber subscriber2 = new TestSubscriber()) {
using(Scheduler scheduler = new Scheduler(mockTimeSource)) {
object handle = scheduler.NotifyIn(
TimeSpan.FromHours(24), subscriber1.Callback
);
scheduler.NotifyIn(TimeSpan.FromHours(36), subscriber2.Callback);
mockTimeSource.AdvanceTime(TimeSpan.FromHours(12));
scheduler.Cancel(handle);
mockTimeSource.AdvanceTime(TimeSpan.FromHours(24));
// Wait for the second subscriber to be notified. This is still a race
// condition (there's no guarantee the thread pool will run tasks in
// the order they were added), but it's the best we can do without
// relying on an ugly Thread.Sleep() in this test.
Assert.IsTrue(subscriber2.WaitForCallback(1000));
Assert.AreEqual(0, subscriber1.CallbackCount);
}
}
}
}
public void TestInverseOrderNotification() {
MockTimeSource mockTimeSource = new MockTimeSource(new DateTime(2010, 1, 1));
using(TestSubscriber subscriber1 = new TestSubscriber()) {
using(TestSubscriber subscriber2 = new TestSubscriber()) {
using(Scheduler scheduler = new Scheduler(mockTimeSource)) {
scheduler.NotifyIn(TimeSpan.FromHours(24), subscriber1.Callback);
scheduler.NotifyIn(TimeSpan.FromHours(12), subscriber2.Callback);
mockTimeSource.AdvanceTime(TimeSpan.FromHours(18));
Assert.IsTrue(subscriber2.WaitForCallback(1000));
Assert.AreEqual(0, subscriber1.CallbackCount);
mockTimeSource.AdvanceTime(TimeSpan.FromHours(18));
Assert.IsTrue(subscriber1.WaitForCallback(1000));
}
}
}
}
public void TestNotifyEachWithTimespan() {
MockTimeSource mockTimeSource = new MockTimeSource(new DateTime(2010, 1, 1));
using(TestSubscriber subscriber = new TestSubscriber()) {
using(Scheduler scheduler = new Scheduler(mockTimeSource)) {
scheduler.NotifyEach(
TimeSpan.FromHours(12), TimeSpan.FromHours(1), subscriber.Callback
);
mockTimeSource.AdvanceTime(TimeSpan.FromHours(14));
// Wait for 3 invocations of the callback. We might not catch each trigger
// of the AutoResetEvent, but we know that it will be 3 at most.
for(int invocation = 0; invocation < 3; ++invocation) {
Assert.IsTrue(subscriber.WaitForCallback(1000));
if(subscriber.CallbackCount == 3) {
break;
}
}
}
}
}
