public void Handle(SomeMessage message)
{
var color = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("Handling the message");
Console.ForegroundColor = color;
}
public void Connection_CommonMessageObjectCompleteTest()
{
var content = new SomeMessage(1, "varA");
var message = new RequestMessageData <SomeMessage>(
_data: content,
_publishHostUrl: "publishResponseHostUrlTest",
_publishHostPort: 123,
_publishChannel: "publishResponseChannelTest",
_publishType: MessageBrokerEnum.Redis,
_cacheHostUrl: "publishResponseCacheHostUrlTest",
_cacheHostPort: 456,
_cacheKey: "publishResponseCacheKeyTest",
_cacheType: CacheTypeEnum.MemoryCache,
_cacheTimeoutMiliseconds: 10,
_sessionIDGateway: "sessionIdGatewayTest",
_userIDGateway: "userIDGatewayTest"
);
Assert.IsNotNull(message);
Assert.IsNotNull(message.PublishChannel);
Assert.IsNotNull(message.CacheKey);
Assert.AreEqual(message.Data, content);
Assert.IsTrue(message.Data is SomeMessage);
}
public void WhenMessageFailsThenOnMessageFaultIsCalled()
{
// arrange
var onMessageFaultMock = new Mock <Action <AbstractConsumerSettings, object, Exception> >();
var consumerSettings = new ConsumerSettings
{
Instances = 1,
Topic = "topic1",
ConsumerMode = ConsumerMode.Consumer,
ConsumerType = typeof(IConsumer <SomeMessage>),
MessageType = typeof(SomeMessage),
OnMessageFault = onMessageFaultMock.Object
};
var p = new ConsumerInstancePool <SomeMessage>(consumerSettings, _busMock.Bus, x => Array.Empty <byte>());
var message = new SomeMessage();
_busMock.SerializerMock.Setup(x => x.Deserialize(typeof(SomeMessage), It.IsAny <byte[]>())).Returns(message);
var ex = new Exception("Something went bad");
_busMock.ConsumerMock.Setup(x => x.OnHandle(message, consumerSettings.Topic))
.Returns(Task.FromException <SomeResponse>(ex));
// act
p.ProcessMessage(message).Wait();
// assert
_busMock.ConsumerMock.Verify(x => x.OnHandle(message, consumerSettings.Topic),
Times.Once); // handler called once
onMessageFaultMock.Verify(x => x(consumerSettings, message, ex), Times.Once); // callback called once
}
public void WhenMessageFails_OnMessageFault_IsCalled()
{
// arrange
var onMessageFaultMock = new Mock <Action <ConsumerSettings, object, Exception> >();
var consumerSettings = new ConsumerSettings
{
Instances = 1,
Topic = "topic1",
ConsumerMode = ConsumerMode.Subscriber,
ConsumerType = typeof(IConsumer <SomeMessage>),
MessageType = typeof(SomeMessage),
OnMessageFault = onMessageFaultMock.Object
};
var p = new ConsumerInstancePool <SomeMessage>(consumerSettings, _busMock.Object, x => new byte[0]);
var message = new SomeMessage();
_serializerMock.Setup(x => x.Deserialize(typeof(SomeMessage), It.IsAny <byte[]>())).Returns(message);
var ex = new Exception("Something went bad");
_consumerMock.Setup(x => x.OnHandle(message, consumerSettings.Topic)).Returns(Task.FromException <SomeResponse>(ex));
// act
p.Submit(message);
var commitedMsg = p.Commit(message);
// assert
commitedMsg.Should().BeSameAs(message); // it should commit the failed message
_consumerMock.Verify(x => x.OnHandle(message, consumerSettings.Topic), Times.Once); // handler called once
onMessageFaultMock.Verify(x => x(consumerSettings, message, ex), Times.Once); // callback called once
}
public async Task When_MessageArrives_And_MessageScopeEnabled_Then_ScopeIsCreated_InstanceIsRetrivedFromScope_ConsumeMethodExecuted()
{
// arrange
var topic = "topic1";
var consumerSettings = new ConsumerBuilder <SomeMessage>(_busMock.Bus.Settings).Topic(topic).WithConsumer <IConsumer <SomeMessage> >().Instances(1).PerMessageScopeEnabled(true).ConsumerSettings;
_busMock.BusMock.Setup(x => x.IsMessageScopeEnabled(consumerSettings)).Returns(true);
var p = new ConsumerInstancePoolMessageProcessor <SomeMessage>(consumerSettings, _busMock.Bus, x => Array.Empty <byte>());
var message = new SomeMessage();
_busMock.SerializerMock.Setup(x => x.Deserialize(typeof(SomeMessage), It.IsAny <byte[]>())).Returns(message);
_busMock.ConsumerMock.Setup(x => x.OnHandle(message, consumerSettings.Topic)).Returns(Task.CompletedTask);
Mock <IDependencyResolver> childScopeMock = null;
_busMock.OnChildDependencyResolverCreated = mock =>
{
childScopeMock = mock;
};
// act
await p.ProcessMessage(message);
// assert
_busMock.ConsumerMock.Verify(x => x.OnHandle(message, consumerSettings.Topic), Times.Once); // handler called once
_busMock.DependencyResolverMock.Verify(x => x.CreateScope(), Times.Once);
_busMock.ChildDependencyResolverMocks.Count.Should().Be(0); // it has been disposed
childScopeMock.Should().NotBeNull();
childScopeMock.Verify(x => x.Resolve(typeof(IConsumer <SomeMessage>)), Times.Once);
}
public void EstablishesCurrentPrincipalWhenHandledMessageHasUserName()
{
// arrange
IPrincipal currentPrincipal = null;
var resetEvent = new ManualResetEvent(false);
adapter.Handle <SomeMessage>(m =>
{
// snatch it!
currentPrincipal = Thread.CurrentPrincipal;
resetEvent.Set();
});
var message = new SomeMessage();
bus.AttachHeader(message, Headers.UserName, "mownz");
// act
bus.SendLocal(message);
resetEvent.WaitOne();
// assert
currentPrincipal.ShouldNotBe(null);
currentPrincipal.Identity.Name.ShouldBe("mownz");
}
public void When_MessageArrives_Then_OnMessageArrivedIsCalled()
{
// arrange
var onMessageArrivedMock = new Mock <Action <IMessageBus, AbstractConsumerSettings, object, string> >();
var topic = "topic1";
_busMock.Bus.Settings.OnMessageArrived = onMessageArrivedMock.Object;
var consumerSettings = new ConsumerBuilder <SomeMessage>(_busMock.Bus.Settings).Topic(topic).WithConsumer <IConsumer <SomeMessage> >().Instances(1).ConsumerSettings;
consumerSettings.OnMessageArrived = onMessageArrivedMock.Object;
var p = new ConsumerInstancePoolMessageProcessor <SomeMessage>(consumerSettings, _busMock.Bus, x => Array.Empty <byte>());
var message = new SomeMessage();
_busMock.SerializerMock.Setup(x => x.Deserialize(typeof(SomeMessage), It.IsAny <byte[]>())).Returns(message);
_busMock.ConsumerMock.Setup(x => x.OnHandle(message, consumerSettings.Topic))
.Returns(Task.CompletedTask);
// act
p.ProcessMessage(message).Wait();
// assert
_busMock.ConsumerMock.Verify(x => x.OnHandle(message, consumerSettings.Topic),
Times.Once); // handler called once
onMessageArrivedMock.Verify(x => x(_busMock.Bus, consumerSettings, message, topic), Times.Exactly(2)); // callback called once for consumer and bus level
}
public void When_MessageFails_Then_OnMessageFaultIsCalled()
{
// arrange
var onMessageFaultMock = new Mock <Action <IMessageBus, AbstractConsumerSettings, object, Exception> >();
var consumerSettings = new ConsumerBuilder <SomeMessage>(new MessageBusSettings()).Topic("topic1").WithConsumer <IConsumer <SomeMessage> >().Instances(1).ConsumerSettings;
consumerSettings.OnMessageFault = onMessageFaultMock.Object;
var p = new ConsumerInstancePoolMessageProcessor <SomeMessage>(consumerSettings, _busMock.Bus, x => Array.Empty <byte>());
var message = new SomeMessage();
_busMock.SerializerMock.Setup(x => x.Deserialize(typeof(SomeMessage), It.IsAny <byte[]>())).Returns(message);
var ex = new Exception("Something went bad");
_busMock.ConsumerMock.Setup(x => x.OnHandle(message, consumerSettings.Topic))
.Returns(Task.FromException <SomeResponse>(ex));
// act
p.ProcessMessage(message).Wait();
// assert
_busMock.ConsumerMock.Verify(x => x.OnHandle(message, consumerSettings.Topic),
Times.Once); // handler called once
onMessageFaultMock.Verify(x => x(_busMock.Bus, consumerSettings, message, ex), Times.Once); // callback called once
}
private void Process(SomeMessage msg)
{
// Modify the actor state
Acc.Desc1 = "Hi jon the time is: " + DateTime.Now;
SaveSnapshot(Acc);
_log.Debug("Processing SaveSnapshot in testactor, ID={0}", Acc.AccountID);
}
public void Should_update_byref_param_if_any()
{
// Arrange
var coordinator = Substitute.For <IRpcClientCoordinator>();
coordinator.Send(Arg.Any <RpcRequest>())
.Returns(new RpcResponse
{
ChangedParams = new Dictionary <string, object> {
{ "message", new SomeMessage {
Money = "$1000"
} }
}
});
var interceptor = new RpcClientInterceptor(coordinator);
var service = RpcFactory.CreateClient <ISomeService>(interceptor);
// Action
var message = new SomeMessage();
service.SaveNotAsync(ref message);
Assert.AreEqual("$1000", message.Money);
}
public void When_Subscribe_Two_Handler_After_Add_A_Rule_Should_Handlers_Execute()
{
var messagebus = new UniRxMessageBus();
// Define some const
const string firstHandlerName = "handler First";
const string secondHandlerName = "handler Second";
const string firstMessageString = firstHandlerName + "_Message";
// Create Messages
var firstMessage = new SomeMessage(firstMessageString, string.Empty, DateTime.UtcNow);
// Create Handlers
var firstHandler = new SomeMessageHandler(firstHandlerName);
var secondHandler = new SomeMessageHandler(secondHandlerName);
// Add Rules
messagebus.AddRule(MessageRouteRule.Create <SomeMessage, SomeMessageHandler>(firstHandlerName + "_Rule", false, null, null, null));
// Subscribe handlers
messagebus.Subscribe <SomeMessageHandler, SomeMessage>(firstHandler,
new MessageHandlerActionExecutor <SomeMessage>(msg => firstHandler.Handle(msg)));
messagebus.Subscribe <SomeMessageHandler, SomeMessage>(secondHandler,
new MessageHandlerActionExecutor <SomeMessage>(msg => secondHandler.Handle(msg)));
// Raise events
messagebus.RaiseEvent(firstMessage);
// Assertions
Assert.AreEqual(1, firstHandler.HandleCallCount, CreateAssetMessage(firstHandler, 0));
Assert.AreEqual(1, secondHandler.HandleCallCount, CreateAssetMessage(secondHandler, 1));
}
public void Handle(SomeMessage message)
{
var color = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("Handling the message with {0}", _messageProvider.GetMessage());
Console.ForegroundColor = color;
}
public async Task CutsLongJsonIncludedInDeserializationExceptionIfItIsTooLong()
{
var embeddedObjects = Enumerable.Range(0, 300)
.Select(n => new EmbeddedObject($"HEJ MED DIG MIN VEN - DET HER ER BESKED {n}"));
var someMessage = new SomeMessage(embeddedObjects.ToList());
var headers = new Dictionary <string, string>();
var message = new Message(headers, someMessage);
var transportMessage = await _serializer.Serialize(message);
var jsonText = Encoding.UTF8.GetString(transportMessage.Body);
Console.WriteLine();
Console.WriteLine($"JSON text length: {jsonText.Length}");
Console.WriteLine();
BreakMessage(transportMessage);
var aggregateException = Assert.Throws <AggregateException>(() =>
{
_serializer.Deserialize(transportMessage).Wait();
});
Console.WriteLine(aggregateException);
}
public async Task Handle(SomeMessage message)
{
Console.WriteLine(@"
Executing Handler1
");
_events.Enqueue("Handled by Handler1");
}
public SomeMessage Build()
{
// Check for optional fields etc here
SomeMessage ret = message;
message = null; // Builder is invalid after this
return(ret);
}
public void Handle(SomeMessage message)
{
if (IsNew)
{
Data.SagaDataId = message.SagaDataId;
}
Data.ReceivedMessages++;
}
public void schema_should_support_complex_types_specific_fields()
{
var message = new SomeMessage();
var factory = new RequiredFieldFactory();
var fields = factory.GetRequiredFields(new { message.SomeClass }.GetType());
fields.Should().HaveCount(3);
fields.Should().Contain(new ClassRequiredField("SomeClass", 0, "SomeClass"));
}
public void schema_should_support_simple_collections_specific_fields()
{
var message = new SomeMessage();
var factory = new RequiredFieldFactory();
var fields = factory.GetRequiredFields(new { message.DatesProperty }.GetType());
fields.Should().HaveCount(1);
fields.Should().Contain(new SimpleCollectionRequiredField("DatesProperty", 0, TypesNamesConsts.CollectionOf + "System.DateTime"));
}
private IEnumerable <Waiter> MessageCoroutine()
{
SomeMessage message = null;
yield return(WaitForMessage <SomeMessage>((x) => message = x));
Count = 1;
Assert.AreNotEqual(null, message);
}
//public SomeHandler2(ISecurityService security, ILoggingService log)
//{
//}
public void Handle(SomeMessage message)
{
//Logger.Log
//Security.CheckForSecurity
var color = Console.ForegroundColor;
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("Handling the message");
Console.ForegroundColor = color;
}
static TimeSpan RunTest(int numberOfMessages, PipelineStepProfilerStats profilerStats)
{
using (var adapter = new BuiltinHandlerActivator())
{
var network = new InMemNetwork();
Configure.With(adapter)
.Logging(l => l.Console(LogLevel.Warn))
.Transport(t => t.UseInMemoryTransport(network, "perftest"))
.Options(o =>
{
o.SetNumberOfWorkers(0);
o.SetMaxParallelism(1);
o.Decorate <IPipeline>(c => new PipelineStepProfiler(c.Get <IPipeline>(), profilerStats));
o.Register <IPipelineInvoker>(c => new DefaultPipelineInvoker(c.Get <IPipeline>()));
})
.Start();
var serializer = new SystemTextJsonSerializer(new SimpleAssemblyQualifiedMessageTypeNameConvention());
var boy = new SomeMessage("hello there!");
for (var counter = 0; counter < numberOfMessages; counter++)
{
var headers = new Dictionary <string, string> {
{ Headers.MessageId, Guid.NewGuid().ToString() }
};
var message = new Message(headers, boy);
var transportMessage = serializer.Serialize(message).Result;
var inMemTransportMessage = transportMessage.ToInMemTransportMessage();
network.Deliver("perftest", inMemTransportMessage);
}
;
var numberOfReceivedMessages = 0;
var gotAllMessages = new ManualResetEvent(false);
adapter.Handle <SomeMessage>(async m =>
{
Interlocked.Increment(ref numberOfReceivedMessages);
if (Volatile.Read(ref numberOfReceivedMessages) == numberOfMessages)
{
gotAllMessages.Set();
}
});
var stopwatch = Stopwatch.StartNew();
adapter.Bus.Advanced.Workers.SetNumberOfWorkers(1);
gotAllMessages.WaitOrDie(TimeSpan.FromSeconds(30));
return(stopwatch.Elapsed);
}
}
public void schema_should_support_simple_types_specific_fields()
{
var message = new SomeMessage();
var factory = new RequiredFieldFactory();
var fields = factory.GetRequiredFields(new { message.DateProperty, message.IntProperty }.GetType());
fields.Should().HaveCount(2);
fields.Should().Contain(new SimpleRequiredField("IntProperty", 0, "System.Int32"));
fields.Should().Contain(new SimpleRequiredField("DateProperty", 0, "System.DateTime"));
}
public void Can_use_delegate_to_subscribe_to_message()
{
var eventAggregator = new EventAggregator();
SomeMessage messageTrapped = null;
eventAggregator.AddListenerAction <SomeMessage>(msg => { messageTrapped = msg; });
eventAggregator.SendMessage <SomeMessage>();
messageTrapped.ShouldNotBeNull();
}
public void ThrowsIfNoHandlersCanBeFound()
{
// arrange
var theMessage = new SomeMessage();
// act
var ex = Assert.Throws <UnhandledMessageException>(() => dispatcher.Dispatch(theMessage));
// assert
ex.UnhandledMessage.ShouldBe(theMessage);
}
public void Can_use_unsubscribe_from_delegate_handler()
{
var eventAggregator = new EventAggregator();
SomeMessage messageTrapped = null;
var disposable = eventAggregator.AddListenerAction <SomeMessage>(msg => { messageTrapped = msg; });
disposable.Dispose();
eventAggregator.SendMessage <SomeMessage>();
messageTrapped.ShouldBeNull();
}
public void Connection_CommonMessageObjectTest()
{
var content = new SomeMessage(1, "varA");
var message = new RequestMessageData <SomeMessage>(content);
Assert.IsNotNull(message);
Assert.IsNull(message.PublishChannel);
Assert.IsNull(message.CacheKey);
Assert.AreEqual(message.Data, content);
Assert.IsTrue(message.Data is SomeMessage);
}
static TimeSpan RunTest(int numberOfMessages, PipelineStepProfilerStats profilerStats)
{
using (var adapter = new BuiltinHandlerActivator())
{
var network = new InMemNetwork();
Configure.With(adapter)
.Logging(l => l.Console(LogLevel.Warn))
.Transport(t => t.UseInMemoryTransport(network, "perftest"))
.Options(o =>
{
o.SetNumberOfWorkers(0);
o.SetMaxParallelism(1);
o.Decorate<IPipeline>(c => new PipelineStepProfiler(c.Get<IPipeline>(), profilerStats));
})
.Start();
var serializer = new JsonSerializer();
var boy = new SomeMessage("hello there!");
numberOfMessages.Times(() =>
{
var headers = new Dictionary<string, string> { { Headers.MessageId, Guid.NewGuid().ToString() } };
var message = new Message(headers, boy);
var transportMessage = serializer.Serialize(message).Result;
var inMemTransportMessage = transportMessage.ToInMemTransportMessage();
network.Deliver("perftest", inMemTransportMessage);
});
var numberOfReceivedMessages = 0;
var gotAllMessages = new ManualResetEvent(false);
adapter.Handle<SomeMessage>(async m =>
{
numberOfReceivedMessages++;
if (numberOfReceivedMessages == numberOfMessages)
{
gotAllMessages.Set();
}
});
var stopwatch = Stopwatch.StartNew();
adapter.Bus.Advanced.Workers.SetNumberOfWorkers(1);
gotAllMessages.WaitOrDie(TimeSpan.FromSeconds(30));
return stopwatch.Elapsed;
}
}
public async Task CanRoundtripSimpleObject()
{
const string text = "hej med dig min ven";
var someMessage = new SomeMessage {
Text = text
};
var someMessageRoundtripped = await Roundtrip(someMessage);
Assert.That(someMessageRoundtripped, Is.TypeOf <SomeMessage>());
Assert.That(((SomeMessage)someMessageRoundtripped).Text, Is.EqualTo(text));
}
public async Task When_Send_Then_RoutesToProperBus()
{
// arrange
Mock <MessageBusBase> bus1Mock = null;
Mock <MessageBusBase> bus2Mock = null;
_providerSettings["bus1"] = (mbb) =>
{
mbb.Produce <SomeMessage>(x => x.DefaultTopic("topic1")).WithProvider(mbs =>
{
bus1Mock = new Mock <MessageBusBase>(new[] { mbs });
bus1Mock.SetupGet(x => x.Settings).Returns(mbs);
bus1Mock.Setup(x => x.Publish(It.IsAny <SomeMessage>(), It.IsAny <string>())).Returns(Task.CompletedTask);
return(bus1Mock.Object);
});
};
_providerSettings["bus2"] = (mbb) =>
{
mbb.Produce <SomeRequest>(x => x.DefaultTopic("topic2")).WithProvider(mbs =>
{
bus2Mock = new Mock <MessageBusBase>(new[] { mbs });
bus2Mock.SetupGet(x => x.Settings).Returns(mbs);
bus2Mock.Setup(x => x.Send(It.IsAny <SomeRequest>(), It.IsAny <string>(), default)).Returns(Task.FromResult(new SomeResponse()));
return(bus2Mock.Object);
});
};
var someMessage = new SomeMessage();
var someDerivedMessage = new SomeDerivedMessage();
var someRequest = new SomeRequest();
var someDerivedRequest = new SomeDerivedRequest();
// act
await _subject.Value.Publish(someMessage);
await _subject.Value.Publish(someDerivedMessage);
await _subject.Value.Send(someRequest);
await _subject.Value.Send(someDerivedRequest);
// assert
bus1Mock.Verify(x => x.Publish(someMessage, null), Times.Once);
bus1Mock.Verify(x => x.Publish <SomeMessage>(someDerivedMessage, null), Times.Once);
bus2Mock.Verify(x => x.Send(someRequest, null, default), Times.Once);
bus2Mock.Verify(x => x.Send(someDerivedRequest, null, default), Times.Once);
}
public async Task <IActionResult> Index()
{
Console.Write(JsonConvert.SerializeObject(new
{
Method = $"{GetType().Name}.Index",
Thread.CurrentThread.ManagedThreadId,
}, Formatting.Indented));
//send a message based on your incoming arguments to one of the actors you created earlier
//and await the result by sending the message to `Ask`
SomeRequest someRequest = new SomeRequest(DateTime.Now, Guid.NewGuid().ToString());
SomeMessage someMessage = new SomeMessage(someRequest.Date, someRequest.Guid);
SomeResult result = await Program.MyActor.Ask <SomeResult>(someMessage);
return(View(result));
}
public Task Handle(SomeMessage message, IMessageHandlerContext context)
{
if (testContext.ReceiveCompleted != null)
{
return(Task.CompletedTask);
}
testContext.NativeMessageId = context.Extensions.Get <IncomingMessage>().NativeMessageId;
if (message.Throw)
{
throw new Exception("Simulated failure");
}
return(Task.CompletedTask);
}
public void When_Subscribe_Before_Add_Rule_Should_Handler_Execute()
{
var messagebus = new UniRxMessageBus();
var handler = new SomeMessageHandler(string.Empty);
messagebus.Subscribe <SomeMessageHandler, SomeMessage>(handler,
new MessageHandlerActionExecutor <SomeMessage>(msg => handler.Handle(msg)));
messagebus.AddRule(MessageRouteRule.Create <SomeMessage, SomeMessageHandler>(string.Empty, false));
var message = new SomeMessage("First message", string.Empty, DateTime.UtcNow);
messagebus.RaiseEvent(message);
Assert.AreEqual(1, handler.HandleCallCount);
}
public void ThrowsIfTwoSagaHandlersArePresentInHandlerPipeline()
{
// arrange
activator.UseHandler(new FirstSaga());
activator.UseHandler(new SecondSaga());
var messageThatCanBeHandledByBothSagas = new SomeMessage();
// act
var exception =
Assert.Throws <MultipleSagaHandlersFoundException>(
() => dispatcher.Dispatch(messageThatCanBeHandledByBothSagas));
// assert
exception.Message.ShouldContain("FirstSaga");
exception.Message.ShouldContain("SecondSaga");
exception.Message.ShouldContain("SomeMessage");
}
public void Should_send_async_if_method_is_async()
{
// Arrange
var coordinator = Substitute.For <IRpcClientCoordinator>();
coordinator.Send(Arg.Any <RpcRequest>())
.Returns(new RpcResponse());
var interceptor = new RpcClientInterceptor(coordinator);
var service = RpcFactory.CreateClient <ISomeService>(interceptor);
// Assert
var msg = new SomeMessage();
service.Save(ref msg);
// Assert
coordinator.Received(1).SendAsync(Arg.Is <RpcRequest>(arg => arg.UtcExpiryTime == null));
}
public void Should_update_byref_param_if_any()
{
// Arrange
var coordinator = Substitute.For<IRpcClientCoordinator>();
coordinator.Send(Arg.Any<RpcRequest>())
.Returns(new RpcResponse
{
ChangedParams = new Dictionary<string, object> { { "message", new SomeMessage{Money = "$1000"} } }
});
var interceptor = new RpcClientInterceptor(coordinator);
var service = RpcFactory.CreateClient<ISomeService>(interceptor);
// Action
var message = new SomeMessage();
service.SaveNotAsync(ref message);
Assert.AreEqual("$1000", message.Money);
}
public void Should_send_async_if_method_is_async()
{
// Arrange
var coordinator = Substitute.For<IRpcClientCoordinator>();
coordinator.Send(Arg.Any<RpcRequest>())
.Returns(new RpcResponse());
var interceptor = new RpcClientInterceptor(coordinator);
var service = RpcFactory.CreateClient<ISomeService>(interceptor);
// Assert
var msg = new SomeMessage();
service.Save(ref msg);
// Assert
coordinator.Received(1).SendAsync(Arg.Is<RpcRequest>(arg => arg.UtcExpiryTime == null));
}
