public async Task CanPublishAndReceiveMultipleMessagesOnChannel()
{
var expected = "CanPublishAndReceiveOnChannel";
using (var socketConnection = new SocketConnection(TestsSetup.Host, TestsSetup.Port, Scheduler.Immediate))
{
using (var publisherConnection = new SocketConnection(TestsSetup.Host, TestsSetup.Port, Scheduler.Immediate))
{
var subscriber = socketConnection.AsSubscriber();
var publisher = publisherConnection.AsPublisher();
var matchedReplies = 0;
var tcs = new TaskCompletionSource<bool>();
var expectedMessagesCount = 512;
var messagesChannel = await subscriber.Subscribe("channel1");
messagesChannel.Subscribe(message =>
{
if (string.Compare(message.Content, expected, StringComparison.InvariantCultureIgnoreCase) == 0)
matchedReplies += 1;
if (matchedReplies == expectedMessagesCount)
tcs.SetResult(true);
});
foreach (var once in Enumerable.Repeat(Unit.Default, expectedMessagesCount))
{
var result = await publisher.PublishMessage("channel1", expected);
}
await Task.WhenAny(Task.Delay(1000), tcs.Task);
Assert.AreEqual(expectedMessagesCount, matchedReplies);
}
}
}
async void Subscribe()
{
var connection = new SocketConnection("127.0.0.1", 4525, Scheduler.Immediate);
var currentSyncronizationContext = SynchronizationContext.Current;
var subscriber = connection.AsSubscriber();
try
{
var channelMessagesReceived = 0;
var channelsSubscription = await subscriber.Subscribe("alert1");
channelsSubscription
.Buffer(TimeSpan.FromSeconds(1))
.ObserveOn(currentSyncronizationContext)
.Subscribe(messages =>
{
channelMessagesReceived += messages.Count;
channelMessages.Text = channelMessagesReceived.ToString();
//listBoxAlerts.Items.Add(new ListBoxItem { Content = message.ChannelName + ":" + message.Content });
},
ex =>
{
MessageBox.Show(ex.ToString());
});
var patternChannelMessagesReceived = 0;
var channelsPatternSubscription = await subscriber.PSubscribe("alert*");
channelsPatternSubscription
.Buffer(TimeSpan.FromSeconds(1))
.ObserveOn(currentSyncronizationContext)
.Subscribe(messages =>
{
patternChannelMessagesReceived += messages.Count;
channelPatternMessages.Text = patternChannelMessagesReceived.ToString();
//listBoxAlerts.Items.Add(new ListBoxItem { Content = message.Pattern + ":" + message.Content });
},
ex =>
{
MessageBox.Show(ex.ToString());
});
}
catch (AggregateException ex)
{
MessageBox.Show(ex.ToString());
}
}
public async Task CanPublishAndReceiveOnChannel()
{
var expected = "CanPublishAndReceiveOnChannel";
using (var socketConnection = new SocketConnection(TestsSetup.Host, TestsSetup.Port, Scheduler.Immediate))
{
using (var publisherConnection = new SocketConnection(TestsSetup.Host, TestsSetup.Port, Scheduler.Immediate))
{
var subscriber = socketConnection.AsSubscriber();
var publisher = publisherConnection.AsPublisher();
var messagesChannel = await subscriber.Subscribe("channel1");
var replaySubject = new ReplaySubject<string>();
messagesChannel.Take(1).Select(x => x.Content).Subscribe(replaySubject);
await publisher.PublishMessage("channel1", expected);
var result = await replaySubject.FirstAsync();
Assert.AreEqual(expected, result);
}
}
}
public async Task ChannelsObservablesDontThrowExceptionWhenSocketConnectionIsDisposed()
{
var subscriptionCompleted = new TaskCompletionSource<bool>();
using (var socketConnection = new SocketConnection(TestsSetup.Host, TestsSetup.Port, Scheduler.Immediate))
{
var subscriber = socketConnection.AsSubscriber();
var channelPatternMessages = await subscriber.PSubscribe("channel*");
channelPatternMessages.Subscribe(
_ => { },
ex => {
subscriptionCompleted.SetException(ex);
},
() => { subscriptionCompleted.SetResult(true); });
}
try
{
var completed = await subscriptionCompleted.Task;
Assert.IsTrue(completed);
}
catch (AggregateException ex)
{
if (ex.InnerException is RedisException)
{
throw new Exception(((RedisException)ex.InnerException).SocketError.ToString());
}
throw ex.InnerException;
}
}