public void When_deserializing_versioned_message_use_first_available_message_type()
{
var typeNameSerializer = new DefaultTypeNameSerializer();
var serializer = new JsonSerializer();
const string correlationId = "CorrelationId";
var serializationStrategy = new VersionedMessageSerializationStrategy(typeNameSerializer, serializer, new StaticCorrelationIdGenerationStrategy(correlationId));
var messageBody = new MyMessageV2 {
Text = "Hello world!", Number = 5
};
var message = new Message <MyMessageV2>(messageBody);
var serializedMessage = serializationStrategy.SerializeMessage(message);
// Mess with the properties to mimic a message serialized as MyMessageV3
var messageType = serializedMessage.Properties.Type;
serializedMessage.Properties.Type = messageType.Replace("MyMessageV2", "SomeCompletelyRandomType");
var alternativeMessageHeader = (string)serializedMessage.Properties.Headers[AlternativeMessageTypesHeaderKey];
alternativeMessageHeader = string.Concat(messageType, ";", alternativeMessageHeader);
serializedMessage.Properties.Headers[AlternativeMessageTypesHeaderKey] = Encoding.UTF8.GetBytes(alternativeMessageHeader);
var deserializedMessage = serializationStrategy.DeserializeMessage(serializedMessage.Properties, serializedMessage.Body);
Assert.Equal(typeof(MyMessageV2), deserializedMessage.MessageType);
Assert.Equal(((Message <MyMessageV2>)deserializedMessage).Body.Text, message.Body.Text);
Assert.Equal(((Message <MyMessageV2>)deserializedMessage).Body.Number, message.Body.Number);
}
public DefaultConsumerErrorStrategyTests()
{
var configuration = new ConnectionConfiguration
{
Hosts = new List <HostConfiguration>
{
new HostConfiguration {
Host = "localhost", Port = 5672
}
},
UserName = "******",
Password = "******"
};
configuration.Validate();
var typeNameSerializer = new DefaultTypeNameSerializer();
var errorMessageSerializer = new DefaultErrorMessageSerializer();
connectionFactory = new ConnectionFactoryWrapper(configuration, new RandomClusterHostSelectionStrategy <ConnectionFactoryInfo>());
serializer = new JsonSerializer();
conventions = new Conventions(typeNameSerializer);
consumerErrorStrategy = new DefaultConsumerErrorStrategy(
connectionFactory,
serializer,
conventions,
typeNameSerializer,
errorMessageSerializer);
}
public void When_using_the_versioned_serialization_strategy_versioned_messages_are_correctly_round_tripped()
{
var typeNameSerializer = new DefaultTypeNameSerializer();
var serializer = new JsonSerializer();
const string correlationId = "CorrelationId";
var serializationStrategy = new VersionedMessageSerializationStrategy(typeNameSerializer, serializer, new StaticCorrelationIdGenerationStrategy(correlationId));
var messageBody = new MyMessageV2 {
Text = "Hello world!", Number = 5
};
var message = new Message <MyMessageV2>(messageBody);
var serializedMessage = serializationStrategy.SerializeMessage(message);
// RMQ converts the Header values into a byte[] so mimic the translation here
var alternativeMessageHeader = (string)serializedMessage.Properties.Headers[AlternativeMessageTypesHeaderKey];
serializedMessage.Properties.Headers[AlternativeMessageTypesHeaderKey] = Encoding.UTF8.GetBytes(alternativeMessageHeader);
var deserializedMessage = serializationStrategy.DeserializeMessage(serializedMessage.Properties, serializedMessage.Body);
Assert.Equal(deserializedMessage.MessageType, message.Body.GetType());
Assert.Equal(((Message <MyMessageV2>)deserializedMessage).Body.Text, message.Body.Text);
Assert.Equal(((Message <MyMessageV2>)deserializedMessage).Body.Number, message.Body.Number);
}
public void GetMessageType_returns_message_type_for_a_versioned_message()
{
var typeNameSerialiser = new DefaultTypeNameSerializer();
var property = MessageTypeProperty.CreateForMessageType(typeof(MyMessageV2), typeNameSerialiser);
var messageType = property.GetMessageType();
Assert.Equal(typeof(MyMessageV2), messageType);
}
public void AppendTo_sets_message_type_and_alternatives_for_a_versioned_message()
{
var typeNameSerialiser = new DefaultTypeNameSerializer();
var property = MessageTypeProperty.CreateForMessageType(typeof(MyMessageV2), typeNameSerialiser);
var properties = new MessageProperties();
property.AppendTo(properties);
Assert.Equal(properties.Type, typeNameSerialiser.Serialize(typeof(MyMessageV2)));
Assert.Equal(properties.Headers[AlternativeMessageTypesHeaderKey], typeNameSerialiser.Serialize(typeof(MyMessage)));
}
public void MessageTypeProperty_is_created_correctly_from_message_properties_for_unversioned_message()
{
var typeNameSerialiser = new DefaultTypeNameSerializer();
var properties = new MessageProperties {
Type = typeNameSerialiser.Serialize(typeof(MyMessage))
};
var property = MessageTypeProperty.ExtractFromProperties(properties, typeNameSerialiser);
var messageType = property.GetMessageType();
Assert.Equal(typeof(MyMessage), messageType);
}
public When_publishing_a_message()
{
typeNameSerializer = new DefaultTypeNameSerializer();
var customConventions = new Conventions(typeNameSerializer)
{
ExchangeNamingConvention = x => "CustomExchangeNamingConvention",
QueueNamingConvention = (x, y) => "CustomQueueNamingConvention",
TopicNamingConvention = x => "CustomTopicNamingConvention"
};
mockBuilder = new MockBuilder(x => x.Register <IConventions>(customConventions));
mockBuilder.PubSub.Publish(new TestMessage());
}
public void MessageTypeProperty_is_created_correctly_from_message_properties_for_versioned_message()
{
var typeNameSerialiser = new DefaultTypeNameSerializer();
var properties = new MessageProperties {
Type = typeNameSerialiser.Serialize(typeof(MyMessageV2))
};
var encodedAlternativeMessageTypes = Encoding.UTF8.GetBytes(typeNameSerialiser.Serialize(typeof(MyMessage)));
properties.Headers.Add(AlternativeMessageTypesHeaderKey, encodedAlternativeMessageTypes);
var property = MessageTypeProperty.ExtractFromProperties(properties, typeNameSerialiser);
var messageType = property.GetMessageType();
Assert.Equal(typeof(MyMessageV2), messageType);
}
public void When_using_the_default_serialization_strategy_messages_are_correctly_round_tripped_when_null()
{
var typeNameSerializer = new DefaultTypeNameSerializer();
var serializer = new JsonSerializer();
const string correlationId = "CorrelationId";
var serializationStrategy = new DefaultMessageSerializationStrategy(typeNameSerializer, serializer, new StaticCorrelationIdGenerationStrategy(correlationId));
var message = new Message <MyMessage>();
var serializedMessage = serializationStrategy.SerializeMessage(message);
var deserializedMessage = serializationStrategy.DeserializeMessage(serializedMessage.Properties, serializedMessage.Body);
Assert.Equal(deserializedMessage.MessageType, message.MessageType);
Assert.Null(((Message <MyMessage>)deserializedMessage).Body);
}
public void When_using_the_versioned_serialization_strategy_messages_are_correctly_round_tripped()
{
var typeNameSerializer = new DefaultTypeNameSerializer();
var serializer = new JsonSerializer();
const string correlationId = "CorrelationId";
var serializationStrategy = new VersionedMessageSerializationStrategy(typeNameSerializer, serializer, new StaticCorrelationIdGenerationStrategy(correlationId));
var messageBody = new MyMessage {
Text = "Hello world!"
};
var message = new Message <MyMessage>(messageBody);
var serializedMessage = serializationStrategy.SerializeMessage(message);
var deserializedMessage = serializationStrategy.DeserializeMessage(serializedMessage.Properties, serializedMessage.Body);
Assert.Equal(deserializedMessage.MessageType, message.Body.GetType());
Assert.Equal(((Message <MyMessage>)deserializedMessage).Body.Text, message.Body.Text);
}
public void GetType_returns_first_available_alternative_if_message_type_unavailable()
{
var typeNameSerialiser = new DefaultTypeNameSerializer();
var v1 = typeNameSerialiser.Serialize(typeof(MyMessage));
var v2 = typeNameSerialiser.Serialize(typeof(MyMessageV2));
var vUnknown = v2.Replace("MyMessageV2", "MyUnknownMessage");
var alternativeTypes = string.Concat(v2, ";", v1);
var encodedAlternativeTypes = Encoding.UTF8.GetBytes(alternativeTypes);
var properties = new MessageProperties {
Type = vUnknown
};
properties.Headers.Add(AlternativeMessageTypesHeaderKey, encodedAlternativeTypes);
var property = MessageTypeProperty.ExtractFromProperties(properties, typeNameSerialiser);
var messageType = property.GetMessageType();
Assert.Equal(typeof(MyMessageV2), messageType);
}
public void GetType_throws_exception_if_all_types_unavailable()
{
var typeNameSerialiser = new DefaultTypeNameSerializer();
var v2 = typeNameSerialiser.Serialize(typeof(MyMessageV2));
var vUnknown1 = v2.Replace("MyMessageV2", "MyUnknownMessage");
var vUnknown2 = v2.Replace("MyMessageV2", "MyUnknownMessageV2");
var vUnknown3 = v2.Replace("MyMessageV2", "MyUnknownMessageV3");
var alternativeTypes = string.Concat(vUnknown2, ";", vUnknown1);
var encodedAlternativeTypes = Encoding.UTF8.GetBytes(alternativeTypes);
var properties = new MessageProperties {
Type = vUnknown3
};
properties.Headers.Add(AlternativeMessageTypesHeaderKey, encodedAlternativeTypes);
var property = MessageTypeProperty.ExtractFromProperties(properties, typeNameSerialiser);
Assert.Throws <EasyNetQException>(() => property.GetMessageType());
}
public When_using_default_conventions()
{
typeNameSerializer = new DefaultTypeNameSerializer();
conventions = new Conventions(typeNameSerializer);
}
