public void TimerShouldGetMessagesFromAggregatorAndExecuteHandler()
{
// Arrange
var mockPersistor = new Mock <IAggregatorPersistor>();
var mockContainer = new Mock <IBusContainer>();
var timer = new AggregatorProcessor(mockPersistor.Object, mockContainer.Object, typeof(FakeAggregator));
mockPersistor.Setup(x => x.Count(typeof(FakeMessage1).AssemblyQualifiedName)).Returns(1);
var aggregator = new FakeAggregator();
var message = new FakeMessage1(Guid.NewGuid());
mockContainer.Setup(x => x.GetInstance(typeof(FakeAggregator))).Returns(aggregator);
mockPersistor.Setup(x => x.GetData(typeof(FakeMessage1).AssemblyQualifiedName)).Returns(new List <object> {
message
});
// Act
timer.StartTimer <FakeMessage1>(new TimeSpan(0, 0, 0, 0, 50));
Thread.Sleep(90);
// Assert
mockPersistor.Verify(x => x.GetData(typeof(FakeMessage1).AssemblyQualifiedName), Times.Once);
Assert.Equal(1, aggregator.Messages.Count);
Assert.Equal(message, aggregator.Messages.First());
timer.Dispose();
}
public void StartMessageShouldCallProcessMessageOnStreamProcessor()
{
// Arrange
var bus = new Bus(_mockConfiguration.Object);
var mockStream = new Mock <IMessageBusReadStream>();
mockStream.Setup(x => x.HandlerCount).Returns(1);
_mockConsumer.Setup(x => x.StartConsuming(It.IsAny <string>(), It.IsAny <IList <string> >(), It.Is <ConsumerEventHandler>(y => AssignEventHandler(y)), It.IsAny <IConfiguration>()));
var mockProcessor = new Mock <IStreamProcessor>();
_mockContainer.Setup(x => x.GetInstance <IStreamProcessor>(It.Is <Dictionary <string, object> >(y => y["container"] == _mockContainer.Object))).Returns(mockProcessor.Object);
mockProcessor.Setup(x => x.ProcessMessage(It.IsAny <FakeMessage1>(), mockStream.Object));
_mockConfiguration.Setup(x => x.GetMessageBusReadStream()).Returns(mockStream.Object);
var message = new FakeMessage1(Guid.NewGuid())
{
Username = "******"
};
bus.StartConsuming();
// Act
_fakeEventHandler(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message)), typeof(FakeMessage1).AssemblyQualifiedName, new Dictionary <string, object>
{
{ "Start", "" },
{ "SequenceId", Encoding.UTF8.GetBytes("TestSequence") },
{ "SourceAddress", Encoding.UTF8.GetBytes("Source") },
{ "RequestMessageId", Encoding.UTF8.GetBytes("MessageId") },
{ "MessageType", Encoding.UTF8.GetBytes("ByteStream") }
});
// Assert
mockProcessor.Verify(x => x.ProcessMessage(It.Is <FakeMessage1>(y => y.Username == "Tim"), It.IsAny <IMessageBusReadStream>()), Times.Once);
}
public void ShouldExecuteAsyncHandler()
{
// Arrange
var messageProcessor = new MessageHandlerProcessor(_mockContainer.Object);
var message1HandlerReference = new HandlerReference
{
HandlerType = typeof(FakeAsyncHandler),
MessageType = typeof(FakeMessage1)
};
_mockContainer.Setup(x => x.GetHandlerTypes(typeof(IMessageHandler <FakeMessage1>), typeof(IAsyncMessageHandler <FakeMessage1>))).Returns(new List <HandlerReference>
{
message1HandlerReference
});
var fakeHandler = new FakeAsyncHandler();
_mockContainer.Setup(x => x.GetInstance(typeof(FakeAsyncHandler))).Returns(fakeHandler);
// Act
var message1 = new FakeMessage1(Guid.NewGuid());
messageProcessor.ProcessMessage <FakeMessage1>(JsonConvert.SerializeObject(message1),
new ConsumeContext {
Headers = new Dictionary <string, object>()
}).GetAwaiter().GetResult();;
// Assert
Assert.Equal(true, fakeHandler.Executed);
}
public void PublishWithRoutingKeyShouldPublishMessage()
{
// Arrange
var mockConfiguration = new Mock <IConfiguration>();
var mockProducer = new Mock <IProducer>();
var mockContainer = new Mock <IBusContainer>();
var mockProessManagerFinder = new Mock <IProcessManagerFinder>();
var mockSendMessagePipeline = new Mock <ISendMessagePipeline>();
mockConfiguration.Setup(x => x.GetSendMessagePipeline()).Returns(mockSendMessagePipeline.Object);
mockConfiguration.Setup(x => x.GetContainer()).Returns(mockContainer.Object);
mockConfiguration.Setup(x => x.GetProcessManagerFinder()).Returns(mockProessManagerFinder.Object);
mockConfiguration.Setup(x => x.GetProducer()).Returns(mockProducer.Object);
mockConfiguration.SetupGet(x => x.TransportSettings).Returns(new TransportSettings());
var message = new FakeMessage1(Guid.NewGuid())
{
Username = "******"
};
mockProducer.Setup(x => x.Publish(typeof(FakeMessage1), It.IsAny <byte[]>(), null));
// Act
var bus = new ServiceConnect.Bus(mockConfiguration.Object);
bus.Publish(message, "routingkey1");
// Assert
mockSendMessagePipeline.Setup(x => x.ExecutePublishMessagePipeline(typeof(FakeMessage1), It.IsAny <byte[]>(), It.Is <Dictionary <string, string> >(i => i.ContainsKey("RoutingKey")), It.IsAny <string>()));
}
public void SendingRequestWithEndpointAndCallbackShouldSendMessageToTheSpecifiedEndPoint()
{
// Arrange
var mockConfiguration = new Mock <IConfiguration>();
var mockProducer = new Mock <IProducer>();
var mockContainer = new Mock <IBusContainer>();
var mockRequestConfiguration = new Mock <IRequestConfiguration>();
var mockSendMessagePipeline = new Mock <ISendMessagePipeline>();
mockConfiguration.Setup(x => x.GetSendMessagePipeline()).Returns(mockSendMessagePipeline.Object);
mockConfiguration.Setup(x => x.GetContainer()).Returns(mockContainer.Object);
mockConfiguration.Setup(x => x.GetProducer()).Returns(mockProducer.Object);
mockConfiguration.SetupGet(x => x.TransportSettings).Returns(new TransportSettings());
mockConfiguration.Setup(x => x.GetRequestConfiguration(It.IsAny <Guid>())).Returns(mockRequestConfiguration.Object);
var task = new Task(() => { });
mockRequestConfiguration.Setup(x => x.SetHandler(It.IsAny <Action <object> >())).Returns(task);
var message = new FakeMessage1(Guid.NewGuid())
{
Username = "******"
};
// Act
var bus = new ServiceConnect.Bus(mockConfiguration.Object);
bus.SendRequest <FakeMessage1, FakeMessage2>("test", message, x => { }, null);
// Assert
mockSendMessagePipeline.Verify(x => x.ExecuteSendMessagePipeline(It.IsAny <Type>(), It.IsAny <byte[]>(), It.IsAny <Dictionary <string, string> >(), "test"), Times.Once);
}
public void SendingRequestSynchronouslyShouldSendCommand()
{
// Arrange
var mockConfiguration = new Mock <IConfiguration>();
var mockProducer = new Mock <IProducer>();
var mockContainer = new Mock <IBusContainer>();
var mockRequestConfiguration = new Mock <IRequestConfiguration>();
var mockSendMessagePipeline = new Mock <ISendMessagePipeline>();
mockConfiguration.Setup(x => x.GetSendMessagePipeline()).Returns(mockSendMessagePipeline.Object);
mockConfiguration.Setup(x => x.GetContainer()).Returns(mockContainer.Object);
mockConfiguration.Setup(x => x.GetProducer()).Returns(mockProducer.Object);
mockConfiguration.SetupGet(x => x.TransportSettings).Returns(new TransportSettings());
mockConfiguration.Setup(x => x.GetRequestConfiguration(It.IsAny <Guid>())).Returns(mockRequestConfiguration.Object);
var task = new Task(() => { });
mockRequestConfiguration.Setup(x => x.SetHandler(It.IsAny <Action <object> >())).Returns(task);
var message = new FakeMessage1(Guid.NewGuid())
{
Username = "******"
};
mockSendMessagePipeline.Setup(x => x.ExecuteSendMessagePipeline(typeof(FakeMessage1), It.IsAny <byte[]>(), It.IsAny <Dictionary <string, string> >(), It.IsAny <string>())).Callback(task.Start);
// Act
var bus = new ServiceConnect.Bus(mockConfiguration.Object);
FakeMessage2 response = bus.SendRequest <FakeMessage1, FakeMessage2>(message, null, 1000);
// Assert
mockSendMessagePipeline.Verify(x => x.ExecuteSendMessagePipeline(typeof(FakeMessage1), It.IsAny <byte[]>(), It.IsAny <Dictionary <string, string> >(), null), Times.Once);
}
public void SendShouldSendCommandUsingSpecifiedEndpoint()
{
// Arrange
var mockConfiguration = new Mock <IConfiguration>();
var mockProducer = new Mock <IProducer>();
var mockContainer = new Mock <IBusContainer>();
var mockProessManagerFinder = new Mock <IProcessManagerFinder>();
var mockSendMessagePipeline = new Mock <ISendMessagePipeline>();
mockConfiguration.Setup(x => x.GetSendMessagePipeline()).Returns(mockSendMessagePipeline.Object);
mockConfiguration.Setup(x => x.GetContainer()).Returns(mockContainer.Object);
mockConfiguration.Setup(x => x.GetProcessManagerFinder()).Returns(mockProessManagerFinder.Object);
mockConfiguration.Setup(x => x.GetProducer()).Returns(mockProducer.Object);
mockConfiguration.SetupGet(x => x.TransportSettings).Returns(new TransportSettings());
var message = new FakeMessage1(Guid.NewGuid())
{
Username = "******"
};
const string endPoint = "MyEndPoint";
mockProducer.Setup(x => x.Send(endPoint, typeof(FakeMessage1), It.IsAny <byte[]>(), null));
// Act
var bus = new ServiceConnect.Bus(mockConfiguration.Object);
bus.Send(endPoint, message, null);
// Assert
mockSendMessagePipeline.Verify(x => x.ExecuteSendMessagePipeline(typeof(FakeMessage1), It.IsAny <byte[]>(), It.IsAny <Dictionary <string, string> >(), endPoint), Times.Once);
}
public async Task ShouldSendMessageToAggregatorProcessor()
{
_mockConfiguration.SetupGet(x => x.MessageProcessingMiddleware).Returns(new List <Type>());
var message = new FakeMessage1(Guid.NewGuid())
{
Username = "******"
};
var processor = new Mock <IAggregatorProcessor>();
processor.Setup(x => x.ProcessMessage <FakeMessage1>(JsonConvert.SerializeObject(message)));
var busState = new BusState();
busState.AggregatorProcessors[typeof(FakeMessage1)] = processor.Object;
var pipeline = new ProcessMessagePipeline(_mockConfiguration.Object, busState);
await pipeline.ExecutePipeline(_consumeContext, typeof(FakeMessage1), new Envelope
{
Headers = new Dictionary <string, object>(),
Body = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message))
});
processor.Verify(x => x.ProcessMessage <FakeMessage1>(It.Is <string>(y => JsonConvert.DeserializeObject <FakeMessage1>(y).Username == "Tim")), Times.Once);
}
public void TimerShouldRemoveAllProcessedMessagesFromPersistor()
{
// Arrange
var mockPersistor = new Mock <IAggregatorPersistor>();
var mockContainer = new Mock <IBusContainer>();
var timer = new AggregatorProcessor(mockPersistor.Object, mockContainer.Object, typeof(FakeAggregator));
mockPersistor.Setup(x => x.Count(typeof(FakeMessage1).AssemblyQualifiedName)).Returns(1);
var aggregator = new FakeAggregator();
var message = new FakeMessage1(Guid.NewGuid());
mockContainer.Setup(x => x.GetInstance(typeof(FakeAggregator))).Returns(aggregator);
mockPersistor.Setup(x => x.GetData(typeof(FakeMessage1).AssemblyQualifiedName)).Returns(new List <object> {
message
});
// Act
timer.StartTimer <FakeMessage1>(new TimeSpan(0, 0, 0, 0, 50));
Thread.Sleep(100);
// Assert
mockPersistor.Verify(x => x.RemoveData(typeof(FakeMessage1).AssemblyQualifiedName, message.CorrelationId), Times.Once);
timer.Dispose();
}
public void SendingRequestToMultipleEndpointsSynchronouslyShouldReturnResponses()
{
// Arrange
var mockConfiguration = new Mock <IConfiguration>();
var mockProducer = new Mock <IProducer>();
var mockContainer = new Mock <IBusContainer>();
var mockRequestConfiguration = new Mock <IRequestConfiguration>();
var mockSendMessagePipeline = new Mock <ISendMessagePipeline>();
mockConfiguration.Setup(x => x.GetSendMessagePipeline()).Returns(mockSendMessagePipeline.Object);
mockConfiguration.Setup(x => x.GetContainer()).Returns(mockContainer.Object);
mockConfiguration.Setup(x => x.GetProducer()).Returns(mockProducer.Object);
mockConfiguration.SetupGet(x => x.TransportSettings).Returns(new TransportSettings());
mockConfiguration.Setup(x => x.GetRequestConfiguration(It.IsAny <Guid>())).Returns(mockRequestConfiguration.Object);
var task = new Task(() => { });
Action <FakeMessage2> action = null;
mockRequestConfiguration.Setup(x => x.SetHandler(It.IsAny <Action <object> >())).Returns(task).Callback <Action <FakeMessage2> >(r =>
{
action = r;
});
var message = new FakeMessage1(Guid.NewGuid())
{
Username = "******"
};
var r1 = new FakeMessage2(Guid.NewGuid());
var r2 = new FakeMessage2(Guid.NewGuid());
mockSendMessagePipeline.Setup(x => x.ExecuteSendMessagePipeline(It.IsAny <Type>(), It.IsAny <byte[]>(), It.IsAny <Dictionary <string, string> >(), "test1")).Callback(() =>
{
action(r1);
});
mockSendMessagePipeline.Setup(x => x.ExecuteSendMessagePipeline(It.IsAny <Type>(), It.IsAny <byte[]>(), It.IsAny <Dictionary <string, string> >(), "test2")).Callback(() =>
{
action(r2);
task.Start();
});
// Act
var bus = new ServiceConnect.Bus(mockConfiguration.Object);
IList <FakeMessage2> responses = bus.SendRequest <FakeMessage1, FakeMessage2>(new List <string> {
"test1", "test2"
}, message, null, 1000);
// Assert
Assert.Equal(2, responses.Count);
Assert.True(responses.Contains(r1));
Assert.True(responses.Contains(r2));
}
public void SendingRequestToMultipleEndpointsShouldPassResponsesToCallbackHandler()
{
// Arrange
var mockConfiguration = new Mock <IConfiguration>();
var mockProducer = new Mock <IProducer>();
var mockContainer = new Mock <IBusContainer>();
var mockRequestConfiguration = new Mock <IRequestConfiguration>();
var mockSendMessagePipeline = new Mock <ISendMessagePipeline>();
mockConfiguration.Setup(x => x.GetSendMessagePipeline()).Returns(mockSendMessagePipeline.Object);
mockConfiguration.Setup(x => x.GetContainer()).Returns(mockContainer.Object);
mockConfiguration.Setup(x => x.GetProducer()).Returns(mockProducer.Object);
mockConfiguration.SetupGet(x => x.TransportSettings).Returns(new TransportSettings());
mockConfiguration.Setup(x => x.GetRequestConfiguration(It.IsAny <Guid>())).Returns(mockRequestConfiguration.Object);
var task = new Task(() => { });
int count = 0;
var r1 = new FakeMessage2(Guid.NewGuid());
var r2 = new FakeMessage2(Guid.NewGuid());
var responses = new List <FakeMessage2>();
Action <FakeMessage2> action = message2 =>
{
count++;
responses.Add(message2);
};
mockRequestConfiguration.Setup(x => x.SetHandler(It.IsAny <Action <object> >())).Callback <Action <object> >(a =>
{
a(r1);
a(r2);
}).Returns(task);
var message = new FakeMessage1(Guid.NewGuid())
{
Username = "******"
};
mockProducer.Setup(x => x.Send(It.IsAny <Type>(), It.IsAny <byte[]>(), It.IsAny <Dictionary <string, string> >()));
// Act
var bus = new ServiceConnect.Bus(mockConfiguration.Object);
bus.SendRequest(message, action, null);
// Assert
mockRequestConfiguration.Verify(x => x.SetHandler(It.IsAny <Action <object> >()), Times.Exactly(1));
Assert.Equal(2, count);
Assert.True(responses.Contains(r1));
Assert.True(responses.Contains(r2));
}
public void ConsumeMessageEventShouldStopStreamIfStopMessageIsRecieved()
{
// Arrange
var bus = new Bus(_mockConfiguration.Object);
var mockStream = new Mock <IMessageBusReadStream>();
mockStream.Setup(x => x.HandlerCount).Returns(1);
_mockConsumer.Setup(x => x.StartConsuming(It.IsAny <string>(), It.IsAny <IList <string> >(), It.Is <ConsumerEventHandler>(y => AssignEventHandler(y)), It.IsAny <IConfiguration>()));
var mockProcessor = new Mock <IStreamProcessor>();
_mockContainer.Setup(x => x.GetInstance <IStreamProcessor>(It.Is <Dictionary <string, object> >(y => y["container"] == _mockContainer.Object))).Returns(mockProcessor.Object);
mockProcessor.Setup(x => x.ProcessMessage(It.IsAny <FakeMessage1>(), mockStream.Object));
_mockConfiguration.Setup(x => x.GetMessageBusReadStream()).Returns(mockStream.Object);
var message = new FakeMessage1(Guid.NewGuid())
{
Username = "******"
};
_mockProducer.Setup(x => x.Send("Source", typeof(StreamResponseMessage), It.IsAny <byte[]>(), It.Is <Dictionary <string, string> >(y => y["ResponseMessageId"] == "MessageId")));
bus.StartConsuming();
_fakeEventHandler(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message)), typeof(FakeMessage1).AssemblyQualifiedName, new Dictionary <string, object>
{
{ "Start", "" },
{ "SequenceId", Encoding.UTF8.GetBytes("TestSequence") },
{ "SourceAddress", Encoding.UTF8.GetBytes("Source") },
{ "RequestMessageId", Encoding.UTF8.GetBytes("MessageId") },
{ "MessageType", Encoding.UTF8.GetBytes("ByteStream") },
});
var streamMessage = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
// Act
_fakeEventHandler(streamMessage, typeof(byte[]).AssemblyQualifiedName, new Dictionary <string, object>
{
{ "SequenceId", Encoding.UTF8.GetBytes("TestSequence") },
{ "SourceAddress", Encoding.UTF8.GetBytes("Source") },
{ "RequestMessageId", Encoding.UTF8.GetBytes("MessageId") },
{ "MessageType", Encoding.UTF8.GetBytes("ByteStream") },
{ "PacketNumber", Encoding.UTF8.GetBytes("2") },
{ "Stop", "" }
});
// Assert
mockStream.Verify(x => x.Write(It.IsAny <byte[]>(), It.IsAny <long>()), Times.Never);
mockStream.VerifySet(x => x.LastPacketNumber = 2, Times.Once);
}
public void SendingRequestWithEndpointSynchronouslyShouldReturnResponse()
{
// Arrange
var mockConfiguration = new Mock <IConfiguration>();
var mockProducer = new Mock <IProducer>();
var mockContainer = new Mock <IBusContainer>();
var mockRequestConfiguration = new Mock <IRequestConfiguration>();
var mockSendMessagePipeline = new Mock <ISendMessagePipeline>();
mockConfiguration.Setup(x => x.GetSendMessagePipeline()).Returns(mockSendMessagePipeline.Object);
mockConfiguration.Setup(x => x.GetContainer()).Returns(mockContainer.Object);
mockConfiguration.Setup(x => x.GetProducer()).Returns(mockProducer.Object);
mockConfiguration.SetupGet(x => x.TransportSettings).Returns(new TransportSettings());
mockConfiguration.Setup(x => x.GetRequestConfiguration(It.IsAny <Guid>())).Returns(mockRequestConfiguration.Object);
var task = new Task(() => { });
Action <FakeMessage2> action = null;
mockRequestConfiguration.Setup(x => x.SetHandler(It.IsAny <Action <object> >())).Returns(task)
.Callback <Action <FakeMessage2> >(r => action = r);
var message = new FakeMessage1(Guid.NewGuid())
{
Username = "******"
};
mockSendMessagePipeline.Setup(x => x.ExecuteSendMessagePipeline(It.IsAny <Type>(), It.IsAny <byte[]>(), It.IsAny <Dictionary <string, string> >(), "test")).Callback(() =>
{
action(new FakeMessage2(message.CorrelationId)
{
DisplayName = "Tim Watson",
Email = "*****@*****.**"
});
task.Start();
});
// Act
var bus = new ServiceConnect.Bus(mockConfiguration.Object);
FakeMessage2 response = bus.SendRequest <FakeMessage1, FakeMessage2>("test", message, null, 1000);
// Assert
Assert.Equal("Tim Watson", response.DisplayName);
Assert.Equal("*****@*****.**", response.Email);
Assert.Equal(message.CorrelationId, response.CorrelationId);
}
public void ShouldSendMessageToAggregatorProcessor()
{
// Arrange
var bus = new ServiceConnect.Bus(_mockConfiguration.Object);
_mockConsumer.Setup(x => x.StartConsuming(It.IsAny <string>(), It.IsAny <IList <string> >(), It.Is <ConsumerEventHandler>(y => AssignEventHandler(y)), It.IsAny <IConfiguration>()));
var mockPersistor = new Mock <IAggregatorPersistor>();
var mockProcessor = new Mock <IAggregatorProcessor>();
var fakeAggregator = new FakeAggregator();
_mockConfiguration.Setup(x => x.GetAggregatorPersistor()).Returns(mockPersistor.Object);
_mockConfiguration.Setup(x => x.Threads).Returns(1);
_mockContainer.Setup(x => x.GetInstance <IMessageHandlerProcessor>(It.IsAny <Dictionary <string, object> >())).Returns(new Mock <IMessageHandlerProcessor>().Object);
_mockContainer.Setup(x => x.GetInstance <IProcessManagerProcessor>(It.IsAny <Dictionary <string, object> >())).Returns(new Mock <IProcessManagerProcessor>().Object);
_mockConfiguration.Setup(x => x.GetAggregatorProcessor(It.IsAny <IAggregatorPersistor>(), It.IsAny <IBusContainer>(), It.IsAny <Type>())).Returns(mockProcessor.Object);
_mockContainer.Setup(x => x.GetHandlerTypes()).Returns(new List <HandlerReference>
{
new HandlerReference
{
HandlerType = typeof(FakeAggregator),
MessageType = typeof(FakeMessage1)
}
});
_mockContainer.Setup(x => x.GetInstance(typeof(FakeAggregator))).Returns(fakeAggregator);
var message = new FakeMessage1(Guid.NewGuid())
{
Username = "******"
};
mockProcessor.Setup(x => x.ProcessMessage <FakeMessage1>(JsonConvert.SerializeObject(message)));
bus.StartConsuming();
// Act
_fakeEventHandler(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message)), typeof(FakeMessage1).AssemblyQualifiedName, new Dictionary <string, object>
{
{ "MessageType", Encoding.UTF8.GetBytes("Send") }
});
// Assert
mockProcessor.Verify(x => x.ProcessMessage <FakeMessage1>(It.Is <string>(y => JsonConvert.DeserializeObject <FakeMessage1>(y).Username == "Tim")), Times.Once);
}
public void ShouldExecuteTheCorrectHandlerWithMultipleRoutingKeyAttributes()
{
// Arrange
var messageProcessor = new MessageHandlerProcessor(_mockContainer.Object);
var message1HandlerReference = new HandlerReference
{
HandlerType = typeof(FakeHandlerWithAttr2),
MessageType = typeof(FakeMessage1),
RoutingKeys = new List <string> {
"Test1", "Test2"
}
};
_mockContainer.Setup(x => x.GetHandlerTypes(typeof(IMessageHandler <FakeMessage1>))).Returns(new List <HandlerReference>
{
message1HandlerReference
});
var fakeHandler = new FakeHandlerWithAttr2();
_mockContainer.Setup(x => x.GetInstance(typeof(FakeHandlerWithAttr2))).Returns(fakeHandler);
// Act
var message1 = new FakeMessage1(Guid.NewGuid())
{
Username = "******"
};
messageProcessor.ProcessMessage <FakeMessage1>(JsonConvert.SerializeObject(message1),
new ConsumeContext {
Headers = new Dictionary <string, object> {
{ "RoutingKey", Encoding.ASCII.GetBytes("Test2") }
}
});
// Assert
Assert.Equal(message1.CorrelationId, fakeHandler.Command.CorrelationId);
Assert.Equal(message1.Username, fakeHandler.Command.Username);
_mockContainer.Verify(x => x.GetInstance(typeof(FakeHandlerWithAttr2)), Times.Once);
}
public void ShouldExecuteTheCorrectHandlerWithCatchAllRoutingKeyAttribute()
{
// Arrange
var messageProcessor = new MessageHandlerProcessor(_mockContainer.Object, _mockLogger.Object);
var message1HandlerReference = new HandlerReference
{
HandlerType = typeof(FakeHandlerWithAttr1),
MessageType = typeof(FakeMessage1),
RoutingKeys = new List <string> {
"#"
} // matches any routing key
};
_mockContainer.Setup(x => x.GetHandlerTypes(typeof(IMessageHandler <FakeMessage1>), typeof(IAsyncMessageHandler <FakeMessage1>))).Returns(new List <HandlerReference>
{
message1HandlerReference
});
var fakeHandler = new FakeHandlerWithAttr1();
_mockContainer.Setup(x => x.GetInstance(typeof(FakeHandlerWithAttr1))).Returns(fakeHandler);
// Act
var message1 = new FakeMessage1(Guid.NewGuid())
{
Username = "******"
};
messageProcessor.ProcessMessage <FakeMessage1>(JsonConvert.SerializeObject(message1),
new ConsumeContext {
Headers = new Dictionary <string, object> {
{ "RoutingKey", Encoding.ASCII.GetBytes("SomeRandomRoutingKey") }
}
}).GetAwaiter().GetResult();;
// Assert
Assert.Equal(message1.CorrelationId, fakeHandler.Command.CorrelationId);
Assert.Equal(message1.Username, fakeHandler.Command.Username);
_mockContainer.Verify(x => x.GetInstance(typeof(FakeHandlerWithAttr1)), Times.Once);
}
public void ShouldExecuteTheCorrectHandlers()
{
// Arrange
var messageProcessor = new MessageHandlerProcessor(_mockContainer.Object);
var message1HandlerReference = new HandlerReference
{
HandlerType = typeof(FakeHandler1),
MessageType = typeof(FakeMessage1)
};
_mockContainer.Setup(x => x.GetHandlerTypes(typeof(IMessageHandler <FakeMessage1>))).Returns(new List <HandlerReference>
{
message1HandlerReference
});
var fakeHandler = new FakeHandler1();
_mockContainer.Setup(x => x.GetInstance(typeof(FakeHandler1))).Returns(fakeHandler);
// Act
var message1 = new FakeMessage1(Guid.NewGuid())
{
Username = "******"
};
messageProcessor.ProcessMessage <FakeMessage1>(JsonConvert.SerializeObject(message1), null);
var message2 = new FakeMessage2(Guid.NewGuid())
{
DisplayName = "Tim Watson"
};
messageProcessor.ProcessMessage <FakeMessage2>(JsonConvert.SerializeObject(message2), null);
// Assert
Assert.Equal(message1.CorrelationId, fakeHandler.Command.CorrelationId);
Assert.Equal(message1.Username, fakeHandler.Command.Username);
_mockContainer.Verify(x => x.GetInstance(typeof(FakeHandler2)), Times.Never);
}
public void RouteShouldSendCommandWithRoutingSlipHeader()
{
// Arrange
var mockConfiguration = new Mock <IConfiguration>();
var mockProducer = new Mock <IProducer>();
var mockContainer = new Mock <IBusContainer>();
var mockProessManagerFinder = new Mock <IProcessManagerFinder>();
var mockSendMessagePipeline = new Mock <ISendMessagePipeline>();
mockConfiguration.Setup(x => x.GetSendMessagePipeline()).Returns(mockSendMessagePipeline.Object);
mockConfiguration.Setup(x => x.GetContainer()).Returns(mockContainer.Object);
mockConfiguration.Setup(x => x.GetProcessManagerFinder()).Returns(mockProessManagerFinder.Object);
mockConfiguration.Setup(x => x.GetProducer()).Returns(mockProducer.Object);
mockConfiguration.SetupGet(x => x.TransportSettings).Returns(new TransportSettings());
var message = new FakeMessage1(Guid.NewGuid())
{
Username = "******"
};
const string endPoint1 = "MyEndPoint1";
const string endPoint2 = "MyEndPoint2";
mockProducer.Setup(x => x.Send(endPoint1, It.IsAny <Type>(), It.IsAny <byte[]>(), It.IsAny <Dictionary <string, string> >()));
// Act
var bus = new ServiceConnect.Bus(mockConfiguration.Object);
bus.Route(message, new List <string> {
endPoint1, endPoint2
});
// Assert
mockSendMessagePipeline.Setup(x => x.ExecuteSendMessagePipeline(It.IsAny <Type>(), It.IsAny <byte[]>(), It.Is <Dictionary <string, string> >(i => i.Count == 1), It.IsAny <string>()));
mockSendMessagePipeline.Setup(x => x.ExecuteSendMessagePipeline(It.IsAny <Type>(), It.IsAny <byte[]>(), It.Is <Dictionary <string, string> >(i => i.ContainsKey("RoutingSlip")), It.IsAny <string>()));
mockSendMessagePipeline.Setup(x => x.ExecuteSendMessagePipeline(It.IsAny <Type>(), It.IsAny <byte[]>(), It.Is <Dictionary <string, string> >(i => i.ContainsValue("[\"MyEndPoint2\"]")), It.IsAny <string>()));
}
public void CreateStreamShouldCreateAMessageBusWriteStream()
{
// Arrange
var mockConfiguration = new Mock <IConfiguration>();
var mockProducer = new Mock <IProducer>();
var mockContainer = new Mock <IBusContainer>();
var mockRequestConfiguration = new Mock <IRequestConfiguration>();
var mockStream = new Mock <IMessageBusWriteStream>();
var mockSendMessagePipeline = new Mock <ISendMessagePipeline>();
mockConfiguration.Setup(x => x.GetSendMessagePipeline()).Returns(mockSendMessagePipeline.Object);
mockConfiguration.Setup(x => x.GetContainer()).Returns(mockContainer.Object);
mockConfiguration.Setup(x => x.GetProducer()).Returns(mockProducer.Object);
mockConfiguration.SetupGet(x => x.TransportSettings).Returns(new TransportSettings());
mockConfiguration.Setup(x => x.GetRequestConfiguration(It.IsAny <Guid>())).Returns(mockRequestConfiguration.Object);
mockConfiguration.Setup(x => x.GetMessageBusWriteStream(It.IsAny <IProducer>(), "TestEndpoint", It.IsAny <string>(), It.IsAny <IConfiguration>())).Returns(mockStream.Object);
var task = new Task(() => { });
mockRequestConfiguration.Setup(x => x.SetHandler(It.IsAny <Action <object> >())).Returns(task);
var message = new FakeMessage1(Guid.NewGuid())
{
Username = "******"
};
mockSendMessagePipeline.Setup(x => x.ExecuteSendMessagePipeline(It.IsAny <Type>(), It.IsAny <byte[]>(), It.IsAny <Dictionary <string, string> >(), It.IsAny <string>())).Callback(task.Start);
// Act
var bus = new Bus(mockConfiguration.Object);
// Act
var stream = bus.CreateStream("TestEndpoint", message);
// Assert
Assert.NotNull(stream);
Assert.Equal(mockStream.Object, stream);
}
public void SendingRequestWithEndpointAndCallbackShouldPassCallbackToHandler()
{
// Arrange
var mockConfiguration = new Mock <IConfiguration>();
var mockProducer = new Mock <IProducer>();
var mockContainer = new Mock <IBusContainer>();
var mockRequestConfiguration = new Mock <IRequestConfiguration>();
var mockSendMessagePipeline = new Mock <ISendMessagePipeline>();
mockConfiguration.Setup(x => x.GetSendMessagePipeline()).Returns(mockSendMessagePipeline.Object);
mockConfiguration.Setup(x => x.GetContainer()).Returns(mockContainer.Object);
mockConfiguration.Setup(x => x.GetProducer()).Returns(mockProducer.Object);
mockConfiguration.SetupGet(x => x.TransportSettings).Returns(new TransportSettings());
mockConfiguration.Setup(x => x.GetRequestConfiguration(It.IsAny <Guid>())).Returns(mockRequestConfiguration.Object);
var task = new Task(() => { });
bool actionCalled = false;
Action <FakeMessage2> action = message2 => { actionCalled = true; };
mockRequestConfiguration.Setup(x => x.SetHandler(It.IsAny <Action <object> >())).Callback <Action <object> >(a => a(new FakeMessage2(Guid.NewGuid()))).Returns(task);
var message = new FakeMessage1(Guid.NewGuid())
{
Username = "******"
};
mockProducer.Setup(x => x.Send(It.IsAny <Type>(), It.IsAny <byte[]>(), It.IsAny <Dictionary <string, string> >()));
// Act
var bus = new ServiceConnect.Bus(mockConfiguration.Object);
bus.SendRequest("test", message, action, null);
// Assert
mockRequestConfiguration.Verify(x => x.SetHandler(It.IsAny <Action <object> >()), Times.Once());
Assert.True(actionCalled);
}
public void Execute(FakeMessage1 command)
{
Data.User = command.Username;
}
