protected override void EstablishContext()
{
base.EstablishContext();
RemoteBus.ShouldHaveSubscriptionFor <MyMessage>();
LocalBus.Publish(new MyMessage());
}
protected override void EstablishContext()
{
base.EstablishContext();
AddFirstCommandInstance("A", "loopback://localhost/a");
AddFirstCommandInstance("B", "loopback://localhost/b");
AddFirstCommandInstance("C", "loopback://localhost/c");
RemoteBus.ShouldHaveSubscriptionFor <Distributed <FirstCommand> >();
}
public void Should_not_remove_any_existing_subscriptions()
{
RemoteBus.SubscribeHandler <A>(x => { });
RemoteBus.ShouldHaveSubscriptionFor <A>();
LocalBus.ShouldHaveRemoteSubscriptionFor <A>();
RemoteBus.Dispose();
ThreadUtil.Sleep(2.Seconds());
LocalBus.ShouldHaveRemoteSubscriptionFor <A>();
}
public void Publishing_to_a_remote_subscriber()
{
Consumer = new ConsumerOf <SimpleMessage>();
_unsubscribeAction = RemoteBus.SubscribeInstance(Consumer);
RemoteBus.ShouldHaveSubscriptionFor <SimpleMessage>();
LocalBus.ShouldHaveSubscriptionFor <SimpleMessage>();
_message = new SimpleMessage();
LocalBus.Publish(_message);
}
public void A_consumer_type_should_be_created_to_receive_the_message()
{
var fm = new FutureMessage <PingMessage>();
LocalBus.SubscribeConsumer <PingHandler>(() => new PingHandler(fm));
RemoteBus.ShouldHaveSubscriptionFor <PingMessage>();
int old = PingHandler.Pinged;
RemoteBus.Publish(new PingMessage());
fm.IsAvailable(1.Seconds());
Assert.That(PingHandler.Pinged, Is.GreaterThan(old));
}
public void Should_be_able_to_read_xml_when_using_json()
{
Assert.IsTrue(RemoteBus.ShouldHaveSubscriptionFor <B>().Any());
Assert.IsTrue(LocalBus.ShouldHaveSubscriptionFor <A>().Any());
LocalBus.GetEndpoint(RemoteUri).Send(new A {
Key = "Hello"
});
_requestReceived.WaitUntilCompleted(8.Seconds()).ShouldBeTrue();
_responseReceived.WaitUntilCompleted(8.Seconds()).ShouldBeTrue();
}
public void Should_remove_any_previous_subscriptions()
{
RemoteBus.SubscribeHandler <A>(x => { });
RemoteBus.ShouldHaveSubscriptionFor <A>();
LocalBus.ShouldHaveRemoteSubscriptionFor <A>();
RemoteBus.Dispose();
ThreadUtil.Sleep(2.Seconds());
SetupRemoteBus();
LocalBus.ShouldNotHaveSubscriptionFor <A>();
}
public void A_consumer_object_should_receive_the_message()
{
FutureMessage <PingMessage> fm = new FutureMessage <PingMessage>();
PingHandler handler = new PingHandler(fm);
LocalBus.SubscribeInstance(handler);
RemoteBus.ShouldHaveSubscriptionFor <PingMessage>();
int old = PingHandler.Pinged;
RemoteBus.Publish(new PingMessage());
fm.IsAvailable(1.Seconds());
Assert.That(PingHandler.Pinged, Is.GreaterThan(old));
}
public void Subscring_to_an_endpoint_should_accept_and_dispatch_messages()
{
FutureMessage <PingMessage> fm = new FutureMessage <PingMessage>();
bool workDid = false;
LocalBus.SubscribeHandler <PingMessage>(
(msg) => { workDid = true; fm.Set(msg); },
delegate { return(true); });
RemoteBus.ShouldHaveSubscriptionFor <PingMessage>();
RemoteBus.Publish(_message);
fm.IsAvailable(1.Seconds());
Assert.That(workDid, Is.True, "Lazy Test!");
}
public void Should_properly_register_the_consumers_for_each_endpoint()
{
var firstComponent = new FirstComponent();
LocalBus.SubscribeInstance(firstComponent);
var secondComponent = new SecondComponent();
LocalBus.SubscribeInstance(secondComponent);
RemoteBus.ShouldHaveSubscriptionFor <IncomingMessage>();
RemoteBus.ShouldHaveCorrelatedSubscriptionFor <IncomingMessage, string>(FirstCorrelationId);
RemoteBus.ShouldHaveCorrelatedSubscriptionFor <IncomingMessage, string>(SecondCorrelationId);
}
public void Then_the_claim_is_rejected_when_no_verification_is_received_within_the_timeout()
{
var timer = Stopwatch.StartNew();
var controller = new ClaimRequestTestCoordinator(LocalBus, 1000);
using (LocalBus.SubscribeInstance(controller).Disposable())
{
RemoteBus.ShouldHaveSubscriptionFor <ClaimRequestCreatedPendingVerificationEvent>();
bool complete = controller.CreateClaimRequest(1200, "ClaimType", DateTime.Today.AddDays(-10), "provider", "reason");
Assert.IsTrue(complete, "There should be a timeout scheduled for this claim request.");
timer.Stop();
Debug.WriteLine(string.Format("Time to handle message: {0}ms", timer.ElapsedMilliseconds));
complete = controller.Timeout();
Assert.IsTrue(complete, "The claim request timed out but the claim was not rejected.");
}
}
protected override void EstablishContext()
{
base.EstablishContext();
InMemorySagaRepository <RegisterUserSaga> sagaRepository = SetupSagaRepository <RegisterUserSaga>();
// this just shows that you can easily respond to the message
RemoteBus.SubscribeHandler <SendUserVerificationEmail>(
x =>
{
RemoteBus.ShouldHaveSubscriptionFor <UserVerificationEmailSent>();
RemoteBus.Publish(new UserVerificationEmailSent(x.CorrelationId, x.Email));
});
RemoteBus.SubscribeSaga(sagaRepository);
LocalBus.ShouldHaveSubscriptionFor <RegisterUser>();
LocalBus.ShouldHaveSubscriptionFor <UserVerificationEmailSent>();
LocalBus.ShouldHaveSubscriptionFor <UserValidated>();
}
public void Then_a_new_timeout_is_scheduled_and_cancelled_when_the_claim_is_verified()
{
var timer = Stopwatch.StartNew();
var controller = new ClaimRequestTestCoordinator(LocalBus, 4000);
using (LocalBus.SubscribeInstance(controller).Disposable())
{
RemoteBus.ShouldHaveSubscriptionFor <ClaimRequestCreatedPendingVerificationEvent>();
RemoteBus.ShouldHaveSubscriptionFor <CardUseVerifiedEvent>();
bool complete = controller.CreateClaimRequest(1200, "ClaimType", DateTime.Today.AddDays(-10), "provider", "reason");
Assert.IsTrue(complete, "No timeout scheduled message was received for this claim request.");
timer.Stop();
Debug.WriteLine(string.Format("Time to handle message: {0}ms", timer.ElapsedMilliseconds));
complete = controller.VerifyCardUse();
Assert.IsTrue(complete, "The timeout should have been cancelled and the saga should be complete.");
}
}
public void It_should_not_rollback_a_send_if_an_exception_is_thrown()
{
var consumer = new TestMessageConsumer <PongMessage>();
LocalBus.SubscribeInstance(consumer);
var message = new PingMessage();
var response = new PongMessage(message.CorrelationId);
RemoteBus.SubscribeHandler <PingMessage>(m =>
{
RemoteBus.Publish(response);
throw new ApplicationException("Boing!");
});
LocalBus.ShouldHaveSubscriptionFor <PingMessage>();
RemoteBus.ShouldHaveSubscriptionFor <PongMessage>();
LocalBus.Publish(message);
consumer.ShouldHaveReceivedMessage(response, _timeout);
}
protected override void EstablishContext()
{
base.EstablishContext();
var sagaRepository = new InMemorySagaRepository <ClaimRequestSaga>();
//these subscriptions are to replace the Timeout Service
RemoteBus.SubscribeHandler <ScheduleTimeout>(
x =>
{
RemoteBus.ShouldHaveSubscriptionFor <TimeoutScheduled>();
RemoteBus.Publish(new TimeoutScheduled {
CorrelationId = x.CorrelationId, TimeoutAt = x.TimeoutAt
});
});
RemoteBus.SubscribeHandler <CancelTimeout>(
x =>
{
RemoteBus.ShouldHaveSubscriptionFor <TimeoutCancelled>();
RemoteBus.Publish(new TimeoutCancelled {
CorrelationId = x.CorrelationId
});
}
);
//RemoteBus.SubscribeHandler<ClaimRequestCreatedPendingVerificationEvent>(x =>
// {
// Debug.WriteLine("Claim Created Pending Verification event received.");
// });
RemoteBus.SubscribeSaga(sagaRepository);
//event messages that the Saga is subscribed to
LocalBus.ShouldHaveSubscriptionFor <ClaimRequestCreatedPendingVerificationEvent>();
LocalBus.ShouldHaveSubscriptionFor <CardUseVerifiedEvent>();
LocalBus.ShouldHaveSubscriptionFor <TimeoutExpired>();
}
public void The_user_should_be_pending()
{
Stopwatch timer = Stopwatch.StartNew();
var controller = new RegisterUserController(LocalBus);
using (IUnsubscribeAction unsubscribe = LocalBus.SubscribeInstance(controller).Disposable())
{
RemoteBus.ShouldHaveSubscriptionFor <UserRegistrationPending>();
RemoteBus.ShouldHaveSubscriptionFor <UserRegistrationComplete>();
bool complete = controller.RegisterUser("username", "password", "Display Name", "*****@*****.**");
complete.ShouldBeTrue("The user should be pending");
timer.Stop();
Debug.WriteLine(string.Format("Time to handle message: {0}ms", timer.ElapsedMilliseconds));
complete = controller.ValidateUser();
complete.ShouldBeTrue("The user should be complete");
}
}