public void TC005_PublishWithoudPayload()
{
bool errorThrown = false;
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
natsClient.Publish("foo");
natsClient.Publish("foo", null, "hello");
natsClient.Publish("foo", null, "hello", "reply");
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
}
public void TC006_PublishNil()
{
bool errorThrown = false;
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
// todo: vladi: check to see if nil in Ruby evaluates to boolean true
natsClient.Publish(null);
natsClient.Publish(null, null, "hello");
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
}
public void TC015_MultipleResponseCallback()
{
bool errorThrown = false;
List <int> expected = new List <int>();
List <int> response = new List <int>();
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
SimpleCallback[] delegates = new SimpleCallback[] {
delegate() { response.Add(0); },
delegate() { response.Add(1); },
delegate() { response.Add(2); },
delegate() { response.Add(3); },
delegate() { response.Add(4); },
delegate() { response.Add(5); },
delegate() { response.Add(6); },
delegate() { response.Add(7); },
delegate() { response.Add(8); },
delegate() { response.Add(9); },
delegate() { response.Add(10); },
delegate() { response.Add(11); },
delegate() { response.Add(12); },
delegate() { response.Add(13); },
delegate() { response.Add(14); }
};
for (int i = 0; i < 15; i++)
{
expected.Add(i);
natsClient.Publish("foo", delegates[i]);
}
natsClient.Publish("foo", delegate()
{
resetEvent.Set();
});
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
for (int i = 0; i < 15; i++)
{
Assert.AreEqual(expected[i], response[i]);
}
}
public void TC023_ReciveGiantMessageForSubscription()
{
bool errorThrown = false;
string receivedMessage = "";
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
natsClient.Subscribe("foo", delegate(string msg, string reply, string subject)
{
receivedMessage = msg;
resetEvent.Set();
});
ASCIIEncoding ascii = new ASCIIEncoding();
natsClient.Publish("foo", null, ascii.GetString(new byte[90000]));
resetEvent.WaitOne(10000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
Assert.AreEqual(receivedMessage.Length, 90000);
}
public void TC014_PublishCallback()
{
bool errorThrown = false;
bool done = false;
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
natsClient.Publish("foo", delegate()
{
done = true;
resetEvent.Set();
});
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
Assert.IsTrue(done);
}
public void TC011_ReciveMessageIfWildcardSubscription()
{
string errorThrown = null;
string receivedMessage = "";
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = args.Message == null ? String.Empty : args.Message;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
// todo: vladi: if not testing agains an empty server, this subscription may fail
natsClient.Subscribe("*", delegate(string msg, string reply, string subject)
{
receivedMessage = msg;
resetEvent.Set();
});
natsClient.Publish("foo", null, "xxx");
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsTrue(errorThrown == null, errorThrown);
Assert.AreEqual(receivedMessage, "xxx");
}
public void TC010_ReciveEmptyMessage()
{
bool errorThrown = false;
string receivedMessage = "xxx";
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
natsClient.Subscribe("foo", delegate(string msg, string reply, string subject)
{
receivedMessage = msg;
resetEvent.Set();
});
natsClient.Publish("foo", null, "");
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
Assert.AreEqual(receivedMessage, "");
}
public void TC012_RecieveMessageOnUnsubscription()
{
bool errorThrown = false;
int receivedCount = 0;
object receivedCountLock = new object();
int sid = 0;
IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor));
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
});
natsClient.Start(natsEndpoint);
ManualResetEvent mre = new ManualResetEvent(false);
sid = natsClient.Subscribe("foo", delegate(string msg, string reply, string subject)
{
lock (receivedCountLock)
{
receivedCount++;
if (receivedCount == 2)
{
natsClient.Unsubscribe(sid);
mre.Set();
}
}
});
natsClient.Publish("foo", () =>
{
natsClient.Publish("foo", () =>
{
mre.WaitOne();
natsClient.Publish("foo", () => { }, "xxx");
}, "xxx");
}, "xxx");
Thread.Sleep(5000);
natsClient.Close();
Assert.IsFalse(errorThrown);
Assert.AreEqual(2, receivedCount);
}
public void TC018_UnsubscribeWithinBlocks()
{
bool errorThrown = false;
int receivedMessageCount = 0;
int sid = 0;
AutoResetEvent resetEvent = new AutoResetEvent(false);
object receivedMessageCountLock = new object();
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
sid = natsClient.Subscribe("foo", delegate(string msg, string reply, string subject)
{
lock (receivedMessageCountLock)
{
receivedMessageCount++;
natsClient.Unsubscribe(sid);
}
});
natsClient.Publish("foo", delegate()
{
natsClient.Publish("foo", delegate()
{
resetEvent.Set();
}, "xxx");
}, "xxx");
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
Assert.AreEqual(1, receivedMessageCount);
}
public void TC021_PublishThreadSafe()
{
bool errorThrown = false;
object locker = new object();
int callbackNr = 0;
int sid = 0;
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
});
for (int i = 0; i < 40; i++)
{
string subject = Guid.NewGuid().ToString();
sid = natsClient.Subscribe(subject, delegate(string msg, string reply, string subj)
{
lock (locker)
{
callbackNr++;
}
});
Thread workerThread = new Thread(new ParameterizedThreadStart(delegate(object data)
{
natsClient.Publish((string)data);
}));
workerThread.Start(subject);
}
natsClient.Start(natsEndpoint);
while (callbackNr != 40 || errorThrown)
{
Thread.Sleep(1000);
}
natsClient.Close();
}
Assert.IsFalse(errorThrown);
}
public void TC004_CheckServerError()
{
bool errorThrown = false;
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.Pedantic = true;
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
natsClient.Unsubscribe(10000);
natsClient.Publish("done");
resetEvent.WaitOne(10000);
natsClient.Close();
}
Assert.IsTrue(errorThrown);
}
public void TC017_RquestReplyMultipleConnections()
{
bool errorThrown = false;
string receivedMessage = "";
string receivedReply = "";
AutoResetEvent resetEvent = new AutoResetEvent(false);
using (IReactor natsClient = ReactorFactory.GetReactor(typeof(Reactor)))
{
natsClient.OnError += new EventHandler <ReactorErrorEventArgs>(delegate(object sender, ReactorErrorEventArgs args)
{
errorThrown = true;
resetEvent.Set();
});
natsClient.Start(natsEndpoint);
natsClient.Subscribe("need_help", delegate(string msg, string reply, string subject)
{
receivedMessage = msg;
natsClient.Publish(reply, null, "help");
});
// todo: vladi: this doesn't work if no message is sent.
natsClient.Request("need_help", null, delegate(string msg, string reply, string subject)
{
receivedReply = msg;
resetEvent.Set();
}, "yyy");
resetEvent.WaitOne(5000);
natsClient.Close();
}
Assert.IsFalse(errorThrown);
Assert.AreEqual(receivedMessage, "yyy");
Assert.AreEqual(receivedReply, "help");
}
