Skip to content

S
StackExchange.Redis
Commit eb3955b0 authored by Marc Gravell's avatar Marc Gravell
Browse files
Options

Migrate: pub/sub test suite

parent c002a00e
Hide whitespace changes
Inline Side-by-side
Showing with 238 additions and 226 deletions
MigratedBookSleeveTestSuite/PubSub.cs
View file @ eb3955b0
//using NUnit.Framework; using NUnit.Framework;
//using System.Threading; using System.Threading;
//using System.Text; using System.Text;
//using System; using System;
//using System.Diagnostics; using System.Diagnostics;
//using System.Threading.Tasks; using System.Threading.Tasks;
//using BookSleeve; using System.Collections.Generic;
//using System.Collections.Generic; using StackExchange.Redis;
//namespace Tests namespace Tests
//{ {
// [TestFixture] [TestFixture]
// public class PubSub // http://redis.io/commands#pubsub public class PubSub // http://redis.io/commands#pubsub
// { {
// [Test] [Test]
// public void TestPublishWithNoSubscribers() public void TestPublishWithNoSubscribers()
// { {
// using (var conn = Config.GetUnsecuredConnection()) using (var muxer = Config.GetUnsecuredConnection())
// { {
// Assert.AreEqual(0, conn.Wait(conn.Publish("channel", "message"))); var conn = muxer.GetSubscriber();
// } Assert.AreEqual(0, conn.Publish("channel", "message"));
// } }
}
// [Test] [Test]
// public void TestMassivePublishWithWithoutFlush_Local() public void TestMassivePublishWithWithoutFlush_Local()
// { {
// using (var conn = Config.GetUnsecuredConnection(waitForOpen: true)) using (var muxer = Config.GetUnsecuredConnection(waitForOpen: true))
// { {
// TestMassivePublishWithWithoutFlush(conn, "local"); var conn = muxer.GetSubscriber();
// } TestMassivePublish(conn, "local");
// } }
// [Test] }
// public void TestMassivePublishWithWithoutFlush_Remote() [Test]
// { public void TestMassivePublishWithWithoutFlush_Remote()
// using (var conn = Config.GetRemoteConnection(waitForOpen: true)) {
// { using (var muxer = Config.GetRemoteConnection(waitForOpen: true))
// TestMassivePublishWithWithoutFlush(conn, "remote"); {
// } var conn = muxer.GetSubscriber();
// } TestMassivePublish(conn, "remote");
}
}
// private void TestMassivePublishWithWithoutFlush(RedisConnection conn, string caption) private void TestMassivePublish(ISubscriber conn, string caption)
// { {
// const int loop = 100000; const int loop = 100000;
// GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced); GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
// GC.WaitForPendingFinalizers(); GC.WaitForPendingFinalizers();
// var tasks = new Task[loop]; var tasks = new Task[loop];
// var withFlush = Stopwatch.StartNew();
// for (int i = 0; i < loop; i++)
// tasks[i] = conn.Publish("foo", "bar");
// conn.WaitAll(tasks);
// withFlush.Stop();
// GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced); var withFAF = Stopwatch.StartNew();
// GC.WaitForPendingFinalizers(); for (int i = 0; i < loop; i++)
conn.Publish("foo", "bar", CommandFlags.FireAndForget);
withFAF.Stop();
// conn.SuspendFlush(); GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
// var withoutFlush = Stopwatch.StartNew(); GC.WaitForPendingFinalizers();
// for (int i = 0; i < loop; i++)
// tasks[i] = conn.Publish("foo", "bar");
// conn.ResumeFlush();
// conn.WaitAll(tasks);
// withoutFlush.Stop();
// Assert.Less(1, 2, "sanity check"); var withAsync = Stopwatch.StartNew();
// Assert.Less(withoutFlush.ElapsedMilliseconds, withFlush.ElapsedMilliseconds, caption); for (int i = 0; i < loop; i++)
// Console.WriteLine("{2}: {0}ms (eager-flush) vs {1}ms (suspend-flush)", tasks[i] = conn.PublishAsync("foo", "bar");
// withFlush.ElapsedMilliseconds, withoutFlush.ElapsedMilliseconds, caption); conn.WaitAll(tasks);
// } withAsync.Stop();
Assert.Less(1, 2, "sanity check");
Assert.Less(withFAF.ElapsedMilliseconds, withAsync.ElapsedMilliseconds, caption);
Console.WriteLine("{2}: {0}ms (F+F) vs {1}ms (async)",
withFAF.ElapsedMilliseconds, withAsync.ElapsedMilliseconds, caption);
}
// [Test]
// public void PubSubOrder()
// {
// using (var pub = Config.GetRemoteConnection(waitForOpen: true))
// using (var sub = pub.GetOpenSubscriberChannel())
// {
// string channel = "PubSubOrder";
// const int count = 500000;
// object syncLock = new object();
// List<int> data = new List<int>(count); [Test]
// sub.CompletionMode = ResultCompletionMode.PreserveOrder; public void PubSubOrder()
// sub.Subscribe(channel, (key,val) => { {
// bool pulse; using (var muxer = Config.GetRemoteConnection(waitForOpen: true))
// lock (data) {
// { var sub = muxer.GetSubscriber();
// data.Add(int.Parse(Encoding.UTF8.GetString(val))); string channel = "PubSubOrder";
// pulse = data.Count == count; const int count = 500000;
// if((data.Count % 10) == 99) Console.WriteLine(data.Count); object syncLock = new object();
// }
// if(pulse)
// lock(syncLock)
// Monitor.PulseAll(syncLock);
// }).Wait();
// lock (syncLock)
// {
// for (int i = 0; i < count; i++)
// {
// pub.Publish(channel, i.ToString());
// }
// if (!Monitor.Wait(syncLock, 10000))
// {
// throw new TimeoutException("Items: " + data.Count);
// }
// for (int i = 0; i < count; i++)
// Assert.AreEqual(i, data[i]);
// }
// }
// } List<int> data = new List<int>(count);
muxer.PreserveAsyncOrder = true;
sub.SubscribeAsync(channel, (key, val) =>
{
bool pulse;
lock (data)
{
data.Add(int.Parse(Encoding.UTF8.GetString(val)));
pulse = data.Count == count;
if ((data.Count % 10) == 99) Console.WriteLine(data.Count);
}
if (pulse)
lock (syncLock)
Monitor.PulseAll(syncLock);
}).Wait();
// [Test] lock (syncLock)
// public void TestPublishWithSubscribers() {
// { for (int i = 0; i < count; i++)
// using (var listenA = Config.GetSubscriberConnection()) {
// using (var listenB = Config.GetSubscriberConnection()) sub.Publish(channel, i.ToString(), CommandFlags.FireAndForget);
// using (var conn = Config.GetUnsecuredConnection()) }
// { sub.Ping();
// var t1 = listenA.Subscribe("channel", delegate { }); if (!Monitor.Wait(syncLock, 10000))
// var t2 = listenB.Subscribe("channel", delegate { }); {
throw new TimeoutException("Items: " + data.Count);
}
for (int i = 0; i < count; i++)
Assert.AreEqual(i, data[i]);
}
}
// listenA.Wait(t1); }
// Assert.AreEqual(1, listenA.SubscriptionCount, "A subscriptions");
// listenB.Wait(t2); [Test]
// Assert.AreEqual(1, listenB.SubscriptionCount, "B subscriptions"); public void TestPublishWithSubscribers()
{
using (var muxerA = Config.GetUnsecuredConnection())
using (var muxerB = Config.GetUnsecuredConnection())
using (var conn = Config.GetUnsecuredConnection())
{
var listenA = muxerA.GetSubscriber();
var listenB = muxerB.GetSubscriber();
var t1 = listenA.SubscribeAsync("channel", delegate { });
var t2 = listenB.SubscribeAsync("channel", delegate { });
// var pub = conn.Publish("channel", "message"); listenA.Wait(t1);
// Assert.AreEqual(2, conn.Wait(pub), "delivery count"); listenB.Wait(t2);
// }
// } var pub = conn.GetSubscriber().PublishAsync("channel", "message");
Assert.AreEqual(2, conn.Wait(pub), "delivery count");
}
}
// [Test] [Test]
// public void TestMultipleSubscribersGetMessage() public void TestMultipleSubscribersGetMessage()
// { {
// using (var listenA = Config.GetSubscriberConnection()) using (var muxerA = Config.GetUnsecuredConnection())
// using (var listenB = Config.GetSubscriberConnection()) using (var muxerB = Config.GetUnsecuredConnection())
// using (var conn = Config.GetUnsecuredConnection()) using (var conn = Config.GetUnsecuredConnection())
// { {
// conn.Wait(conn.Server.Ping()); var listenA = muxerA.GetSubscriber();
// int gotA = 0, gotB = 0; var listenB = muxerB.GetSubscriber();
// var tA = listenA.Subscribe("channel", (s, msg) => { if (Encoding.UTF8.GetString(msg) == "message") Interlocked.Increment(ref gotA); }); conn.GetDatabase().Ping();
// var tB = listenB.Subscribe("channel", (s, msg) => { if (Encoding.UTF8.GetString(msg) == "message") Interlocked.Increment(ref gotB); }); var pub = conn.GetSubscriber();
// listenA.Wait(tA); int gotA = 0, gotB = 0;
// listenB.Wait(tB); var tA = listenA.SubscribeAsync("channel", (s, msg) => { if (msg == "message") Interlocked.Increment(ref gotA); });
// Assert.AreEqual(2, conn.Wait(conn.Publish("channel", "message"))); var tB = listenB.SubscribeAsync("channel", (s, msg) => { if (msg == "message") Interlocked.Increment(ref gotB); });
// AllowReasonableTimeToPublishAndProcess(); listenA.Wait(tA);
// Assert.AreEqual(1, Interlocked.CompareExchange(ref gotA, 0, 0)); listenB.Wait(tB);
// Assert.AreEqual(1, Interlocked.CompareExchange(ref gotB, 0, 0)); Assert.AreEqual(2, pub.Publish("channel", "message"));
AllowReasonableTimeToPublishAndProcess();
Assert.AreEqual(1, Interlocked.CompareExchange(ref gotA, 0, 0));
Assert.AreEqual(1, Interlocked.CompareExchange(ref gotB, 0, 0));
// // and unsubscibe... // and unsubscibe...
// tA = listenA.Unsubscribe("channel"); tA = listenA.UnsubscribeAsync("channel");
// listenA.Wait(tA); listenA.Wait(tA);
// Assert.AreEqual(1, conn.Wait(conn.Publish("channel", "message"))); Assert.AreEqual(1, pub.Publish("channel", "message"));
// AllowReasonableTimeToPublishAndProcess(); AllowReasonableTimeToPublishAndProcess();
// Assert.AreEqual(1, Interlocked.CompareExchange(ref gotA, 0, 0)); Assert.AreEqual(1, Interlocked.CompareExchange(ref gotA, 0, 0));
// Assert.AreEqual(2, Interlocked.CompareExchange(ref gotB, 0, 0)); Assert.AreEqual(2, Interlocked.CompareExchange(ref gotB, 0, 0));
// } }
// } }
// [Test] [Test]
// public void Issue38() public void Issue38()
// { // https://code.google.com/p/booksleeve/issues/detail?id=38 { // https://code.google.com/p/booksleeve/issues/detail?id=38
// using (var pub = Config.GetUnsecuredConnection(waitForOpen: true)) using (var pub = Config.GetUnsecuredConnection(waitForOpen: true))
// using (var sub = pub.GetOpenSubscriberChannel()) {
// { var sub = pub.GetSubscriber();
// int count = 0; int count = 0;
// Action<string, byte[]> handler = (channel, payload) => Interlocked.Increment(ref count); Action<RedisChannel, RedisValue> handler = (channel, payload) => Interlocked.Increment(ref count);
// var a = sub.Subscribe(new string[] { "foo", "bar" }, handler); var a0 = sub.SubscribeAsync("foo", handler);
// var b = sub.PatternSubscribe(new string[] { "f*o", "b*r" }, handler); var a1 = sub.SubscribeAsync("bar", handler);
// sub.WaitAll(a, b); var b0 = sub.SubscribeAsync("f*o", handler);
var b1 = sub.SubscribeAsync("b*r", handler);
sub.WaitAll(a0, a1, b0, b1);
// var c = pub.Publish("foo", "foo"); var c = sub.PublishAsync("foo", "foo");
// var d = pub.Publish("f@o", "f@o"); var d = sub.PublishAsync("f@o", "f@o");
// var e = pub.Publish("bar", "bar"); var e = sub.PublishAsync("bar", "bar");
// var f = pub.Publish("b@r", "b@r"); var f = sub.PublishAsync("b@r", "b@r");
// pub.WaitAll(c, d, e, f); pub.WaitAll(c, d, e, f);
// long total = c.Result + d.Result + e.Result + f.Result; long total = c.Result + d.Result + e.Result + f.Result;
// AllowReasonableTimeToPublishAndProcess(); AllowReasonableTimeToPublishAndProcess();
// Assert.AreEqual(6, total, "sent"); Assert.AreEqual(6, total, "sent");
// Assert.AreEqual(6, Interlocked.CompareExchange(ref count, 0, 0), "received"); Assert.AreEqual(6, Interlocked.CompareExchange(ref count, 0, 0), "received");
// } }
// } }
// internal static void AllowReasonableTimeToPublishAndProcess() internal static void AllowReasonableTimeToPublishAndProcess()
// { {
// Thread.Sleep(50); Thread.Sleep(50);
// } }
// [Test] [Test]
// public void TestPartialSubscriberGetMessage() public void TestPartialSubscriberGetMessage()
// { {
// using (var listenA = Config.GetSubscriberConnection()) using (var muxerA = Config.GetUnsecuredConnection())
// using (var listenB = Config.GetSubscriberConnection()) using (var muxerB = Config.GetUnsecuredConnection())
// using (var conn = Config.GetUnsecuredConnection()) using (var conn = Config.GetUnsecuredConnection())
// { {
// int gotA = 0, gotB = 0; int gotA = 0, gotB = 0;
// var tA = listenA.Subscribe("channel", (s, msg) => { if (s == "channel" && Encoding.UTF8.GetString(msg) == "message") Interlocked.Increment(ref gotA); }); var listenA = muxerA.GetSubscriber();
// var tB = listenB.PatternSubscribe("chann*", (s, msg) => { if (s == "channel" && Encoding.UTF8.GetString(msg) == "message") Interlocked.Increment(ref gotB); }); var listenB = muxerB.GetSubscriber();
// listenA.Wait(tA); var pub = conn.GetSubscriber();
// listenB.Wait(tB); var tA = listenA.SubscribeAsync("channel", (s, msg) => { if (s == "channel" && msg == "message") Interlocked.Increment(ref gotA); });
// Assert.AreEqual(2, conn.Wait(conn.Publish("channel", "message"))); var tB = listenB.SubscribeAsync("chann*", (s, msg) => { if (s == "channel" && msg == "message") Interlocked.Increment(ref gotB); });
// AllowReasonableTimeToPublishAndProcess(); listenA.Wait(tA);
// Assert.AreEqual(1, Interlocked.CompareExchange(ref gotA, 0, 0)); listenB.Wait(tB);
// Assert.AreEqual(1, Interlocked.CompareExchange(ref gotB, 0, 0)); Assert.AreEqual(2, pub.Publish("channel", "message"));
AllowReasonableTimeToPublishAndProcess();
Assert.AreEqual(1, Interlocked.CompareExchange(ref gotA, 0, 0));
Assert.AreEqual(1, Interlocked.CompareExchange(ref gotB, 0, 0));
// // and unsubscibe... // and unsubscibe...
// tB = listenB.PatternUnsubscribe("chann*"); tB = listenB.UnsubscribeAsync("chann*", null);
// listenB.Wait(tB); listenB.Wait(tB);
// Assert.AreEqual(1, conn.Wait(conn.Publish("channel", "message"))); Assert.AreEqual(1, pub.Publish("channel", "message"));
// AllowReasonableTimeToPublishAndProcess(); AllowReasonableTimeToPublishAndProcess();
// Assert.AreEqual(2, Interlocked.CompareExchange(ref gotA, 0, 0)); Assert.AreEqual(2, Interlocked.CompareExchange(ref gotA, 0, 0));
// Assert.AreEqual(1, Interlocked.CompareExchange(ref gotB, 0, 0)); Assert.AreEqual(1, Interlocked.CompareExchange(ref gotB, 0, 0));
// } }
// } }
// [Test] [Test]
// public void TestSubscribeUnsubscribeAndSubscribeAgain() public void TestSubscribeUnsubscribeAndSubscribeAgain()
// { {
// using (var pub = Config.GetUnsecuredConnection()) using (var pubMuxer = Config.GetUnsecuredConnection())
// using (var sub = Config.GetSubscriberConnection()) using (var subMuxer = Config.GetUnsecuredConnection())
// { {
// int x = 0, y = 0; var pub = pubMuxer.GetSubscriber();
// var t1 = sub.Subscribe("abc", delegate { Interlocked.Increment(ref x); }); var sub = subMuxer.GetSubscriber();
// var t2 = sub.PatternSubscribe("ab*", delegate { Interlocked.Increment(ref y); }); int x = 0, y = 0;
// sub.WaitAll(t1, t2); var t1 = sub.SubscribeAsync("abc", delegate { Interlocked.Increment(ref x); });
// pub.Publish("abc", ""); var t2 = sub.SubscribeAsync("ab*", delegate { Interlocked.Increment(ref y); });
// AllowReasonableTimeToPublishAndProcess(); sub.WaitAll(t1, t2);
// Assert.AreEqual(1, Thread.VolatileRead(ref x)); pub.Publish("abc", "");
// Assert.AreEqual(1, Thread.VolatileRead(ref y)); AllowReasonableTimeToPublishAndProcess();
// t1 = sub.Unsubscribe("abc"); Assert.AreEqual(1, Thread.VolatileRead(ref x));
// t2 = sub.PatternUnsubscribe("ab*"); Assert.AreEqual(1, Thread.VolatileRead(ref y));
// sub.WaitAll(t1, t2); t1 = sub.UnsubscribeAsync("abc", null);
// pub.Publish("abc", ""); t2 = sub.UnsubscribeAsync("ab*", null);
// Assert.AreEqual(1, Thread.VolatileRead(ref x)); sub.WaitAll(t1, t2);
// Assert.AreEqual(1, Thread.VolatileRead(ref y)); pub.Publish("abc", "");
// t1 = sub.Subscribe("abc", delegate { Interlocked.Increment(ref x); }); Assert.AreEqual(1, Thread.VolatileRead(ref x));
// t2 = sub.PatternSubscribe("ab*", delegate { Interlocked.Increment(ref y); }); Assert.AreEqual(1, Thread.VolatileRead(ref y));
// sub.WaitAll(t1, t2); t1 = sub.SubscribeAsync("abc", delegate { Interlocked.Increment(ref x); });
// pub.Publish("abc", ""); t2 = sub.SubscribeAsync("ab*", delegate { Interlocked.Increment(ref y); });
// AllowReasonableTimeToPublishAndProcess(); sub.WaitAll(t1, t2);
// Assert.AreEqual(2, Thread.VolatileRead(ref x)); pub.Publish("abc", "");
// Assert.AreEqual(2, Thread.VolatileRead(ref y)); AllowReasonableTimeToPublishAndProcess();
Assert.AreEqual(2, Thread.VolatileRead(ref x));
Assert.AreEqual(2, Thread.VolatileRead(ref y));
// } }
// } }
// } }
//} }
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment