public void should_throw_an_exception_when_given_an_empty_string_for_a_channel_name_async()
{
var reset = new AutoResetEvent(false);
var pusherServer = ClientServerFactory.CreateServer();
ArgumentException caughtException = null;
IGetResult <PresenceChannelMessage> result = null;
try
{
pusherServer.FetchUsersFromPresenceChannelAsync <PresenceChannelMessage>(string.Empty, getResult =>
{
result = getResult;
reset.Set();
});
}
catch (ArgumentException ex)
{
caughtException = ex;
}
StringAssert.IsMatch("channelName cannot be null or empty", caughtException.Message);
}
public void Should_get_an_empty_list_of_subscribed_users_when_using_the_correct_channel_name_and_no_users_are_subscribed()
{
var reset = new AutoResetEvent(false);
string channelName = "presence-test-channel2";
var pusherServer = ClientServerFactory.CreateServer();
var result = pusherServer.FetchUsersFromPresenceChannel <PresenceChannelMessage>(channelName);
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
Assert.AreEqual(0, result.Data.Users.Length);
}
public void should_return_bad_request_using_an_incorrect_channel_name_and_users_are_subscribed()
{
var reset = new AutoResetEvent(false);
string channelName = "presence-test-channel3";
var pusherServer = ClientServerFactory.CreateServer();
var pusherClient = ClientServerFactory.CreateClient(pusherServer, reset, channelName);
var result = pusherServer.FetchUsersFromPresenceChannel <PresenceChannelMessage>("test-channel");
Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
}
public async void It_should_return_the_state_asynchronously_When_given_a_channel_name_that_exists_and_no_info_object_is_provided()
{
var reset = new AutoResetEvent(false);
var channelName = "presence-state-channel-async-1";
var pusherServer = ClientServerFactory.CreateServer();
var pusherClient = ClientServerFactory.CreateClient(pusherServer, reset, channelName);
var response = await pusherServer.FetchStateForChannelAsync <ChannelStateMessage>(channelName);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.IsTrue(response.Data.Occupied);
}
public async void It_should_return_the_state_asynchronously_When_given_a_channel_name_that_exists_and_no_info_object_is_provided()
{
var reset = new AutoResetEvent(false);
var channelName = "presence-multiple-state-channel-async-3";
var pusherServer = ClientServerFactory.CreateServer();
var pusherClient = ClientServerFactory.CreateClient(pusherServer, reset, channelName);
var result = await pusherServer.FetchStateForChannelsAsync <object>();
reset.Set();
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
}
public async Task should_return_bad_request_asynchronously_using_an_incorrect_channel_name_and_users_are_subscribed()
{
var reset = new AutoResetEvent(false);
string channelName = "presence-test-channel-async-3";
var pusherServer = ClientServerFactory.CreateServer();
var pusherClient = ClientServerFactory.CreateClient(pusherServer, reset, channelName);
IGetResult <PresenceChannelMessage> result = await pusherServer.FetchUsersFromPresenceChannelAsync <PresenceChannelMessage>("test-channel-async");
reset.Set();
Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
}
public async void It_should_not_return_the_state_based_asynchronously_When_given_a_channel_name_that_exists_an_bad_attributes()
{
var reset = new AutoResetEvent(false);
var channelName = "presence-state-channel-async-2";
var pusherServer = ClientServerFactory.CreateServer();
var pusherClient = ClientServerFactory.CreateClient(pusherServer, reset, channelName);
var info = new { info = "does-not-exist" };
var result = await pusherServer.FetchStateForChannelAsync <ChannelStateMessage>(channelName, info);
Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
StringAssert.IsMatch("info should be a comma separated list of attributes", result.Body);
}
public void It_should_return_the_state_When_given_a_channel_name_that_exists()
{
AutoResetEvent reset = new AutoResetEvent(false);
string channelName = "presence-multiple-state-channel3";
var pusherServer = ClientServerFactory.CreateServer();
var pusherClient = ClientServerFactory.CreateClient(pusherServer, reset, channelName);
var info = new { info = "user_count", filter_by_prefix = "presence-" };
var result = pusherServer.FetchStateForChannels <object>(info);
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
Assert.AreEqual(1, ((((Dictionary <string, object>)result.Data)["channels"] as Dictionary <string, object>)["presence-multiple-state-channel3"] as Dictionary <string, object>)["user_count"]);
}
public async void It_should_return_the_state_asynchronously_When_given_a_channel_name_that_exists()
{
var channelName = "presence-state-channel-async-1";
var reset = new AutoResetEvent(false);
var pusherServer = ClientServerFactory.CreateServer();
var pusherClient = ClientServerFactory.CreateClient(pusherServer, reset, channelName);
var info = new { info = "user_count" };
var response = await pusherServer.FetchStateForChannelAsync <ChannelStateMessage>(channelName, info);
reset.Set();
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
Assert.AreEqual(1, response.Data.User_Count);
}
public void It_should_not_return_the_state_based_When_given_a_channel_name_that_exists_an_bad_attributes()
{
AutoResetEvent reset = new AutoResetEvent(false);
string channelName = "presence-multiple-state-channel4";
var pusherServer = ClientServerFactory.CreateServer();
var pusherClient = ClientServerFactory.CreateClient(pusherServer, reset, channelName);
var info = new { info = "does-not-exist" };
var result = pusherServer.FetchStateForChannels <object>(info);
Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
StringAssert.IsMatch("info should be a comma separated list of attributes", (result as GetResult <object>).OriginalContent);
}
public async Task Should_get_a_list_of_subscribed_users_asynchronously_when_using_the_correct_channel_name_and_users_are_subscribed()
{
var reset = new AutoResetEvent(false);
string channelName = "presence-test-channel-async-1";
var pusherServer = ClientServerFactory.CreateServer();
var pusherClient = ClientServerFactory.CreateClient(pusherServer, reset, channelName);
IGetResult <PresenceChannelMessage> result = await pusherServer.FetchUsersFromPresenceChannelAsync <PresenceChannelMessage>(channelName);
reset.Set();
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
Assert.AreEqual(1, result.Data.Users.Length);
Assert.AreEqual("Mr Pusher", result.Data.Users[0].Id);
}
public void should_throw_an_exception_when_given_an_empty_string_for_a_channel_name()
{
var pusherServer = ClientServerFactory.CreateServer();
ArgumentException caughtException = null;
try
{
pusherServer.FetchUsersFromPresenceChannel <PresenceChannelMessage>(string.Empty);
}
catch (ArgumentException ex)
{
caughtException = ex;
}
StringAssert.IsMatch("channelName cannot be null or empty", caughtException.Message);
}
public async void It_should_throw_an_exception_when_given_a_null_as_a_channel_name_async()
{
var pusherServer = ClientServerFactory.CreateServer();
var info = new { info = "user_count" };
ArgumentException caughtException = null;
try
{
var response = await pusherServer.FetchStateForChannelAsync <ChannelStateMessage>(null, info);
}
catch (ArgumentException ex)
{
caughtException = ex;
}
StringAssert.IsMatch("channelName cannot be null or empty", caughtException.Message);
}
public async void It_should_return_the_state_asynchronously_When_given_a_channel_name_that_exists()
{
var reset = new AutoResetEvent(false);
var channelName = "presence-multiple-state-channel-async-3";
var pusherServer = ClientServerFactory.CreateServer();
var pusherClient = ClientServerFactory.CreateClient(pusherServer, reset, channelName);
var info = new { info = "user_count", filter_by_prefix = "presence-" };
var result = await pusherServer.FetchStateForChannelsAsync <object>(info);
reset.Set();
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
Assert.AreEqual(1, ((Newtonsoft.Json.Linq.JValue)((result.Data as Newtonsoft.Json.Linq.JObject)["channels"]["presence-multiple-state-channel-async-3"]["user_count"])).Value);
}
public void Should_get_an_empty_list_of_subscribed_users_asynchronously_when_using_the_correct_channel_name_and_no_users_are_subscribed()
{
var reset = new AutoResetEvent(false);
string channelName = "presence-test-channel-async-2";
var pusherServer = ClientServerFactory.CreateServer();
IGetResult <PresenceChannelMessage> result = null;
pusherServer.FetchUsersFromPresenceChannelAsync <PresenceChannelMessage>(channelName, getResult =>
{
result = getResult;
reset.Set();
});
reset.WaitOne(TimeSpan.FromSeconds(30));
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
Assert.AreEqual(0, result.Data.Users.Length);
}
public void It_should_return_the_state_asynchronously_When_given_a_channel_name_that_exists_and_no_info_object_is_provided()
{
var reset = new AutoResetEvent(false);
var channelName = "presence-state-channel-async-1";
var pusherServer = ClientServerFactory.CreateServer();
var pusherClient = ClientServerFactory.CreateClient(pusherServer, reset, channelName);
IGetResult <ChannelStateMessage> result = null;
pusherServer.FetchStateForChannelAsync <ChannelStateMessage>(channelName, getResult =>
{
result = getResult;
reset.Set();
});
reset.WaitOne(TimeSpan.FromSeconds(30));
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
Assert.IsTrue(result.Data.Occupied);
}
public async Task should_throw_an_exception_when_given_an_empty_string_for_a_channel_name_async()
{
var reset = new AutoResetEvent(false);
var pusherServer = ClientServerFactory.CreateServer();
ArgumentException caughtException = null;
try
{
var response = await pusherServer.FetchUsersFromPresenceChannelAsync <PresenceChannelMessage>(string.Empty);
reset.Set();
}
catch (ArgumentException ex)
{
caughtException = ex;
}
Assert.IsNotNull(caughtException);
StringAssert.IsMatch("channelName cannot be null or empty", caughtException.Message);
}
public void It_should_throw_an_exception_when_given_an_empty_string_as_a_channel_name_async()
{
var pusherServer = ClientServerFactory.CreateServer();
var info = new { info = "user_count" };
ArgumentException caughtException = null;
IGetResult <ChannelStateMessage> result = null;
try
{
pusherServer.FetchStateForChannelAsync <ChannelStateMessage>(string.Empty, info, getResult =>
{
result = getResult;
});
}
catch (ArgumentException ex)
{
caughtException = ex;
}
StringAssert.IsMatch("channelName cannot be null or empty", caughtException.Message);
}
public void It_should_return_the_state_asynchronously_When_given_a_channel_name_that_exists()
{
var reset = new AutoResetEvent(false);
var channelName = "presence-multiple-state-channel-async-3";
var pusherServer = ClientServerFactory.CreateServer();
var pusherClient = ClientServerFactory.CreateClient(pusherServer, reset, channelName);
var info = new { info = "user_count", filter_by_prefix = "presence-" };
IGetResult <object> result = null;
pusherServer.FetchStateForChannelsAsync <object>(info, getResult =>
{
result = getResult;
reset.Set();
});
reset.WaitOne(TimeSpan.FromSeconds(30));
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
Assert.AreEqual(1, ((((Dictionary <string, object>)result.Data)["channels"] as Dictionary <string, object>)["presence-multiple-state-channel-async-3"] as Dictionary <string, object>)["user_count"]);
}
public void It_should_not_return_the_state_asynchronously_based_When_given_a_channel_name_that_exists_an_bad_attributes()
{
AutoResetEvent reset = new AutoResetEvent(false);
string channelName = "presence-multiple-state-channel-async-4";
var pusherServer = ClientServerFactory.CreateServer();
var pusherClient = ClientServerFactory.CreateClient(pusherServer, reset, channelName);
var info = new { info = "does-not-exist" };
IGetResult <object> result = null;
pusherServer.FetchStateForChannelsAsync <object>(info, getResult =>
{
result = getResult;
reset.Set();
});
reset.WaitOne(TimeSpan.FromSeconds(30));
Assert.AreEqual(HttpStatusCode.BadRequest, result.StatusCode);
StringAssert.IsMatch("info should be a comma separated list of attributes", (result as GetResult <object>).OriginalContent);
}
public void It_should_return_the_state_asynchronously_When_given_a_channel_name_that_exists()
{
var reset = new AutoResetEvent(false);
var channelName = "presence-state-channel-async-1";
var pusherServer = ClientServerFactory.CreateServer();
var pusherClient = ClientServerFactory.CreateClient(pusherServer, reset, channelName);
var info = new { info = "user_count" };
IGetResult <ChannelStateMessage> result = null;
pusherServer.FetchStateForChannelAsync <ChannelStateMessage>(channelName, info, getResult =>
{
result = getResult;
reset.Set();
});
reset.WaitOne(TimeSpan.FromSeconds(30));
Assert.AreEqual(HttpStatusCode.OK, result.StatusCode);
Assert.AreEqual(1, result.Data.User_Count);
}
