public void TestAsyncSubHandlerAPI() { using (IConnection c = new ConnectionFactory().CreateConnection()) { int received = 0; EventHandler<MsgHandlerEventArgs> h = (sender, args) => { Interlocked.Increment(ref received); }; using (IAsyncSubscription s = c.SubscribeAsync("foo", h)) { c.Publish("foo", null); c.Flush(); Thread.Sleep(500); } using (IAsyncSubscription s = c.SubscribeAsync("foo", "bar", h)) { c.Publish("foo", null); c.Flush(); Thread.Sleep(500); } if (received != 2) { Assert.Fail("Received ({0}) != 2", received); } } }
public void TestClosedConnections() { IConnection c = new ConnectionFactory().CreateConnection(); ISyncSubscription s = c.SubscribeSync("foo"); c.Close(); // While we can annotate all the exceptions in the test framework, // just do it manually. UnitTestUtilities.testExpectedException( () => { c.Publish("foo", null); }, typeof(NATSConnectionClosedException)); UnitTestUtilities.testExpectedException( () => { c.Publish(new Msg("foo")); }, typeof(NATSConnectionClosedException)); UnitTestUtilities.testExpectedException( () => { c.SubscribeAsync("foo"); }, typeof(NATSConnectionClosedException)); UnitTestUtilities.testExpectedException( () => { c.SubscribeSync("foo"); }, typeof(NATSConnectionClosedException)); UnitTestUtilities.testExpectedException( () => { c.SubscribeAsync("foo", "bar"); }, typeof(NATSConnectionClosedException)); UnitTestUtilities.testExpectedException( () => { c.SubscribeSync("foo", "bar"); }, typeof(NATSConnectionClosedException)); UnitTestUtilities.testExpectedException( () => { c.Request("foo", null); }, typeof(NATSConnectionClosedException)); UnitTestUtilities.testExpectedException( () => { s.NextMessage(); }, typeof(NATSConnectionClosedException)); UnitTestUtilities.testExpectedException( () => { s.NextMessage(100); }, typeof(NATSConnectionClosedException)); UnitTestUtilities.testExpectedException( () => { s.Unsubscribe(); }, typeof(NATSConnectionClosedException)); UnitTestUtilities.testExpectedException( () => { s.AutoUnsubscribe(1); }, typeof(NATSConnectionClosedException)); }
public void TestBasicReconnectFunctionality() { Options opts = utils.DefaultTestOptions; opts.Url = "nats://localhost:22222"; opts.MaxReconnect = 2; opts.ReconnectWait = 1000; Object testLock = new Object(); Object msgLock = new Object(); opts.DisconnectedEventHandler = (sender, args) => { lock (testLock) { Monitor.Pulse(testLock); } }; opts.ReconnectedEventHandler = (sender, args) => { // NOOP }; NATSServer ns = utils.CreateServerOnPort(22222); using (IConnection c = new ConnectionFactory().CreateConnection(opts)) { IAsyncSubscription s = c.SubscribeAsync("foo"); s.MessageHandler += (sender, args) => { lock (msgLock) { Monitor.Pulse(msgLock); } }; s.Start(); c.Flush(); lock (testLock) { ns.Shutdown(); Assert.True(Monitor.Wait(testLock, 100000)); } c.Publish("foo", Encoding.UTF8.GetBytes("Hello")); // restart the server. using (ns = utils.CreateServerOnPort(22222)) { lock (msgLock) { c.Flush(50000); Assert.True(Monitor.Wait(msgLock, 10000)); } Assert.True(c.Stats.Reconnects == 1); } } }
public void TestCustomObjectSerialization() { using (IEncodedConnection c = new ConnectionFactory().CreateEncodedConnection()) { Object mu = new Object(); SerializationTestObj origObj = new SerializationTestObj(); EventHandler<EncodedMessageEventArgs> eh = (sender, args) => { // Ensure we blow up in the cast SerializationTestObj so = (SerializationTestObj)args.ReceivedObject; Assert.IsTrue(so.Equals(origObj)); lock (mu) { Monitor.Pulse(mu); } }; using (IAsyncSubscription s = c.SubscribeAsync("foo", eh)) { lock (mu) { c.Publish("foo", new SerializationTestObj()); c.Flush(); Monitor.Wait(mu, 1000); } } } }
public void TestServerAutoUnsub() { using (IConnection c = new ConnectionFactory().CreateConnection()) { long received = 0; int max = 10; using (IAsyncSubscription s = c.SubscribeAsync("foo")) { s.MessageHandler += (sender, arg) => { System.Console.WriteLine("Received msg."); received++; }; s.AutoUnsubscribe(max); s.Start(); for (int i = 0; i < (max * 2); i++) { c.Publish("foo", Encoding.UTF8.GetBytes("hello")); } c.Flush(); Thread.Sleep(500); if (received != max) { Assert.Fail("Recieved ({0}) != max ({1})", received, max); } Assert.IsFalse(s.IsValid); } } }
private static void NatsSubscribeMethod() { using (var c = new NC.ConnectionFactory().CreateEncodedConnection($"http://{Config.DOCKER_MACHINE_IP}:4222")) { c.OnDeserialize = Serializer.ProtobufDeserializer <User>; EventHandler <NC.EncodedMessageEventArgs> eh = (sender, args) => { var user = (User)args.ReceivedObject; var redisUser = GetUserFromRedis(user.Id.ToString()); Console.WriteLine(new string('*', 10)); Console.WriteLine($"User from NATS: {user}"); Console.WriteLine($"User from REDIS: {redisUser}"); Console.WriteLine($"Are users equal: {user.Equals(redisUser)}"); }; using (var s = c.SubscribeAsync("users", eh)) { Console.WriteLine("Waiting for a message.."); Console.WriteLine(); while (!string.IsNullOrEmpty(Console.ReadLine())) { Thread.Sleep(100); } } } }
public void TestReplyArg() { using (IConnection c = new ConnectionFactory().CreateConnection()) { using (IAsyncSubscription s = c.SubscribeAsync("foo")) { s.MessageHandler += ExpectedReplyHandler; s.Start(); lock(mu) { received = false; c.Publish("foo", "bar", null); Monitor.Wait(mu, 5000); } } } if (!received) Assert.Fail("Message not received."); }
public void TestQueueSubsOnReconnect() { AutoResetEvent reconnectEvent = new AutoResetEvent(false); Options opts = reconnectOptions; IConnection c; string subj = "foo.bar"; string qgroup = "workers"; opts.ReconnectedEventHandler += (sender, args) => { reconnectEvent.Set(); }; using(NATSServer ns = utils.CreateServerOnPort(22222)) { c = new ConnectionFactory().CreateConnection(opts); EventHandler<MsgHandlerEventArgs> eh = (sender, args) => { int seq = Convert.ToInt32(Encoding.UTF8.GetString(args.Message.Data)); lock (results) { if (results.ContainsKey(seq) == false) results.Add(seq, true); } }; // Create Queue Subscribers c.SubscribeAsync(subj, qgroup, eh); c.SubscribeAsync(subj, qgroup, eh); c.Flush(); sendAndCheckMsgs(c, subj, 10); } // server should stop... // give the OS time to shut it down. Thread.Sleep(1000); // start back up using (NATSServer ns = utils.CreateServerOnPort(22222)) { // wait for reconnect Assert.True(reconnectEvent.WaitOne(6000)); sendAndCheckMsgs(c, subj, 10); } }
public void TestLargeMessage() { using (IConnection c = new ConnectionFactory().CreateConnection()) { int msgSize = 51200; byte[] msg = new byte[msgSize]; for (int i = 0; i < msgSize; i++) msg[i] = (byte)'A'; msg[msgSize-1] = (byte)'Z'; using (IAsyncSubscription s = c.SubscribeAsync("foo")) { Object testLock = new Object(); s.MessageHandler += (sender, args) => { lock(testLock) { Monitor.Pulse(testLock); } Assert.IsTrue(compare(msg, args.Message.Data)); }; s.Start(); c.Publish("foo", msg); c.Flush(1000); lock(testLock) { Monitor.Wait(testLock, 2000); } } } }
public void TestLargeSubjectAndReply() { using (IConnection c = new ConnectionFactory().CreateConnection()) { String subject = ""; for (int i = 0; i < 1024; i++) { subject += "A"; } String reply = ""; for (int i = 0; i < 1024; i++) { reply += "A"; } using (IAsyncSubscription s = c.SubscribeAsync(subject)) { Object testLock = new Object(); s.MessageHandler += (sender, args) => { if (!subject.Equals(args.Message.Subject)) Assert.Fail("Invalid subject received."); if (!reply.Equals(args.Message.Reply)) Assert.Fail("Invalid subject received."); lock (testLock) { Monitor.Pulse(testLock); } }; s.Start(); c.Publish(subject, reply, null); c.Flush(); lock (testLock) { Assert.IsTrue(Monitor.Wait(testLock, 1000)); } } } }
public void TestSubDelTaskCountBasic() { var opts = utils.DefaultTestOptions; Assert.Throws<ArgumentOutOfRangeException>( () => { opts.SubscriberDeliveryTaskCount = -1; }); opts.SubscriberDeliveryTaskCount = 2; using (new NATSServer()) { using (IConnection c = new ConnectionFactory().CreateConnection(opts)) { int s1Count = 0; int s2Count = 0; int COUNT = 10; AutoResetEvent ev1 = new AutoResetEvent(false); AutoResetEvent ev2 = new AutoResetEvent(false); IAsyncSubscription s1 = c.SubscribeAsync("foo", (obj, args) => { s1Count++; if (s1Count == COUNT) { ev1.Set(); } }); IAsyncSubscription s2 = c.SubscribeAsync("bar", (obj, args) => { s2Count++; if (s2Count >= COUNT) { ev2.Set(); } }); for (int i = 0; i < 10; i++) { c.Publish("foo", null); c.Publish("bar", null); } c.Flush(); Assert.True(ev1.WaitOne(10000)); Assert.True(ev2.WaitOne(10000)); s1.Unsubscribe(); Assert.True(s1Count == COUNT); Assert.True(s2Count == COUNT); ev2.Reset(); c.Publish("bar", null); c.Flush(); Assert.True(ev2.WaitOne(10000)); Assert.True(s2Count == COUNT + 1); s2.Unsubscribe(); } } }
public void TestSlowAsyncSubscriber() { AutoResetEvent ev = new AutoResetEvent(false); Options opts = utils.DefaultTestOptions; opts.SubChannelLength = 100; using (new NATSServer()) { using (IConnection c = new ConnectionFactory().CreateConnection(opts)) { using (IAsyncSubscription s = c.SubscribeAsync("foo")) { Object mu = new Object(); s.MessageHandler += (sender, args) => { // block to back us up. ev.WaitOne(2000); }; s.Start(); Assert.True(s.PendingByteLimit == Defaults.SubPendingBytesLimit); Assert.True(s.PendingMessageLimit == Defaults.SubPendingMsgsLimit); long pml = 100; long pbl = 1024 * 1024; s.SetPendingLimits(pml, pbl); Assert.True(s.PendingByteLimit == pbl); Assert.True(s.PendingMessageLimit == pml); for (int i = 0; i < (pml + 100); i++) { c.Publish("foo", null); } int flushTimeout = 5000; Stopwatch sw = new Stopwatch(); sw.Start(); c.Flush(flushTimeout); sw.Stop(); ev.Set(); Assert.False(sw.ElapsedMilliseconds >= flushTimeout, string.Format("elapsed ({0}) > timeout ({1})", sw.ElapsedMilliseconds, flushTimeout)); } } } }
public void TestEncodedSerizationOverrides() { using (IEncodedConnection c = new ConnectionFactory().CreateEncodedConnection()) { c.OnDeserialize = deserializeFromXML; c.OnSerialize = serializeToXML; Object mu = new Object(); SerializationTestObj origObj = new SerializationTestObj(); origObj.a = 99; EventHandler<EncodedMessageEventArgs> eh = (sender, args) => { SerializationTestObj so = (SerializationTestObj)args.ReceivedObject; Assert.IsTrue(so.Equals(origObj)); lock (mu) { Monitor.Pulse(mu); } }; using (IAsyncSubscription s = c.SubscribeAsync("foo", eh)) { lock (mu) { c.Publish("foo", origObj); c.Flush(); Monitor.Wait(mu, 1000); } } } }
public void TestStats() { using (IConnection c = new ConnectionFactory().CreateConnection()) { byte[] data = Encoding.UTF8.GetBytes("The quick brown fox jumped over the lazy dog"); int iter = 10; for (int i = 0; i < iter; i++) { c.Publish("foo", data); } c.Flush(1000); IStatistics stats = c.Stats; Assert.AreEqual(iter, stats.OutMsgs); Assert.AreEqual(iter * data.Length, stats.OutBytes); c.ResetStats(); // Test both sync and async versions of subscribe. IAsyncSubscription s1 = c.SubscribeAsync("foo"); s1.MessageHandler += (sender, arg) => { }; s1.Start(); ISyncSubscription s2 = c.SubscribeSync("foo"); for (int i = 0; i < iter; i++) { c.Publish("foo", data); } c.Flush(1000); stats = c.Stats; Assert.AreEqual(2 * iter, stats.InMsgs); Assert.AreEqual(2 * iter * data.Length, stats.InBytes); } }
public void TestEncodedObjectRequestReply() { using (IEncodedConnection c = new ConnectionFactory().CreateEncodedConnection()) { Object mu = new Object(); SerializationTestObj origObj = new SerializationTestObj(); EventHandler<EncodedMessageEventArgs> eh = (sender, args) => { SerializationTestObj so = (SerializationTestObj)args.ReceivedObject; Assert.IsTrue(so.Equals(origObj)); String str = "Received"; c.Publish(args.Reply, str); c.Flush(); lock (mu) { Monitor.Pulse(mu); } }; using (IAsyncSubscription s = c.SubscribeAsync("foo", eh)) { Assert.IsTrue("Received".Equals(c.Request("foo", origObj, 1000))); Assert.IsTrue("Received".Equals(c.Request("foo", origObj))); } } }
public void TestEncodedObjectSerization() { using (IEncodedConnection c = new ConnectionFactory().CreateEncodedConnection()) { String myStr = "value"; Object mu = new Object(); EventHandler<EncodedMessageEventArgs> eh = (sender, args) => { Assert.IsTrue(args.ReceivedObject.Equals(myStr)); lock (mu) { Monitor.Pulse(mu); } }; using (IAsyncSubscription s = c.SubscribeAsync("foo", eh)) { lock (mu) { for (int i = 0; i < 10; i++) c.Publish("foo", myStr); c.Flush(); Monitor.Wait(mu, 1000); } } using (IAsyncSubscription s = c.SubscribeAsync("foo", eh)) { lock (mu) { c.Publish("foo", "bar", myStr); c.Flush(); Monitor.Wait(mu, 1000); } } } }
public void TestSubDelTaskCountSlowConsumer() { AutoResetEvent errorEv = new AutoResetEvent(false); var opts = utils.DefaultTestOptions; opts.SubscriberDeliveryTaskCount = 1; opts.SubChannelLength = 10; opts.AsyncErrorEventHandler = (obj, args) => { errorEv.Set(); }; using (new NATSServer()) { using (IConnection c = new ConnectionFactory().CreateConnection(opts)) { AutoResetEvent cbEv = new AutoResetEvent(false); using (var s = c.SubscribeAsync("foo", (obj, args) => { cbEv.WaitOne(); })) { for (int i = 0; i < opts.SubChannelLength * 2; i++) { c.Publish("foo", null); } c.Flush(); // make sure we hit the error. Assert.True(errorEv.WaitOne(10000)); // unblock the callback. cbEv.Set(); } } } }
public void TestSubDelTaskCountScaling() { int COUNT = 20000; var opts = utils.DefaultTestOptions; opts.SubscriberDeliveryTaskCount = 20; using (new NATSServer()) { using (IConnection c = new ConnectionFactory().CreateConnection(opts)) { long recvCount = 0; var subs = new List<IAsyncSubscription>(); EventHandler<MsgHandlerEventArgs> eh = (obj, args) => { Interlocked.Increment(ref recvCount); }; for (int i = 0; i < COUNT; i++) { subs.Add(c.SubscribeAsync("foo", eh)); } c.Publish("foo", null); c.Flush(); while (Interlocked.Read(ref recvCount) != (COUNT)) { Thread.Sleep(100); } // ensure we are not creating a thread per subscriber. Assert.True(Process.GetCurrentProcess().Threads.Count < 500); subs.ForEach((s) => { s.Unsubscribe(); }); } } }
public void TestSubDelTaskCountReconnect() { bool disconnected = false; AutoResetEvent reconnectEv = new AutoResetEvent(false); var opts = utils.DefaultTestOptions; opts.SubscriberDeliveryTaskCount = 2; opts.DisconnectedEventHandler = (obj, args) => { disconnected = true;}; opts.ReconnectedEventHandler = (obj, args) => { reconnectEv.Set(); }; using (var server = new NATSServer()) { using (IConnection c = new ConnectionFactory().CreateConnection(opts)) { long received = 0; int max = 10; AutoResetEvent ev = new AutoResetEvent(false); using (var s = c.SubscribeAsync("foo", (obj, args) => { received++; if (received == max) ev.Set(); })) { for (int i = 0; i < max / 2; i++) { c.Publish("foo", null); } c.Flush(); // bounce the server, we should reconnect, then // be able to receive messages. server.Bounce(100); Assert.True(reconnectEv.WaitOne(20000)); Assert.True(disconnected); for (int i = 0; i < max / 2; i++) { c.Publish("foo", null); } c.Flush(); Assert.True(ev.WaitOne(10000)); Assert.True(received == max); } } } }
public void TestRequestNoBody() { using (IConnection c = new ConnectionFactory().CreateConnection()) { using (IAsyncSubscription s = c.SubscribeAsync("foo")) { byte[] response = Encoding.UTF8.GetBytes("I will help you."); s.MessageHandler += (sender, args) => { c.Publish(args.Message.Reply, response); }; s.Start(); Msg m = c.Request("foo", null, 50000); if (!compare(m.Data, response)) { Assert.Fail("Response isn't valid"); } } } }
public void TestAsyncSubscribe() { using (IConnection c = new ConnectionFactory().CreateConnection()) { using (IAsyncSubscription s = c.SubscribeAsync("foo")) { asyncSub = s; s.MessageHandler += CheckReceivedAndValidHandler; s.Start(); lock (mu) { received = false; c.Publish("foo", omsg); c.Flush(); Monitor.Wait(mu, 30000); } if (!received) Assert.Fail("Did not receive message."); } } }
public void TestSendAndRecv() { using (IConnection c = new ConnectionFactory().CreateConnection()) { using (IAsyncSubscription s = c.SubscribeAsync("foo")) { int received = 0; int count = 1000; s.MessageHandler += (sender, args) => { Interlocked.Increment(ref received); }; s.Start(); for (int i = 0; i < count; i++) { c.Publish("foo", null); } c.Flush(); Thread.Sleep(500); if (received != count) { Assert.Fail("Received ({0}) != count ({1})", received, count); } } } }
public void TestAsyncErrHandler() { Object subLock = new Object(); object testLock = new Object(); IAsyncSubscription s; Options opts = ConnectionFactory.GetDefaultOptions(); opts.SubChannelLength = 10; bool handledError = false; using (IConnection c = new ConnectionFactory().CreateConnection(opts)) { using (s = c.SubscribeAsync("foo")) { opts.AsyncErrorEventHandler = (sender, args) => { lock (subLock) { if (handledError) return; handledError = true; Assert.IsTrue(args.Subscription == s); System.Console.WriteLine("Expected Error: " + args.Error); Assert.IsTrue(args.Error.Contains("Slow")); // release the subscriber Monitor.Pulse(subLock); } // release the test lock (testLock) { Monitor.Pulse(testLock); } }; bool blockedOnSubscriber = false; s.MessageHandler += (sender, args) => { lock (subLock) { if (blockedOnSubscriber) return; Console.WriteLine("Subscriber Waiting...."); Assert.IsTrue(Monitor.Wait(subLock, 10000)); Console.WriteLine("Subscriber done."); blockedOnSubscriber = true; } }; s.Start(); lock(testLock) { for (int i = 0; i < (opts.SubChannelLength + 100); i++) { c.Publish("foo", null); } c.Flush(1000); Assert.IsTrue(Monitor.Wait(testLock, 1000)); } } } }
public void TestUnsubscribe() { int count = 0; int max = 20; using (IConnection c = new ConnectionFactory().CreateConnection()) { using (IAsyncSubscription s = c.SubscribeAsync("foo")) { Boolean unsubscribed = false; asyncSub = s; //s.MessageHandler += UnsubscribeAfterCount; s.MessageHandler += (sender, args) => { count++; System.Console.WriteLine("Count = {0}", count); if (count == max) { asyncSub.Unsubscribe(); lock (mu) { unsubscribed = true; Monitor.Pulse(mu); } } }; s.Start(); max = 20; for (int i = 0; i < max; i++) { c.Publish("foo", null, null); } Thread.Sleep(100); c.Flush(); lock (mu) { if (!unsubscribed) { Monitor.Wait(mu, 5000); } } } if (count != max) Assert.Fail("Received wrong # of messages after unsubscribe: {0} vs {1}", count, max); } }
public void TestSubDelTaskCountAutoUnsub() { var opts = utils.DefaultTestOptions; opts.SubscriberDeliveryTaskCount = 2; using (new NATSServer()) { using (IConnection c = new ConnectionFactory().CreateConnection(opts)) { long received = 0; int max = 10; AutoResetEvent ev = new AutoResetEvent(false); using (var s = c.SubscribeAsync("foo", (obj, args) => { received++; if (received > max) ev.Set(); })) { s.AutoUnsubscribe(max); for (int i = 0; i < max * 2; i++) { c.Publish("foo", null); } c.Flush(); // event should never fire. Assert.False(ev.WaitOne(500)); // double check Assert.True(received == max); Assert.False(s.IsValid); } } } }
public void TestSlowAsyncSubscriber() { Options opts = ConnectionFactory.GetDefaultOptions(); opts.SubChannelLength = 10; using (IConnection c = new ConnectionFactory().CreateConnection(opts)) { using (IAsyncSubscription s = c.SubscribeAsync("foo")) { Object mu = new Object(); s.MessageHandler += (sender, args) => { lock (mu) { Console.WriteLine("Subscriber Waiting...."); Assert.IsTrue(Monitor.Wait(mu, 20000)); Console.WriteLine("Subscriber done."); } }; s.Start(); for (int i = 0; i < (opts.SubChannelLength + 100); i++) { c.Publish("foo", null); } int flushTimeout = 1000; Stopwatch sw = new Stopwatch(); sw.Start(); bool flushFailed = false; try { c.Flush(flushTimeout); } catch (Exception) { flushFailed = true; } sw.Stop(); lock (mu) { Monitor.Pulse(mu); } if (sw.ElapsedMilliseconds < flushTimeout) { Assert.Fail("elapsed ({0}) < timeout ({1})", sw.ElapsedMilliseconds, flushTimeout); } Assert.IsTrue(flushFailed); } } }
public void TestFlushInHandler() { using (IConnection c = new ConnectionFactory().CreateConnection()) { using (IAsyncSubscription s = c.SubscribeAsync("foo")) { byte[] response = Encoding.UTF8.GetBytes("I will help you."); s.MessageHandler += (sender, args) => { try { c.Flush(); System.Console.WriteLine("Success."); } catch (Exception e) { Assert.Fail("Unexpected exception: " + e); } lock (mu) { Monitor.Pulse(mu); } }; s.Start(); lock (mu) { c.Publish("foo", Encoding.UTF8.GetBytes("Hello")); Monitor.Wait(mu); } } } }
public void TestAsyncSubscriberStarvation() { Object waitCond = new Object(); using (IConnection c = new ConnectionFactory().CreateConnection()) { using (IAsyncSubscription helper = c.SubscribeAsync("helper"), start = c.SubscribeAsync("start")) { helper.MessageHandler += (sender, arg) => { System.Console.WriteLine("Helper"); c.Publish(arg.Message.Reply, Encoding.UTF8.GetBytes("Hello")); }; helper.Start(); start.MessageHandler += (sender, arg) => { System.Console.WriteLine("Responsder"); string responseIB = c.NewInbox(); IAsyncSubscription ia = c.SubscribeAsync(responseIB); ia.MessageHandler += (iSender, iArgs) => { System.Console.WriteLine("Internal subscriber."); lock (waitCond) { Monitor.Pulse(waitCond); } }; ia.Start(); c.Publish("helper", responseIB, Encoding.UTF8.GetBytes("Help me!")); }; start.Start(); c.Publish("start", Encoding.UTF8.GetBytes("Begin")); c.Flush(); lock (waitCond) { Assert.IsTrue(Monitor.Wait(waitCond, 2000)); } } } }
public void TestAsyncErrHandler() { object subLock = new object(); object testLock = new object(); IAsyncSubscription s; Options opts = utils.DefaultTestOptions; opts.SubChannelLength = 10; bool handledError = false; using (new NATSServer()) { using (IConnection c = new ConnectionFactory().CreateConnection(opts)) { using (s = c.SubscribeAsync("foo")) { c.Opts.AsyncErrorEventHandler = (sender, args) => { lock (subLock) { if (handledError) return; handledError = true; Assert.True(args.Subscription == s); Assert.True(args.Error.Contains("Slow")); // release the subscriber Monitor.Pulse(subLock); } // release the test lock (testLock) { Monitor.Pulse(testLock); } }; bool blockedOnSubscriber = false; s.MessageHandler += (sender, args) => { lock (subLock) { if (blockedOnSubscriber) return; Assert.True(Monitor.Wait(subLock, 500)); blockedOnSubscriber = true; } }; s.Start(); lock (testLock) { for (int i = 0; i < (opts.SubChannelLength + 100); i++) { c.Publish("foo", null); } try { c.Flush(1000); } catch (Exception) { // ignore - we're testing the error handler, not flush. } Assert.True(Monitor.Wait(testLock, 1000)); } } } } }
public void TestAsyncSubscribersOnClose() { /// basically tests if the subscriber sub channel gets /// cleared on a close. Object waitCond = new Object(); int callbacks = 0; using (IConnection c = new ConnectionFactory().CreateConnection()) { using (IAsyncSubscription s = c.SubscribeAsync("foo")) { s.MessageHandler += (sender, args) => { callbacks++; lock (waitCond) { Monitor.Wait(waitCond); } }; s.Start(); for (int i = 0; i < 10; i++) { c.Publish("foo", null); } c.Flush(); Thread.Sleep(500); c.Close(); lock (waitCond) { Monitor.Pulse(waitCond); } Thread.Sleep(500); Assert.IsTrue(callbacks == 1); } } }
public void TestEncodedInvalidObjectSerialization() { using (IEncodedConnection c = new ConnectionFactory().CreateEncodedConnection()) { String myStr = "value"; Object mu = new Object(); bool hitException = false; EventHandler<EncodedMessageEventArgs> eh = (sender, args) => { // Ensure we blow up in the cast try { Exception invalid = (Exception)args.ReceivedObject; } catch (Exception e) { hitException = true; System.Console.WriteLine("Expected exception: " + e.Message); } Assert.IsTrue(hitException); lock (mu) { Monitor.Pulse(mu); } }; using (IAsyncSubscription s = c.SubscribeAsync("foo", eh)) { lock (mu) { c.Publish("foo", myStr); c.Flush(); Monitor.Wait(mu, 1000); } } } }