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 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 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 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 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 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 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 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 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 TestRespondWithCustomInbox()
{
var opts = Context.GetTestOptionsWithDefaultTimeout(Context.Server1.Port);
opts.CustomInboxPrefix = "_TEST.";
using (NATSServer.CreateFastAndVerify(Context.Server1.Port))
{
using (var cn = Context.ConnectionFactory.CreateConnection(opts))
using (var requestSub = cn.SubscribeSync("foo"))
{
var replyTo = cn.NewInbox();
Assert.StartsWith("_TEST.", replyTo);
using (var responderSub = cn.SubscribeSync(replyTo))
{
cn.Publish("foo", replyTo, SamplePayload.Random());
var request = requestSub.NextMessage(1000);
Assert.NotNull(request);
Assert.Equal(replyTo, request.Reply);
var reply = SamplePayload.Random();
request.Respond(reply);
var response = responderSub.NextMessage(1000);
Assert.NotNull(response);
Assert.Equal(replyTo, response.Subject);
Assert.Equal(reply, response.Data);
requestSub.Unsubscribe();
responderSub.Unsubscribe();
}
}
}
}
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());
}
}
}
