public void TestCloseDisconnectedHandler()
{
bool disconnected = false;
Object mu = new Object();
Options o = ConnectionFactory.GetDefaultOptions();
o.AllowReconnect = false;
o.DisconnectedEventHandler += (sender, args) => {
lock (mu)
{
disconnected = true;
Monitor.Pulse(mu);
}
};
IConnection c = new ConnectionFactory().CreateConnection(o);
lock (mu)
{
c.Close();
Monitor.Wait(mu, 20000);
}
Assert.IsTrue(disconnected);
// now test using.
disconnected = false;
lock (mu)
{
using (c = new ConnectionFactory().CreateConnection(o)) { };
Monitor.Wait(mu);
}
Assert.IsTrue(disconnected);
}
private void connectAndFail(String url)
{
try
{
System.Console.WriteLine("Trying: " + url);
hitDisconnect = 0;
Options opts = ConnectionFactory.GetDefaultOptions();
opts.Url = url;
opts.DisconnectedEventHandler += handleDisconnect;
IConnection c = new ConnectionFactory().CreateConnection(url);
Assert.Fail("Expected a failure; did not receive one");
c.Close();
}
catch (Exception e)
{
if (e.Message.Contains("Authorization"))
{
System.Console.WriteLine("Success with expected failure: " + e.Message);
}
else
{
Assert.Fail("Unexpected exception thrown: " + e);
}
}
finally
{
if (hitDisconnect > 0)
Assert.Fail("The disconnect event handler was incorrectly invoked.");
}
}
public void TestConnectionStatus()
{
IConnection c = new ConnectionFactory().CreateConnection();
Assert.AreEqual(ConnState.CONNECTED, c.State);
c.Close();
Assert.AreEqual(ConnState.CLOSED, c.State);
}
public void TestAuthSuccess()
{
using (NATSServer s = util.CreateServerWithConfig(TestContext, "auth_1222.conf"))
{
IConnection c = new ConnectionFactory().CreateConnection("nats://*****:*****@localhost:1222");
c.Close();
}
}
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));
}
private bool isNatsServerRunning()
{
try
{
IConnection c = new NATS.Client.ConnectionFactory().CreateConnection();
c.Close();
return(true);
}
catch (Exception)
{
return(false);
}
}
public void TestMultipleClose()
{
IConnection c = new ConnectionFactory().CreateConnection();
Task[] tasks = new Task[10];
for (int i = 0; i < 10; i++)
{
tasks[i] = new Task(() => { c.Close(); });
tasks[i].Start();
}
Task.WaitAll(tasks);
}
public void TestCloseHandler()
{
bool closed = false;
Options o = ConnectionFactory.GetDefaultOptions();
o.ClosedEventHandler += (sender, args) => { closed = true; };
IConnection c = new ConnectionFactory().CreateConnection(o);
c.Close();
Assert.IsTrue(closed);
// now test using.
closed = false;
using (c = new ConnectionFactory().CreateConnection(o)) { };
Assert.IsTrue(closed);
}
public void TestConnectedServer()
{
IConnection c = new ConnectionFactory().CreateConnection();
string u = c.ConnectedUrl;
if (string.IsNullOrWhiteSpace(u))
Assert.Fail("Invalid connected url {0}.", u);
if (!Defaults.Url.Equals(u))
Assert.Fail("Invalid connected url {0}.", u);
c.Close();
u = c.ConnectedUrl;
if (u != null)
Assert.Fail("Url is not null after connection is closed.");
}
public NATSServer(bool verify)
{
createProcessStartInfo();
p = Process.Start(psInfo);
if (verify)
{
for (int i = 0; i < 10; i++)
{
try
{
var c = new ConnectionFactory().CreateConnection();
c.Close();
break;
}
catch
{
Thread.Sleep(i * 250);
}
}
}
}
public void TestReleaseFlush()
{
IConnection c = new ConnectionFactory().CreateConnection();
for (int i = 0; i < 1000; i++)
{
c.Publish("foo", Encoding.UTF8.GetBytes("Hello"));
}
new Task(() => { c.Close(); }).Start();
c.Flush();
}
public void TestCloseAndDispose()
{
using (IConnection c = new ConnectionFactory().CreateConnection())
{
c.Close();
}
}
public void TestClose()
{
Options opts = ConnectionFactory.GetDefaultOptions();
opts.Url = "nats://localhost:22222";
opts.AllowReconnect = true;
opts.MaxReconnect = 60;
using (NATSServer s1 = utils.CreateServerOnPort(22222))
{
IConnection c = new ConnectionFactory().CreateConnection(opts);
Assert.IsFalse(c.IsClosed());
s1.Shutdown();
Thread.Sleep(100);
if (c.IsClosed())
{
Assert.Fail("Invalid state, expecting not closed, received: "
+ c.State.ToString());
}
using (NATSServer s2 = utils.CreateServerOnPort(22222))
{
Thread.Sleep(1000);
Assert.IsFalse(c.IsClosed());
c.Close();
Assert.IsTrue(c.IsClosed());
}
}
}
private void connectAndFail(String url)
{
try
{
hitDisconnect = 0;
Options opts = util.DefaultTestOptions;
opts.Url = url;
opts.DisconnectedEventHandler += handleDisconnect;
IConnection c = new ConnectionFactory().CreateConnection(url);
Assert.True(false, "Expected a failure; did not receive one");
c.Close();
}
catch (Exception e)
{
Assert.True(e.Message.Contains("Authorization"));
}
finally
{
Assert.False(hitDisconnect > 0, "The disconnect event handler was incorrectly invoked.");
}
}
public void TestServerStopDisconnectedHandler()
{
bool disconnected = false;
Object mu = new Object();
Options o = ConnectionFactory.GetDefaultOptions();
o.AllowReconnect = false;
o.DisconnectedEventHandler += (sender, args) =>
{
lock (mu)
{
disconnected = true;
Monitor.Pulse(mu);
}
};
IConnection c = new ConnectionFactory().CreateConnection(o);
lock (mu)
{
utils.bounceDefaultServer(1000);
Monitor.Wait(mu);
}
c.Close();
Assert.IsTrue(disconnected);
}
public void TestIsReconnectingAndStatus()
{
bool disconnected = false;
object disconnectedLock = new object();
bool reconnected = false;
object reconnectedLock = new object();
IConnection c = null;
Options opts = utils.DefaultTestOptions;
opts.Url = "nats://localhost:22222";
opts.AllowReconnect = true;
opts.MaxReconnect = 10000;
opts.ReconnectWait = 100;
opts.DisconnectedEventHandler += (sender, args) =>
{
lock (disconnectedLock)
{
disconnected = true;
Monitor.Pulse(disconnectedLock);
}
};
opts.ReconnectedEventHandler += (sender, args) =>
{
lock (reconnectedLock)
{
reconnected = true;
Monitor.Pulse(reconnectedLock);
}
};
using (NATSServer s = utils.CreateServerOnPort(22222))
{
c = new ConnectionFactory().CreateConnection(opts);
Assert.True(c.State == ConnState.CONNECTED);
Assert.True(c.IsReconnecting() == false);
}
// server stops here...
lock (disconnectedLock)
{
if (!disconnected)
Assert.True(Monitor.Wait(disconnectedLock, 10000));
}
Assert.True(c.State == ConnState.RECONNECTING);
Assert.True(c.IsReconnecting() == true);
// restart the server
using (NATSServer s = utils.CreateServerOnPort(22222))
{
lock (reconnectedLock)
{
// may have reconnected, if not, wait
if (!reconnected)
Assert.True(Monitor.Wait(reconnectedLock, 10000));
}
Assert.True(c.IsReconnecting() == false);
Assert.True(c.State == ConnState.CONNECTED);
c.Close();
}
Assert.True(c.IsReconnecting() == false);
Assert.True(c.State == ConnState.CLOSED);
}
public void TestCloseSubRelease()
{
using (IConnection c = new ConnectionFactory().CreateConnection())
{
using (ISyncSubscription s = c.SubscribeSync("foo"))
{
Stopwatch sw = new Stopwatch();
sw.Start();
try
{
new Task(() => { Thread.Sleep(100); c.Close(); }).Start();
s.NextMessage(10000);
}
catch (Exception) { /* ignore */ }
sw.Stop();
Assert.IsTrue(sw.ElapsedMilliseconds < 10000);
}
}
}
public void TestClose()
{
Options opts = utils.DefaultTestOptions;
opts.Url = "nats://localhost:22222";
opts.AllowReconnect = true;
opts.MaxReconnect = 60;
using (NATSServer s1 = utils.CreateServerOnPort(22222))
{
IConnection c = new ConnectionFactory().CreateConnection(opts);
Assert.False(c.IsClosed());
s1.Shutdown();
Thread.Sleep(100);
Assert.False(c.IsClosed(), string.Format("Invalid state, expecting not closed, received: {0}", c.State));
using (NATSServer s2 = utils.CreateServerOnPort(22222))
{
Thread.Sleep(1000);
Assert.False(c.IsClosed());
c.Close();
Assert.True(c.IsClosed());
}
}
}
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 TestConnectVerbose()
{
Options o = ConnectionFactory.GetDefaultOptions();
o.Verbose = true;
IConnection c = new ConnectionFactory().CreateConnection(o);
c.Close();
}
