public void EnsureDrain()
{
var subject = "176bb0976ef943e3988de4957c9e1a1a";
var q = new ConcurrentQueue <int>();
AsyncContext.Run(() =>
{
using (NATSServer.CreateFastAndVerify(Context.Server1.Port))
{
using (var sync = TestSync.SingleActor())
{
var opts = Context.GetTestOptions(Context.Server1.Port);
opts.ClosedEventHandler = (sender, args) =>
{
q.Enqueue(1);
sync.SignalComplete();
};
using (var cn = Context.ConnectionFactory.CreateConnection(opts))
{
for (var i = 0; i < 50; i++)
{
cn.Publish(subject, new[] { (byte)i });
}
cn.Drain();
sync.WaitForAll();
Assert.Single(q);
}
}
}
});
}
public void EnsureUnsubscribeForAsyncSub()
{
var subject = "d37e3729c5c84702b836a4bb4edf7241";
var recieved = new ConcurrentQueue <Msg>();
AsyncContext.Run(async() =>
{
using (NATSServer.CreateFastAndVerify(Context.Server1.Port))
{
using (var sync = TestSync.SingleActor())
{
using (var cn = Context.ConnectionFactory.CreateConnection(Context.Server1.Url))
{
using (var sub = cn.SubscribeAsync(subject, (_, m) =>
{
recieved.Enqueue(m.Message);
sync.SignalComplete();
}))
{
cn.Publish(subject, new byte[0]);
sync.WaitForAll();
sub.Unsubscribe();
cn.Publish(subject, new byte[0]);
await Task.Delay(100);
Assert.Equal(1, sub.Delivered);
}
}
Assert.Single(recieved);
}
}
});
}
public void WhenObservingMoreThanOneSubjectTheyShouldNotInterfere()
{
sync = TestSync.TwoActors();
var subject1 = "eaa520002f1f42b0b5e2d0e162822780";
var subject2 = "319198581087493da52b48c96de2bf7e";
var payload1 = SamplePayload.Random();
var payload2 = SamplePayload.Random();
using (NATSServer.CreateFastAndVerify(Context.Server1.Port))
{
using (var cn = Context.OpenConnection(Context.Server1.Port))
{
using (var observable1 = cn.Observe(subject1))
using (var observable2 = cn.Observe(subject2))
{
var interceptingOb1 = new TestObserver(_ => sync.SignalComplete());
var interceptingOb2 = new TestObserver(_ => sync.SignalComplete());
observable1.Subscribe(interceptingOb1);
observable2.Subscribe(interceptingOb2);
cn.Publish(subject1, payload1);
cn.Publish(subject2, payload2);
sync.WaitForAll();
Assert.Equal(payload1, interceptingOb1.OnNextResults.Single());
Assert.Equal(payload2, interceptingOb2.OnNextResults.Single());
}
}
}
}
public void WhenObservingMoreThanOneSubjectTheyShouldNotInterfere()
{
sync = TestSync.TwoActors();
var subject1 = "32c4eeffac584ac19227bd68d2726a2b";
var subject2 = "468fb15ff1ef4d738bddbf063aa3ae5d";
var payload1 = SamplePayload.Random();
var payload2 = SamplePayload.Random();
using (Context.StartStreamingServerWithEmbedded(Context.Server1))
{
using (var cn = Context.GetStanConnection(Context.Server1))
{
using (var observable1 = cn.Observe(subject1))
using (var observable2 = cn.Observe(subject2))
{
var interceptingOb1 = new TestObserver(_ => sync.SignalComplete());
var interceptingOb2 = new TestObserver(_ => sync.SignalComplete());
observable1.Subscribe(interceptingOb1);
observable2.Subscribe(interceptingOb2);
cn.Publish(subject1, payload1);
cn.Publish(subject2, payload2);
sync.WaitForAll();
Assert.Equal(payload1, interceptingOb1.OnNextResults.Single());
Assert.Equal(payload2, interceptingOb2.OnNextResults.Single());
}
}
}
}
public void WhenSubscribingMoreThanOneObserverToTheObservableOnlyOneServerSubscriptionShouldBeSetup()
{
sync = TestSync.FourActors();
var subject = "42016e8229d340c9869c8c2e30fec4f6";
var payload = SamplePayload.Random();
using (Context.StartStreamingServerWithEmbedded(Context.Server1))
{
using (var cn = Context.GetStanConnection(Context.Server1))
{
var initialSubscriptionCount = cn.NATSConnection.SubscriptionCount;
using (var observable = cn.Observe(subject))
{
var interceptingOb = new TestObserver(_ => sync.SignalComplete());
var interceptingSafeOb = new TestObserver(_ => sync.SignalComplete());
observable.Subscribe(interceptingOb);
observable.Subscribe(interceptingSafeOb);
observable.Subscribe(_ => sync.SignalComplete());
observable.SubscribeSafe(_ => sync.SignalComplete());
cn.Publish(subject, payload);
sync.WaitForAll();
Assert.Equal(1, cn.NATSConnection.SubscriptionCount - initialSubscriptionCount);
}
}
}
}
public void WhenDisposingAnObserverItShouldNotReceiveMoreMessages()
{
sync = TestSync.TwoActors();
var subject = "415b09873e3348d3a953e93d35ff61bf";
var payload1 = SamplePayload.Random();
var payload2 = SamplePayload.Random();
using (NATSServer.CreateFastAndVerify(Context.Server1.Port))
{
var interceptingOb1 = new TestObserver(_ => sync.SignalComplete());
var interceptingOb2 = new TestObserver(_ => sync.SignalComplete());
using (var cn = Context.OpenConnection(Context.Server1.Port))
{
using (var observable = cn.Observe(subject))
{
using (observable.Subscribe(interceptingOb1))
{
using (observable.Subscribe(interceptingOb2))
{
cn.Publish(subject, payload1);
sync.WaitForAll();
}
cn.Publish(subject, payload2);
sync.WaitForOne();
}
Assert.Equal(new[] { payload1.Data, payload2.Data }, interceptingOb1.OnNextResults.Select(i => i.Data).ToArray());
Assert.Equal(new[] { payload1.Data }, interceptingOb2.OnNextResults.Select(i => i.Data).ToArray());
}
}
}
}
public void WhenDisposingAnObserverItShouldNotReceiveMoreMessages()
{
sync = TestSync.TwoActors();
var subject = "f3d07d4e380048399df9363222ca482b";
var payload1 = SamplePayload.Random();
var payload2 = SamplePayload.Random();
using (Context.StartStreamingServerWithEmbedded(Context.Server1))
{
var interceptingOb1 = new TestObserver(_ => sync.SignalComplete());
var interceptingOb2 = new TestObserver(_ => sync.SignalComplete());
using (var cn = Context.GetStanConnection(Context.Server1))
{
using (var observable = cn.Observe(subject))
{
using (observable.Subscribe(interceptingOb1))
{
using (observable.Subscribe(interceptingOb2))
{
cn.Publish(subject, payload1);
sync.WaitForAll();
}
cn.Publish(subject, payload2);
sync.WaitForOne();
}
Assert.Equal(new[] { payload1.Data, payload2.Data }, interceptingOb1.OnNextResults.Select(i => i.Data).ToArray());
Assert.Equal(new[] { payload1.Data }, interceptingOb2.OnNextResults.Select(i => i.Data).ToArray());
}
}
}
}
public void EnsureDrainAsync()
{
var subject = "5dc823d90cab46679e0bf51afffda767";
var q = new ConcurrentQueue <int>();
AsyncContext.Run(async() =>
{
using (NATSServer.CreateFastAndVerify(Context.Server1.Port))
{
using (var sync = TestSync.SingleActor())
{
var opts = Context.GetTestOptions(Context.Server1.Port);
opts.ClosedEventHandler = (sender, args) =>
{
q.Enqueue(1);
sync.SignalComplete();
};
using (var cn = Context.ConnectionFactory.CreateConnection(opts))
{
for (var i = 0; i < 50; i++)
{
cn.Publish(subject, new[] { (byte)i });
}
await cn.DrainAsync();
sync.WaitForAll();
Assert.Single(q);
}
}
}
});
}
public void WhenSubscribingMoreThanOneObserverToTheObservableOnlyOneServerSubscriptionShouldBeSetup()
{
sync = TestSync.FourActors();
var subject = "eaa520002f1f42b0b5e2d0e162822780";
var payload = SamplePayload.Random();
using (NATSServer.CreateFastAndVerify(Context.Server1.Port))
{
using (var cn = Context.OpenConnection(Context.Server1.Port))
{
using (var observable = cn.Observe(subject))
{
var interceptingOb = new TestObserver(_ => sync.SignalComplete());
var interceptingSafeOb = new TestObserver(_ => sync.SignalComplete());
observable.Subscribe(interceptingOb);
observable.Subscribe(interceptingSafeOb);
observable.Subscribe(_ => sync.SignalComplete());
observable.SubscribeSafe(_ => sync.SignalComplete());
cn.Publish(subject, payload);
sync.WaitForAll();
Assert.Equal(1, cn.SubscriptionCount);
}
}
}
}
public void WhenPublishingAllSubscribedObserversShouldGetTheMessage()
{
sync = TestSync.FourActors();
var subject = "008f9155d7b84821a26d2e41f73a9a7f";
var payload = SamplePayload.Random();
using (Context.StartStreamingServerWithEmbedded(Context.Server1))
{
using (var cn = Context.GetStanConnection(Context.Server1))
{
using (var observable = cn.Observe(subject))
{
var interceptingOb = new TestObserver(_ => sync.SignalComplete());
var interceptingSafeOb = new TestObserver(_ => sync.SignalComplete());
StanMsg delegatingObIntercept = null, safeDelegatingObIntercept = null;
observable.Subscribe(interceptingOb);
observable.SubscribeSafe(interceptingSafeOb);
observable.Subscribe(msg =>
{
delegatingObIntercept = msg;
sync.SignalComplete();
});
observable.SubscribeSafe(msg =>
{
safeDelegatingObIntercept = msg;
sync.SignalComplete();
});
cn.Publish(subject, payload);
sync.WaitForAll();
Assert.Equal(payload, interceptingOb.OnNextResults.Single());
Assert.Equal(payload, interceptingSafeOb.OnNextResults.Single());
Assert.Equal(payload, delegatingObIntercept);
Assert.Equal(payload, safeDelegatingObIntercept);
}
}
}
}
public void WhenPublishingAllSubscribedObserversShouldGetTheMessage()
{
sync = TestSync.FourActors();
var subject = "132dc3101ef74ede90913c70baa542de";
var payload = SamplePayload.Random();
using (NATSServer.CreateFastAndVerify(Context.Server1.Port))
{
using (var cn = Context.OpenConnection(Context.Server1.Port))
{
using (var observable = cn.Observe(subject))
{
var interceptingOb = new TestObserver(_ => sync.SignalComplete());
var interceptingSafeOb = new TestObserver(_ => sync.SignalComplete());
Msg delegatingObIntercept = null, safeDelegatingObIntercept = null;
observable.Subscribe(interceptingOb);
observable.SubscribeSafe(interceptingSafeOb);
observable.Subscribe(msg =>
{
delegatingObIntercept = msg;
sync.SignalComplete();
});
observable.SubscribeSafe(msg =>
{
safeDelegatingObIntercept = msg;
sync.SignalComplete();
});
cn.Publish(subject, payload);
sync.WaitForAll();
Assert.Equal(payload, interceptingOb.OnNextResults.Single());
Assert.Equal(payload, interceptingSafeOb.OnNextResults.Single());
Assert.Equal(payload, delegatingObIntercept);
Assert.Equal(payload, safeDelegatingObIntercept);
}
}
}
}
public void EnsurePubSubWithFlush()
{
var subject = "0b122a47380145b49969ddfaafe0c206";
var recieved = new ConcurrentQueue <Msg>();
AsyncContext.Run(() =>
{
using (NATSServer.CreateFastAndVerify(Context.Server1.Port))
{
using (var sync = TestSync.SingleActor())
{
using (var cn = Context.ConnectionFactory.CreateConnection(Context.Server1.Url))
{
using (cn.SubscribeAsync(subject, (_, m) =>
{
recieved.Enqueue(m.Message);
if (recieved.Count == 5)
{
sync.SignalComplete();
}
}))
{
for (var i = 0; i < 5; i++)
{
cn.Publish(subject, new[] { (byte)i });
cn.Flush();
cn.FlushBuffer();
}
sync.WaitForAll();
}
}
Assert.Equal(5, recieved.Count);
}
}
});
}
public void EnsurePubSubWithAsyncHandler()
{
var subject = "236c9af7eae044f585973503e9803f4a";
var recieved = new ConcurrentQueue <Msg>();
AsyncContext.Run(() =>
{
using (NATSServer.CreateFast(Context.Server1.Port))
{
using (var sync = TestSync.SingleActor())
{
using (var cn = Context.ConnectionFactory.CreateConnection(Context.Server1.Url))
{
using (cn.SubscribeAsync(subject, async(_, m) =>
{
await Task.Delay(100);
recieved.Enqueue(m.Message);
if (recieved.Count == 5)
{
sync.SignalComplete();
}
}))
{
for (var i = 0; i < 5; i++)
{
cn.Publish(subject, new[] { (byte)i });
}
sync.WaitForAll();
}
}
Assert.Equal(5, recieved.Count);
}
}
});
}
public void EnsureAutoUnsubscribeForAsyncSub()
{
var subject = "0be903f6c9c14c10973e78ce03ad47e1";
var recieved = new ConcurrentQueue <Msg>();
AsyncContext.Run(async() =>
{
using (NATSServer.CreateFast(Context.Server1.Port))
{
using (var sync = TestSync.SingleActor())
{
using (var cn = Context.ConnectionFactory.CreateConnection(Context.Server1.Url))
{
using (var sub = cn.SubscribeAsync(subject, (_, m) =>
{
recieved.Enqueue(m.Message);
sync.SignalComplete();
}))
{
sub.AutoUnsubscribe(1);
cn.Publish(subject, new byte[0]);
cn.Publish(subject, new byte[0]);
sync.WaitForAll();
await Task.Delay(100);
Assert.Equal(1, sub.Delivered);
}
}
Assert.Single(recieved);
}
}
});
}
public void WhenDisposingAnObservableNoMoreDispatchesShouldBeDone()
{
sync = TestSync.TwoActors();
var subject = "61d374c816034f8b9428b04e273f4c85";
var payload1 = SamplePayload.Random();
var payload2 = SamplePayload.Random();
using (Context.StartStreamingServerWithEmbedded(Context.Server1))
{
var interceptingOb1 = new TestObserver(_ => sync.SignalComplete());
var interceptingOb2 = new TestObserver(_ => sync.SignalComplete());
using (var cn = Context.GetStanConnection(Context.Server1))
{
var observable1 = cn.Observe(subject);
var observable2 = cn.Observe(subject);
observable1.Subscribe(interceptingOb1);
observable2.Subscribe(interceptingOb2);
cn.Publish(subject, payload1);
sync.WaitForAll();
observable1.Dispose();
cn.Publish(subject, payload2);
sync.WaitForOne();
observable2.Dispose();
Assert.Equal(new[] { payload1.Data }, interceptingOb1.OnNextResults.Select(i => i.Data).ToArray());
Assert.Equal(new[] { payload1.Data, payload2.Data }, interceptingOb2.OnNextResults.Select(i => i.Data).ToArray());
}
}
}
public void WhenDisposingAnObservableNoMoreDispatchesShouldBeDone()
{
sync = TestSync.TwoActors();
var subject = "bea00c947f4c470cb4e884c58202d3ac";
var payload1 = SamplePayload.Random();
var payload2 = SamplePayload.Random();
using (NATSServer.CreateFastAndVerify(Context.Server1.Port))
{
var interceptingOb1 = new TestObserver(_ => sync.SignalComplete());
var interceptingOb2 = new TestObserver(_ => sync.SignalComplete());
using (var cn = Context.OpenConnection(Context.Server1.Port))
{
var observable1 = cn.Observe(subject);
var observable2 = cn.Observe(subject);
observable1.Subscribe(interceptingOb1);
observable2.Subscribe(interceptingOb2);
cn.Publish(subject, payload1);
sync.WaitForAll();
observable1.Dispose();
cn.Publish(subject, payload2);
sync.WaitForOne();
observable2.Dispose();
Assert.Equal(new[] { payload1.Data }, interceptingOb1.OnNextResults.Select(i => i.Data).ToArray());
Assert.Equal(new[] { payload1.Data, payload2.Data }, interceptingOb2.OnNextResults.Select(i => i.Data).ToArray());
}
}
}
public void EnsurePubSub()
{
var subject = "16160bf236cb42dda5bbd0dfc744dacc";
var recieved = new ConcurrentQueue <Msg>();
AsyncContext.Run(() =>
{
using (NATSServer.CreateFastAndVerify(Context.Server1.Port))
{
using (var sync = TestSync.SingleActor())
{
using (var cn = Context.ConnectionFactory.CreateConnection(Context.Server1.Url))
{
using (cn.SubscribeAsync(subject, (_, m) =>
{
recieved.Enqueue(m.Message);
if (recieved.Count == 5)
{
sync.SignalComplete();
}
}))
{
for (var i = 0; i < 5; i++)
{
cn.Publish(subject, new[] { (byte)i });
}
sync.WaitForAll();
}
}
Assert.Equal(5, recieved.Count);
}
}
});
}
