private IMessagePublisher CreatePublisher(string providerName)
{
var publisher = new EasyNetQPublisher();
publisher.Initialize(providerName);
return(publisher);
}
public ExecutionHandlingStrategyTests()
{
_publisher = new Mock <IPublisher>();
_mockBus = new Mock <IAdvancedBus>();
_modelNamingConventionController = new Mock <IModelNamingConventionController>();
_easyNetQPublisher = new EasyNetQPublisher(_mockBus.Object, _exchangeName, _modelNamingConventionController.Object);
_mockExchange = new Mock <IExchange>();
}
public EasyNetQSubscriberTests()
{
var exchangename = "exchangeName";
_bookingEventType = "bookingcreated";
_version = "0.1";
_bookingName = "bookingName";
_mockBus = new Mock <IAdvancedBus>();
var mockContainer = new Mock <IContainer>();
_mockBus.SetupGet(x => x.Container).Returns(mockContainer.Object);
_mockMainBus = new Mock <IBus>();
_mockMainBus.SetupGet(x => x.Advanced).Returns(_mockBus.Object);
_mockQueue = new Mock <IQueue>();
_prefetchcount = 5;
_modelNamingConventionController = new Mock <IModelNamingConventionController>();
_easyNetQPublisher = new EasyNetQPublisher(_mockBus.Object, exchangename, _modelNamingConventionController.Object);
_consumerDisposable = new Mock <IDisposable>();
_successHandlingStrategy = new Mock <ISuccessHandlingStrategy>();
_successHandlingStrategy.Setup(x => x.HandleSuccessAsync(It.IsAny <IntegrationEvent>()))
.Returns(Task.FromResult(true));
_errorHandlingStrategy = new Mock <IErrorHandlingStrategy>();
_errorHandlingStrategy.Setup(x => x.HandleErrorAsync(It.IsAny <MessageExecutionContext>()))
.Returns(Task.FromResult(true));
_subsciptionSelector = new Mock <ISubscriptionSelector>();
_nameHandle = new Mock <IDisposable>();
var mockEnvironmentNamingConventionController = new Mock <IEnvironmentNamingConventionController>();
_easyNetQBroker = new EasyNetQBroker(
(connectionString, connected, disconnected, registerServices) =>
{
_mockMainBus.Object.Advanced.Disconnected += disconnected;
_mockMainBus.Object.Advanced.Connected += connected;
return(_mockBus.Object);
}, string.Empty, string.Empty, string.Empty, mockEnvironmentNamingConventionController.Object);
_easyNetQSubscriber = new EasyNetQSubscriber(_errorHandlingStrategy.Object, _mockBus.Object,
_mockQueue.Object, _prefetchcount, _subsciptionSelector.Object, _successHandlingStrategy.Object, _nameHandle.Object);
}
static void Main(string[] args)
{
//var publisher = new RabbitMQPublisher();
//var input = Input();
//while (input != "exit")
//{
// var log = new TestMessageEntity
// {
// Platform = "test",
// ClientId = "test_cli",
// Command = 100,
// Data = input,
// Message = "测试消息"
// };
// publisher.Publish(log, ExchangeTypeCode.Direct);
// input = Input();
//}
//publisher.Stop();
EasyNetQPublisher easyNetQPublisher = new EasyNetQPublisher();
var input = Input();
while (input != "exit")
{
var log = new TestMessageEntity
{
Platform = "test",
ClientId = "test_cli",
Command = 100,
Data = input,
Message = "测试消息"
};
easyNetQPublisher.Publish(log);
input = Input();
}
easyNetQPublisher.Stop();
}
public async void PublishDirectEventAsync_MessageMustBeSerializedAndCorrectlyRouted(bool persistant, byte deliveryMode)
{
//prepare
var mockBus = new Mock <IAdvancedBus>();
var mockExchange = new Mock <IExchange>();
var mockModelNamingConventionController = new Mock <IModelNamingConventionController>();
var subscriberName = "subscriber";
var routingKey = string.Concat("direct.", subscriberName);;
IExchange actualExchange = null;
string actualRouting = string.Empty;
bool actualMandatory = true;
MessageProperties actualProperties = null;
byte[] actualMsg = null;
mockModelNamingConventionController.Setup(x => x.GetDirectRoutingKey(subscriberName)).Returns(routingKey);
mockBus.Setup(x => x.PublishAsync(mockExchange.Object, routingKey, false,
It.IsAny <MessageProperties>(), It.IsAny <byte[]>()))
.Returns((IExchange exchange, string routing, bool mandatory,
MessageProperties properties, byte[] msg) =>
{ return(Task.FromResult(true)); })
.Callback <IExchange, string, bool, MessageProperties, byte[]>(
(exchange, routing, mandatory, properties, msg) =>
{
actualExchange = exchange;
actualRouting = routing;
actualMandatory = mandatory;
actualProperties = properties;
actualMsg = msg;
});
mockBus.Setup(x => x.ExchangeDeclareAsync("exchangename", ExchangeType.Topic,
false, true, false, false, null, false))
.Returns((string exchangename, string exchanegType,
bool passive, bool durable, bool autoDelete, bool internalflag,
string alternateExchange, bool delayed) =>
{ return(Task.FromResult(mockExchange.Object)); });
//act
EasyNetQPublisher easyNetQPublisher =
new EasyNetQPublisher(mockBus.Object, "exchangename", mockModelNamingConventionController.Object);
BookingCreated bookingCreated =
new BookingCreated()
{
BookingName = string.Concat("Microsoft Sale",
Guid.NewGuid().ToString())
};
var bookingCreatedIntegrationEvent = new IntegrationEvent <BookingCreated>()
{
Content = bookingCreated,
EventType = "bookingcreated"
};
await easyNetQPublisher.PublishDirectEventAsync(bookingCreatedIntegrationEvent,
subscriberName, persistant);
//check
actualExchange.Should().Be(mockExchange.Object);
actualRouting.Should().Be(routingKey);
actualMandatory.Should().Be(false);
actualProperties.ShouldBeEquivalentTo(new MessageProperties()
{
DeliveryMode = deliveryMode
});
var messagejson = JsonConvert.SerializeObject(bookingCreatedIntegrationEvent);
var messagebytes = Encoding.UTF8.GetBytes(messagejson);
actualMsg.ShouldBeEquivalentTo(messagebytes);
}
