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)); }