public void Should_not_reconnect_if_has_been_disposed()
{
const string originalMessage = "{ Text:\"Hello World\"}";
var originalMessageBody = Encoding.UTF8.GetBytes(originalMessage);
var exception = new Exception("I just threw!");
var context = new ConsumerExecutionContext(
(bytes, properties, arg3) => null,
new MessageReceivedInfo("consumertag", 0, false, "orginalExchange", "originalRoutingKey", "queue"),
new MessageProperties
{
CorrelationId = "123",
AppId = "456"
},
originalMessageBody
);
connectionFactory = Substitute.For <IConnectionFactory>();
consumerErrorStrategy = new DefaultConsumerErrorStrategy(
connectionFactory,
Substitute.For <ISerializer>(),
Substitute.For <IConventions>(),
Substitute.For <ITypeNameSerializer>(),
Substitute.For <IErrorMessageSerializer>());
consumerErrorStrategy.Dispose();
var ackStrategy = consumerErrorStrategy.HandleConsumerError(context, exception);
connectionFactory.DidNotReceive().CreateConnection();
Assert.Equal(AckStrategies.NackWithRequeue, ackStrategy);
}
public void Should_handle_an_exception_by_writing_to_the_error_queue()
{
const string originalMessage = "{ Text:\"Hello World\"}";
var originalMessageBody = Encoding.UTF8.GetBytes(originalMessage);
var exception = new Exception("I just threw!");
var context = new ConsumerExecutionContext(
(bytes, properties, arg3) => null,
new MessageReceivedInfo("consumertag", 0, false, "orginalExchange", "originalRoutingKey", "queue"),
new MessageProperties
{
CorrelationId = "123",
AppId = "456"
},
originalMessageBody,
MockRepository.GenerateStub <IBasicConsumer>()
);
consumerErrorStrategy.HandleConsumerError(context, exception);
Thread.Sleep(100);
// Now get the error message off the error queue and assert its properties
using (var connection = connectionFactory.CreateConnection())
using (var model = connection.CreateModel())
{
var getArgs = model.BasicGet(conventions.ErrorQueueNamingConvention(), true);
if (getArgs == null)
{
Assert.Fail("Nothing on the error queue");
}
else
{
var message = serializer.BytesToMessage <Error>(getArgs.Body);
message.RoutingKey.ShouldEqual(context.Info.RoutingKey);
message.Exchange.ShouldEqual(context.Info.Exchange);
message.Message.ShouldEqual(originalMessage);
message.Exception.ShouldEqual("System.Exception: I just threw!");
message.DateTime.Date.ShouldEqual(DateTime.Now.Date);
message.BasicProperties.CorrelationId.ShouldEqual(context.Properties.CorrelationId);
message.BasicProperties.AppId.ShouldEqual(context.Properties.AppId);
}
}
}
public When_using_default_consumer_error_strategy()
{
var customConventions = new Conventions(new DefaultTypeNameSerializer())
{
ErrorQueueNamingConvention = info => "CustomEasyNetQErrorQueueName",
ErrorExchangeNamingConvention = info => "CustomErrorExchangePrefixName." + info.RoutingKey
};
mockBuilder = new MockBuilder();
var connectionConfiguration = new ConnectionConfiguration();
var connection = new PersistentConnection(connectionConfiguration, mockBuilder.ConnectionFactory, new EventBus());
errorStrategy = new DefaultConsumerErrorStrategy(
connection,
new JsonSerializer(),
customConventions,
new DefaultTypeNameSerializer(),
new DefaultErrorMessageSerializer(),
connectionConfiguration
);
const string originalMessage = "";
var originalMessageBody = Encoding.UTF8.GetBytes(originalMessage);
var context = new ConsumerExecutionContext(
(bytes, properties, info, cancellation) => Task.FromResult(AckStrategies.Ack),
new MessageReceivedInfo("consumerTag", 0, false, "orginalExchange", "originalRoutingKey", "queue"),
new MessageProperties
{
CorrelationId = string.Empty,
AppId = string.Empty
},
originalMessageBody
);
try
{
errorAckStrategy = errorStrategy.HandleConsumerError(context, new Exception());
cancelAckStrategy = errorStrategy.HandleConsumerCancelled(context);
}
catch (Exception)
{
// swallow
}
}
public void Should_handle_an_exception_by_writing_to_the_error_queue()
{
const string originalMessage = "{ Text:\"Hello World\"}";
var originalMessageBody = Encoding.UTF8.GetBytes(originalMessage);
var deliverArgs = new BasicDeliverEventArgs
{
RoutingKey = "originalRoutingKey",
Exchange = "orginalExchange",
Body = originalMessageBody,
BasicProperties = new BasicProperties
{
CorrelationId = "123",
AppId = "456"
}
};
var exception = new Exception("I just threw!");
consumerErrorStrategy.HandleConsumerError(deliverArgs, exception);
Thread.Sleep(100);
// Now get the error message off the error queue and assert its properties
using (var connection = connectionFactory.CreateConnection())
using (var model = connection.CreateModel())
{
var getArgs = model.BasicGet(DefaultConsumerErrorStrategy.EasyNetQErrorQueue, true);
if (getArgs == null)
{
Assert.Fail("Nothing on the error queue");
}
else
{
var message = serializer.BytesToMessage <Error>(getArgs.Body);
message.RoutingKey.ShouldEqual(deliverArgs.RoutingKey);
message.Exchange.ShouldEqual(deliverArgs.Exchange);
message.Message.ShouldEqual(originalMessage);
message.Exception.ShouldEqual("System.Exception: I just threw!");
message.DateTime.Date.ShouldEqual(DateTime.Now.Date);
message.BasicProperties.CorrelationId.ShouldEqual(deliverArgs.BasicProperties.CorrelationId);
message.BasicProperties.AppId.ShouldEqual(deliverArgs.BasicProperties.AppId);
}
}
}
public void SetUp()
{
var mockModel = new MockModel
{
ExchangeDeclareAction = (exchangeName, type, durable, autoDelete, arguments) => createdExchangeName = exchangeName,
QueueDeclareAction = (queue, durable, exclusive, autoDelete, arguments) =>
{
createdQueueName = queue;
return(new QueueDeclareOk(queue, 0, 0));
}
};
var customConventions = new Conventions
{
ErrorQueueNamingConvention = () => "CustomEasyNetQErrorQueueName",
ErrorExchangeNamingConvention = (originalRoutingKey) => "CustomErrorExchangePrefixName." + originalRoutingKey
};
errorStrategy = new DefaultConsumerErrorStrategy(new MockConnectionFactory(new MockConnection(mockModel)), new JsonSerializer(), new MockLogger(), customConventions);
const string originalMessage = "";
var originalMessageBody = Encoding.UTF8.GetBytes(originalMessage);
var deliverArgs = new BasicDeliverEventArgs
{
RoutingKey = "originalRoutingKey",
Exchange = "orginalExchange",
Body = originalMessageBody,
BasicProperties = new BasicProperties
{
CorrelationId = string.Empty,
AppId = string.Empty
}
};
try
{
errorStrategy.HandleConsumerError(deliverArgs, new Exception());
}
catch (Exception exc)
{
// swallow
}
}
public void SetUp()
{
var customConventions = new Conventions(new TypeNameSerializer())
{
ErrorQueueNamingConvention = () => "CustomEasyNetQErrorQueueName",
ErrorExchangeNamingConvention = info => "CustomErrorExchangePrefixName." + info.RoutingKey
};
mockBuilder = new MockBuilder();
errorStrategy = new DefaultConsumerErrorStrategy(
mockBuilder.ConnectionFactory,
new JsonSerializer(new TypeNameSerializer()),
MockRepository.GenerateStub <IEasyNetQLogger>(),
customConventions,
new TypeNameSerializer(),
new DefaultErrorMessageSerializer());
const string originalMessage = "";
var originalMessageBody = Encoding.UTF8.GetBytes(originalMessage);
var context = new ConsumerExecutionContext(
(bytes, properties, arg3) => null,
new MessageReceivedInfo("consumerTag", 0, false, "orginalExchange", "originalRoutingKey", "queue"),
new MessageProperties
{
CorrelationId = string.Empty,
AppId = string.Empty
},
originalMessageBody,
MockRepository.GenerateStub <IBasicConsumer>()
);
try
{
errorAckStrategy = errorStrategy.HandleConsumerError(context, new Exception());
cancelAckStrategy = errorStrategy.HandleConsumerCancelled(context);
}
catch (Exception)
{
// swallow
}
}
public void SetUp()
{
var customConventions = new Conventions
{
ErrorQueueNamingConvention = () => "CustomEasyNetQErrorQueueName",
ErrorExchangeNamingConvention = originalRoutingKey => "CustomErrorExchangePrefixName." + originalRoutingKey
};
mockBuilder = new MockBuilder();
errorStrategy = new DefaultConsumerErrorStrategy(
mockBuilder.ConnectionFactory,
new JsonSerializer(),
MockRepository.GenerateStub <IEasyNetQLogger>(),
customConventions);
const string originalMessage = "";
var originalMessageBody = Encoding.UTF8.GetBytes(originalMessage);
var deliverArgs = new BasicDeliverEventArgs
{
RoutingKey = "originalRoutingKey",
Exchange = "orginalExchange",
Body = originalMessageBody,
BasicProperties = new BasicProperties
{
CorrelationId = string.Empty,
AppId = string.Empty
}
};
try
{
errorStrategy.HandleConsumerError(deliverArgs, new Exception());
}
catch (Exception)
{
// swallow
}
}
public void Should_not_reconnect_if_has_been_disposed()
{
const string originalMessage = "{ Text:\"Hello World\"}";
var originalMessageBody = Encoding.UTF8.GetBytes(originalMessage);
var exception = new Exception("I just threw!");
var context = new ConsumerExecutionContext(
(bytes, properties, arg3) => null,
new MessageReceivedInfo("consumertag", 0, false, "orginalExchange", "originalRoutingKey", "queue"),
new MessageProperties
{
CorrelationId = "123",
AppId = "456"
},
originalMessageBody,
MockRepository.GenerateStub <IBasicConsumer>()
);
var logger = MockRepository.GenerateMock <IEasyNetQLogger>();
connectionFactory = MockRepository.GenerateMock <IConnectionFactory>();
consumerErrorStrategy = new DefaultConsumerErrorStrategy(
connectionFactory,
MockRepository.GenerateStub <ISerializer>(),
logger,
MockRepository.GenerateStub <IConventions>(),
MockRepository.GenerateStub <ITypeNameSerializer>(),
MockRepository.GenerateStub <IErrorMessageSerializer>());
consumerErrorStrategy.Dispose();
var ackStrategy = consumerErrorStrategy.HandleConsumerError(context, exception);
connectionFactory.AssertWasNotCalled(f => f.CreateConnection());
logger.AssertWasCalled(l => l.ErrorWrite(Arg.Text.Contains("DefaultConsumerErrorStrategy was already disposed"), Arg <Object> .Is.Anything));
Assert.AreEqual(AckStrategies.NackWithRequeue, ackStrategy);
}
public void SetUp()
{
var mockModel = new MockModel
{
ExchangeDeclareAction = (exchangeName, type, durable, autoDelete, arguments) => createdExchangeName = exchangeName,
QueueDeclareAction = (queue, durable, exclusive, autoDelete, arguments) =>
{
createdQueueName = queue;
return new QueueDeclareOk(queue, 0, 0);
}
};
var customConventions = new Conventions
{
ErrorQueueNamingConvention = () => "CustomEasyNetQErrorQueueName",
ErrorExchangeNamingConvention = (originalRoutingKey) => "CustomErrorExchangePrefixName." + originalRoutingKey
};
errorStrategy = new DefaultConsumerErrorStrategy(new MockConnectionFactory(new MockConnection(mockModel)), new JsonSerializer(), new MockLogger(), customConventions);
const string originalMessage = "";
var originalMessageBody = Encoding.UTF8.GetBytes(originalMessage);
var deliverArgs = new BasicDeliverEventArgs
{
RoutingKey = "originalRoutingKey",
Exchange = "orginalExchange",
Body = originalMessageBody,
BasicProperties = new BasicProperties
{
CorrelationId = string.Empty,
AppId = string.Empty
}
};
try
{
errorStrategy.HandleConsumerError(deliverArgs, new Exception());
}
catch (Exception exc)
{
// swallow
}
}
