public void WillSaveOnce() {
var latch = new CountDownLatch(2);
var storage = new InMemoryFileStorage();
var dict = new PersistedDictionary("test.json", storage, new DefaultJsonSerializer(), 50);
dict.Saved += (sender, args) => latch.Signal();
for (int i = 0; i < 10; i++)
dict["test" + i] = i.ToString();
Assert.Equal(10, dict.Count);
bool success = latch.Wait(250);
Assert.False(success, "Dictionary was saved multiple times.");
Assert.Equal(1, latch.Remaining);
Assert.True(storage.Exists("test.json"));
dict["test"] = "test";
Assert.Equal(11, dict.Count);
success = latch.Wait(250);
Assert.True(success, "Failed to save dictionary.");
Assert.True(storage.Exists("test.json"));
}
public void CanTolerateSubscriberFailure() {
var latch = new CountDownLatch(2);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<SimpleMessageA>(msg => {
throw new ApplicationException();
});
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
bool success = latch.Wait(900);
Assert.True(success, "Failed to receive all messages.");
}
public void CanSendMessageToMultipleSubscribers() {
var latch = new CountDownLatch(3);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
bool success = latch.Wait(100);
Assert.True(success, "Failed to receive all messages.");
}
public void CanSendMessageToMultipleSubscribers() {
if (_messageBus == null)
return;
var latch = new CountDownLatch(3);
_messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
_messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
_messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
_messageBus.Publish(new SimpleMessageA {
Data = "Hello"
});
bool success = latch.Wait(15000);
Assert.True(success, "Failed to receive all messages.");
}
public void WillReceiveDerivedMessageTypes() {
var latch = new CountDownLatch(2);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<ISimpleMessage>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
messageBus.PublishAsync(new SimpleMessageB {
Data = "Hello"
});
messageBus.PublishAsync(new SimpleMessageC {
Data = "Hello"
});
bool success = latch.Wait(100);
Assert.True(success, "Failed to receive all messages.");
}
public void CanSubscribeToAllMessageTypes() {
var latch = new CountDownLatch(3);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<object>(msg => {
latch.Signal();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
messageBus.PublishAsync(new SimpleMessageB {
Data = "Hello"
});
messageBus.PublishAsync(new SimpleMessageC {
Data = "Hello"
});
bool success = latch.Wait(100);
Assert.True(success, "Failed to receive all messages.");
}
public void CanSubscribeToAllMessageTypes() {
if (_messageBus == null)
return;
var latch = new CountDownLatch(3);
_messageBus.Subscribe<object>(msg => {
latch.Signal();
});
_messageBus.Publish(new SimpleMessageA {
Data = "Hello"
});
_messageBus.Publish(new SimpleMessageB {
Data = "Hello"
});
_messageBus.Publish(new SimpleMessageC {
Data = "Hello"
});
bool success = latch.Wait(5000);
Assert.True(success, "Failed to receive all messages.");
}
public void WillReceiveDerivedMessageTypes() {
if (_messageBus == null)
return;
var latch = new CountDownLatch(2);
_messageBus.Subscribe<ISimpleMessage>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
_messageBus.Publish(new SimpleMessageA {
Data = "Hello"
});
_messageBus.Publish(new SimpleMessageB {
Data = "Hello"
});
_messageBus.Publish(new SimpleMessageC {
Data = "Hello"
});
bool success = latch.Wait(5000);
Assert.True(success, "Failed to receive all messages.");
}
private void DoWork(QueueEntry<SimpleWorkItem> w, CountDownLatch latch, ref int abandonCount, ref int errorCount) {
Assert.Equal("Hello", w.Value.Data);
latch.Signal();
// randomly complete, abandon or blowup.
if (RandomHelper.GetBool()) {
Console.WriteLine("Completing: {0}", w.Value.Id);
w.CompleteAsync().Wait();
} else if (RandomHelper.GetBool()) {
Console.WriteLine("Abandoning: {0}", w.Value.Id);
w.AbandonAsync();
Interlocked.Increment(ref abandonCount);
} else {
Console.WriteLine("Erroring: {0}", w.Value.Id);
Interlocked.Increment(ref errorCount);
throw new ApplicationException();
}
}
public void CanHaveMultipleWorkers() {
const int workItemCount = 50;
var latch = new CountDownLatch(workItemCount);
int errorCount = 0;
int abandonCount = 0;
var queue = new InMemoryQueue<SimpleWorkItem>(retries: 1, workItemTimeoutMilliseconds: 50);
Task.Factory.StartNew(() => queue.StartWorking(w => DoWork(w, latch, ref abandonCount, ref errorCount)));
Task.Factory.StartNew(() => queue.StartWorking(w => DoWork(w, latch, ref abandonCount, ref errorCount)));
Task.Factory.StartNew(() => queue.StartWorking(w => DoWork(w, latch, ref abandonCount, ref errorCount)));
Parallel.For(0, workItemCount, i => queue.EnqueueAsync(new SimpleWorkItem {
Data = "Hello",
Id = i
}));
bool success = latch.Wait(1000);
Assert.True(success, "Failed to receive all work items.");
Task.Delay(50).Wait();
Assert.Equal(workItemCount, queue.Completed + queue.DeadletterCount);
Assert.Equal(errorCount, queue.WorkerErrors);
Assert.Equal(abandonCount + errorCount, queue.Abandoned);
}
public void CanHaveMultipleWorkers() {
if (_queue == null)
return;
const int workItemCount = 50;
var latch = new CountDownLatch(workItemCount);
int errorCount = 0;
int abandonCount = 0;
Task.Factory.StartNew(() => _queue.StartWorking(w => DoWork(w, latch, ref abandonCount, ref errorCount)));
Task.Factory.StartNew(() => _queue.StartWorking(w => DoWork(w, latch, ref abandonCount, ref errorCount)));
Task.Factory.StartNew(() => _queue.StartWorking(w => DoWork(w, latch, ref abandonCount, ref errorCount)));
Parallel.For(0, workItemCount, i => _queue.EnqueueAsync(new SimpleWorkItem {
Data = "Hello",
Id = i
}));
Assert.Equal(workItemCount, _queue.Enqueued);
bool success = latch.Wait(60000);
Task.Delay(5000).Wait();
Assert.True(success, "Failed to receive all work items.");
Assert.Equal(workItemCount, _queue.Completed + _queue.DeadletterCount);
Assert.Equal(errorCount, _queue.WorkerErrors);
Assert.Equal(abandonCount + errorCount, _queue.Abandoned);
}