public void Should_invoke_the_continuation()
{
var transport = MockRepository.GenerateStub <IMsmqTransport>();
transport.Stub(x => x.Receive(null))
.Callback(new Func <Func <Message, Action <Message> >, bool>(Forwarder));
var address = MockRepository.GenerateMock <IMsmqEndpointAddress>();
IEndpoint endpoint = new MsmqEndpoint(address, new XmlMessageSerializer(), transport, MockRepository.GenerateMock <IMsmqTransport>());
var future = new Future <object>();
endpoint.Receive(m =>
message =>
{
Assert.IsInstanceOf <SimpleMessage>(message);
Assert.AreEqual(((SimpleMessage)message).Name, "Chris");
future.Complete(message);
});
Assert.IsTrue(future.IsAvailable(), "Receive was not called");
}
public void Should_pass_derived_types_through_the_filter()
{
var received = new Future<bool>();
Pipe consumer = PipeSegment.Consumer<BaseClass>(x => received.Complete(true));
Pipe filter = PipeSegment.Filter<object>(consumer);
filter.Send(new SubClass());
received.IsAvailable(TimeSpan.Zero).ShouldBeTrue();
}
public void Should_not_stall_the_scheduler()
{
ActionQueue queue = new ThreadPoolActionQueue();
ActionScheduler scheduler = new TimerActionScheduler(new ThreadPoolActionQueue());
var called = new Future<bool>();
scheduler.Schedule(200.Milliseconds(), queue, () => { throw new InvalidOperationException("Bugger!"); });
scheduler.Schedule(400.Milliseconds(), queue, () => called.Complete(true));
called.IsAvailable(1.Seconds()).ShouldBeTrue();
}
public void Should_wait_until_the_appropriate_time_for_the_action_to_execute()
{
ActionQueue queue = new ThreadPoolActionQueue();
ActionScheduler scheduler = new TimerActionScheduler(new SynchronousActionQueue());
var called = new Future<bool>();
scheduler.Schedule(100.Milliseconds(), queue, () => called.Complete(true));
called.IsAvailable(0.Seconds()).ShouldBeFalse();
called.IsAvailable(1.Seconds()).ShouldBeTrue();
}
public void Should_not_run_any_pending_actions()
{
ActionQueue queue = new ThreadPoolActionQueue();
ActionScheduler scheduler = new TimerActionScheduler(new ThreadPoolActionQueue());
var called = new Future<bool>();
scheduler.Schedule(1.Seconds(), queue, () => called.Complete(true));
scheduler.Disable();
called.IsAvailable(2.Seconds()).ShouldBeFalse();
}
public void Should_schedule_events()
{
Channel<UserUpdate> channel = new SynchronousChannel<UserUpdate>();
var update = new UserUpdate {LastActivity = DateTime.Now - 5.Minutes()};
CommandQueue queue = new SynchronousCommandQueue();
var scheduler = new ThreadPoolScheduler();
var future = new Future<UserUpdate>();
channel.Subscribe(queue, future.Complete);
scheduler.Schedule(1000, () => channel.Publish(update));
Thread.Sleep(500);
Assert.IsFalse(future.IsAvailable(0.Seconds()));
Assert.IsTrue(future.IsAvailable(1.Seconds()));
}
public void Should_receive_the_message_when_a_transaction_is_completed()
{
var future = new Future <DeleteMessage>();
using (TransactionScope transaction = new TransactionScope())
{
Endpoint.Receive(message => m => { future.Complete(m as DeleteMessage); });
transaction.Complete();
}
future.IsAvailable().ShouldBeTrue();
Endpoint.ShouldNotContain <DeleteMessage>();
}
public void Should_deliver_the_message_once_the_endpoint_is_available()
{
var received = new Future <PingMessage>();
using (RemoteBus.Subscribe <PingMessage>(received.Complete).Disposable())
{
Thread.Sleep(100);
var ping = new PingMessage();
LocalBus.Publish(ping);
received.IsAvailable(5.Seconds()).ShouldBeTrue();
}
}
public void Should_prevent_new_actions_from_being_queued()
{
ActionQueue queue = new ThreadPoolActionQueue();
var called = new Future<bool>();
queue.StopAcceptingActions();
Assert.Throws<ActionQueueException>(() => queue.Enqueue(() => called.Complete(true)));
queue.ExecuteAll(10.Seconds());
called.IsAvailable().ShouldBeFalse();
}
public void Should_receive_the_message_when_a_transaction_is_rolled_back()
{
var future = new Future <DeleteMessage>();
using (TransactionScope transaction = new TransactionScope())
{
Endpoint.Receive(message => m => { future.Complete(m as DeleteMessage); });
// do not complete the transaction (implicit rollback)
}
future.IsAvailable().ShouldBeTrue();
Endpoint.ShouldNotContain <DeleteMessage>();
}
public void Should_deliver_the_message_to_an_interested_consumer()
{
var first = new Future <FirstMessageContract>();
RemoteBus.Subscribe <FirstMessageContract>(first.Complete);
PipelineViewer.Trace(RemoteBus.InboundPipeline);
var message = new SomeMessageContract("Joe", 27);
LocalBus.Publish(message);
first.IsAvailable(1.Seconds()).ShouldBeTrue();
}
public void Should_deliver_the_message_once_the_endpoint_is_available()
{
var received = new Future<PingMessage>();
using (RemoteBus.Subscribe<PingMessage>(received.Complete).Disposable())
{
Thread.Sleep(100);
var ping = new PingMessage();
LocalBus.Publish(ping);
received.IsAvailable(5.Seconds()).ShouldBeTrue();
}
}
public void Should_filter_out_unwanted_messages()
{
Channel<UserUpdate> channel = new SynchronousChannel<UserUpdate>();
UserUpdate update = new UserUpdate {LastActivity = DateTime.Now - 5.Minutes()};
CommandQueue queue = new SynchronousCommandQueue();
var future = new Future<UserUpdate>();
channel.Subscribe(queue, future.Complete, message => message.LastActivity > DateTime.Now);
var result = channel.Publish(update);
Assert.IsTrue(result);
Assert.IsFalse(future.IsAvailable(1.Seconds()));
}
public void Should_deliver_the_message_to_an_both_interested_consumers()
{
var first = new Future <FirstMessageContract>();
var second = new Future <SecondMessageContract>();
// These can't be on the same bus, because we only send a message to an endpoint once
// maybe we can do something here by changing the outbound context to keep track of tmessage/endpoint uri
RemoteBus.Subscribe <FirstMessageContract>(first.Complete);
LocalBus.Subscribe <SecondMessageContract>(second.Complete);
PipelineViewer.Trace(RemoteBus.InboundPipeline);
var message = new SomeMessageContract("Joe", 27);
LocalBus.Publish(message);
first.IsAvailable(1.Seconds()).ShouldBeTrue();
second.IsAvailable(1.Seconds()).ShouldBeTrue();
}
public static void ShouldContain <TMessage>(this IEndpoint endpoint)
where TMessage : class
{
var future = new Future <TMessage>();
endpoint.Receive(message =>
{
message.ShouldNotBeNull();
message.ShouldBeSameType <TMessage>();
TMessage tm = (TMessage)message;
future.Complete(tm);
return(null);
});
future.IsAvailable().ShouldBeTrue(endpoint.Address + " should contain a message of type " + typeof(TMessage).Name);
}
public static void ShouldContain <TMessage>(this IEndpoint endpoint, TMessage expectedMessage, TimeSpan timeout)
where TMessage : CorrelatedBy <Guid>
{
var future = new Future <TMessage>();
endpoint.Receive(message =>
{
message.ShouldNotBeNull();
message.ShouldBeSameType <TMessage>();
TMessage tm = (TMessage)message;
Assert.AreEqual(expectedMessage.CorrelationId, tm.CorrelationId);
future.Complete(tm);
return(null);
}, timeout);
future.IsAvailable().ShouldBeTrue(endpoint.Address + " should contain a message of type " + typeof(TMessage).Name + " with correlation id " + expectedMessage.CorrelationId);
}
public void Should_invoke_the_continuation()
{
var transport = MockRepository.GenerateStub<IMsmqTransport>();
transport.Stub(x => x.Receive(null))
.Callback(new Func<Func<Message, Action<Message>>, bool>(Forwarder));
var address = MockRepository.GenerateMock<IMsmqEndpointAddress>();
IEndpoint endpoint = new MsmqEndpoint(address, new XmlMessageSerializer(), transport, MockRepository.GenerateMock<IMsmqTransport>());
var future = new Future<object>();
endpoint.Receive(m =>
message =>
{
Assert.IsInstanceOf<SimpleMessage>(message);
Assert.AreEqual(((SimpleMessage) message).Name, "Chris");
future.Complete(message);
});
Assert.IsTrue(future.IsAvailable(), "Receive was not called");
}
public void Should_run_the_action_until_disabled()
{
ActionQueue queue = new ThreadPoolActionQueue();
ActionScheduler scheduler = new TimerActionScheduler(new ThreadPoolActionQueue());
Stopwatch elapsed = Stopwatch.StartNew();
int count = 0;
var called = new Future<int>();
var failed = new Future<bool>();
ScheduledAction scheduledAction = null;
scheduledAction = scheduler.Schedule(TimeSpan.Zero, 100.Milliseconds(), queue, () =>
{
count++;
if (count == 10)
{
called.Complete(count);
scheduledAction.Cancel();
}
else if (count > 10)
{
failed.Complete(true);
}
});
called.IsAvailable(5.Seconds()).ShouldBeTrue();
elapsed.Stop();
failed.IsAvailable(200.Milliseconds()).ShouldBeFalse();
Trace.WriteLine("Time Period: " + elapsed.ElapsedMilliseconds);
}
public void Should_run_the_action_immediately()
{
ActionQueue queue = new ThreadPoolActionQueue();
ActionScheduler scheduler = new TimerActionScheduler(new SynchronousActionQueue());
var called = new Future<bool>();
scheduler.Schedule(TimeSpan.Zero, queue, () => called.Complete(true));
called.IsAvailable(1.Seconds()).ShouldBeTrue();
}
public void Should_receive_the_message_when_a_transaction_is_rolled_back()
{
var future = new Future<DeleteMessage>();
using (TransactionScope transaction = new TransactionScope())
{
Endpoint.Receive(message => m => { future.Complete(m as DeleteMessage); });
// do not complete the transaction (implicit rollback)
}
future.IsAvailable().ShouldBeTrue();
Endpoint.ShouldContain<DeleteMessage>();
}
public void Should_result_in_no_waiting_actions_in_the_queue()
{
ActionQueue queue = new ThreadActionQueue();
queue.Enqueue(() => Thread.Sleep(1000));
var called = new Future<bool>();
queue.Enqueue(() => called.Complete(true));
queue.ExecuteAll(12.Seconds());
called.IsAvailable().ShouldBeTrue();
}
public void Should_work_for_thread_static_instances()
{
int message = 27;
var result = MockRepository.GenerateMock<Channel<int>>();
result.Expect(x => x.Send(message)).Repeat.Twice();
var provider = MockRepository.GenerateMock<ChannelProvider<int>>();
provider.Expect(x => x(message)).Return(result).Repeat.Twice();
var channel = new InstanceChannel<int>(new ThreadStaticChannelProvider<int>(provider).GetChannel);
Future<bool> first = new Future<bool>();
Future<bool> second = new Future<bool>();
ThreadPool.QueueUserWorkItem(x =>
{
long k;
for (int i = 0; i < 10000000; i++)
{
k = i*777;
}
channel.Send(message);
first.Complete(true);
});
ThreadPool.QueueUserWorkItem(x =>
{
long k;
for (int i = 0; i < 10000000; i++)
{
k = i * 777;
}
channel.Send(message);
second.Complete(true);
});
first.IsAvailable(5.Seconds()).ShouldBeTrue();
second.IsAvailable(5.Seconds()).ShouldBeTrue();
provider.VerifyAllExpectations();
result.VerifyAllExpectations();
}
public void Should_result_in_no_waiting_actions_in_the_queue()
{
TraceLogProvider.Configure(LogLevel.Debug);
ActionQueue queue = new ThreadPoolActionQueue();
queue.Enqueue(() => Thread.Sleep(1000));
var called = new Future<bool>();
queue.Enqueue(() => called.Complete(true));
queue.ExecuteAll(8.Seconds());
called.IsAvailable().ShouldBeTrue();
}
public void Should_receive_the_message_when_a_transaction_is_completed()
{
var future = new Future<DeleteMessage>();
using (TransactionScope transaction = new TransactionScope())
{
Endpoint.Receive(message => m => { future.Complete(m as DeleteMessage); });
transaction.Complete();
}
future.IsAvailable().ShouldBeTrue();
Endpoint.ShouldNotContain<DeleteMessage>();
}
