public void SetUp()
{
var configuration = new ConnectionConfiguration
{
Hosts = new List <IHostConfiguration>
{
new HostConfiguration {
Host = "localhost", Port = 5672
}
},
UserName = "******",
Password = "******"
};
configuration.Validate();
var typeNameSerializer = new TypeNameSerializer();
connectionFactory = new ConnectionFactoryWrapper(configuration, new DefaultClusterHostSelectionStrategy <ConnectionFactoryInfo>());
serializer = new JsonSerializer(typeNameSerializer);
conventions = new Conventions(typeNameSerializer);
consumerErrorStrategy = new DefaultConsumerErrorStrategy(
connectionFactory,
serializer,
new ConsoleLogger(),
conventions,
typeNameSerializer);
}
public void When_deserializing_versioned_message_use_first_available_message_type()
{
var typeNameSerializer = new TypeNameSerializer();
var serializer = new JsonSerializer(typeNameSerializer);
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 serialised 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.That(deserializedMessage.Message.Body.GetType(), Is.EqualTo(typeof(MyMessageV2)));
Assert.That(deserializedMessage.Message.Body.Text, Is.EqualTo(message.Body.Text));
Assert.That(deserializedMessage.Message.Body.Number, Is.EqualTo(message.Body.Number));
}
public static void Main(string[] args)
{
var typeNameSerializer = new TypeNameSerializer();
var argParser = new ArgParser();
var arguments = argParser.Parse(args);
bool enableBinaryPayloads = false;
arguments.WithTypedKeyOptional<bool>("b", a => enableBinaryPayloads = bool.Parse(a.Value))
.FailWith(messsage("Invalid enable binary payloads (b) parameter"));
IErrorMessageSerializer errorMessageSerializer;
if (enableBinaryPayloads)
{
errorMessageSerializer = new Base64ErrorMessageSerializer();
}
else
{
errorMessageSerializer = new DefaultErrorMessageSerializer();
}
// poor man's dependency injection FTW ;)
var program = new Program(
argParser,
new QueueRetreival(errorMessageSerializer),
new FileMessageWriter(),
new MessageReader(),
new QueueInsertion(errorMessageSerializer),
new ErrorRetry(new JsonSerializer(typeNameSerializer), errorMessageSerializer),
new Conventions(typeNameSerializer));
program.Start(args);
}
public void SetUp()
{
var configuration = new ConnectionConfiguration
{
Hosts = new List<IHostConfiguration>
{
new HostConfiguration { Host = "localhost", Port = 5672 }
},
UserName = "******",
Password = "******"
};
configuration.Validate();
var typeNameSerializer = new TypeNameSerializer();
connectionFactory = new ConnectionFactoryWrapper(configuration, new DefaultClusterHostSelectionStrategy<ConnectionFactoryInfo>());
serializer = new JsonSerializer(typeNameSerializer);
conventions = new Conventions(typeNameSerializer);
consumerErrorStrategy = new DefaultConsumerErrorStrategy(
connectionFactory,
serializer,
new ConsoleLogger(),
conventions,
typeNameSerializer);
}
public IMessagesMove AsType(Type messageType)
{
var typeNameSerializer = new TypeNameSerializer();
MessageType = typeNameSerializer.Serialize(messageType);
return(this);
}
public static void Main(string[] args)
{
var typeNameSerializer = new TypeNameSerializer();
var argParser = new ArgParser();
var arguments = argParser.Parse(args);
bool enableBinaryPayloads = false;
arguments.WithTypedKeyOptional <bool>("b", a => enableBinaryPayloads = bool.Parse(a.Value))
.FailWith(messsage("Invalid enable binary payloads (b) parameter"));
IErrorMessageSerializer errorMessageSerializer;
if (enableBinaryPayloads)
{
errorMessageSerializer = new Base64ErrorMessageSerializer();
}
else
{
errorMessageSerializer = new DefaultErrorMessageSerializer();
}
// poor man's dependency injection FTW ;)
var program = new Program(
argParser,
new QueueRetreival(errorMessageSerializer),
new FileMessageWriter(),
new MessageReader(),
new QueueInsertion(errorMessageSerializer),
new ErrorRetry(new JsonSerializer(typeNameSerializer), errorMessageSerializer),
new Conventions(typeNameSerializer));
program.Start(args);
}
public void The_default_queue_naming_convention_should_use_the_TypeNameSerializers_Serialize_method_then_an_underscore_then_the_subscription_id()
{
const string subscriptionId = "test";
var result = conventions.QueueNamingConvention(typeof(TestMessage), subscriptionId);
result.ShouldEqual(TypeNameSerializer.Serialize(typeof(TestMessage)) + "_" + subscriptionId);
}
public void When_using_the_versioned_serialization_strategy_versioned_messages_are_correctly_round_tripped()
{
var typeNameSerializer = new TypeNameSerializer();
var serializer = new JsonSerializer(typeNameSerializer);
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.That(deserializedMessage.Message.Body.GetType(), Is.EqualTo(message.Body.GetType()));
Assert.That(deserializedMessage.Message.Body.Text, Is.EqualTo(message.Body.Text));
Assert.That(deserializedMessage.Message.Body.Number, Is.EqualTo(message.Body.Number));
}
public void SetUp()
{
var typeNameSerializer = new TypeNameSerializer();
conventions = new Conventions(typeNameSerializer);
errorRetry = new ErrorRetry(new JsonSerializer(typeNameSerializer), new DefaultErrorMessageSerializer());
}
public void GetMessageType_returns_message_type_for_a_versioned_message()
{
var typeNameSerialiser = new TypeNameSerializer();
var property = MessageTypeProperty.CreateForMessageType( typeof( MyMessageV2 ), typeNameSerialiser );
var messageType = property.GetMessageType();
Assert.That( messageType.Type, Is.EqualTo( typeof( MyMessageV2 ) ) );
}
public void Should_throw_exception_if_type_is_null()
{
// Arrange
var serializer = new TypeNameSerializer();
// Action
serializer.Serialize(null);
}
public void GetMessageType_returns_message_type_for_an_unversioned_message()
{
var typeNameSerialiser = new TypeNameSerializer();
var property = MessageTypeProperty.CreateForMessageType(typeof(MyMessage), typeNameSerialiser);
var messageType = property.GetMessageType();
Assert.Equal(typeof(MyMessage), messageType.Type);
}
public void Should_be_able_to_serialize_and_deserialize_polymorphic_properties_when_using_TypeNameSerializer()
{
var typeName = new TypeNameSerializer().Serialize(typeof (PolyMessage));
var bytes = serializer.MessageToBytes(new PolyMessage { AorB = new B() });
var result = (PolyMessage)serializer.BytesToMessage(typeName, bytes);
Assert.IsInstanceOf<B>(result.AorB);
}
public void GetMessageType_returns_message_type_for_a_versioned_message()
{
var typeNameSerialiser = new TypeNameSerializer();
var property = MessageTypeProperty.CreateForMessageType(typeof(MyMessageV2), typeNameSerialiser);
var messageType = property.GetMessageType();
Assert.That(messageType.Type, Is.EqualTo(typeof(MyMessageV2)));
}
public void MessageTypeProperty_is_created_correctly_from_message_properties_for_unversioned_message()
{
var typeNameSerialiser = new TypeNameSerializer();
var properties = new MessageProperties {Type = typeNameSerialiser.Serialize( typeof( MyMessage ) )};
var property = MessageTypeProperty.ExtractFromProperties( properties, typeNameSerialiser );
var messageType = property.GetMessageType();
Assert.That( messageType.Type, Is.EqualTo( typeof( MyMessage ) ) );
}
public void AppendTo_sets_message_type_and_alternatives_for_a_versioned_message()
{
var typeNameSerialiser = new TypeNameSerializer();
var property = MessageTypeProperty.CreateForMessageType(typeof(MyMessageV2), typeNameSerialiser);
var properties = new MessageProperties();
property.AppendTo(properties);
Assert.That(properties.Type, Is.EqualTo(typeNameSerialiser.Serialize(typeof(MyMessageV2))));
Assert.That(properties.Headers[AlternativeMessageTypesHeaderKey], Is.EqualTo(typeNameSerialiser.Serialize(typeof(MyMessage))));
}
public void Should_throw_exception_if_type_fullName_is_null()
{
// Arrange
var type = Substitute.For <Type>();
type.FullName.Returns((string)null);
var serializer = new TypeNameSerializer();
// Action
serializer.Serialize(type);
}
public void Should_be_able_to_serialize_and_deserialize_polymorphic_properties_when_using_TypeNameSerializer()
{
var typeName = new TypeNameSerializer().Serialize(typeof(PolyMessage));
var bytes = serializer.MessageToBytes(new PolyMessage {
AorB = new B()
});
var result = (PolyMessage)serializer.BytesToMessage(typeName, bytes);
Assert.IsInstanceOf <B>(result.AorB);
}
public void AppendTo_sets_message_type_and_no_alternatives_for_an_unversioned_message()
{
var typeNameSerialiser = new TypeNameSerializer();
var property = MessageTypeProperty.CreateForMessageType(typeof(MyMessage), typeNameSerialiser);
var properties = new MessageProperties();
property.AppendTo(properties);
Assert.Equal(properties.Type, typeNameSerialiser.Serialize(typeof(MyMessage)));
Assert.False(properties.Headers.ContainsKey(AlternativeMessageTypesHeaderKey));
}
public void AppendTo_sets_message_type_and_alternatives_for_a_versioned_message()
{
var typeNameSerialiser = new TypeNameSerializer();
var property = MessageTypeProperty.CreateForMessageType( typeof( MyMessageV2 ), typeNameSerialiser );
var properties = new MessageProperties();
property.AppendTo( properties );
Assert.That( properties.Type, Is.EqualTo( typeNameSerialiser.Serialize( typeof( MyMessageV2 ) ) ) );
Assert.That( properties.Headers[ AlternativeMessageTypesHeaderKey ], Is.EqualTo( typeNameSerialiser.Serialize( typeof( MyMessage ) ) ) );
}
public void MessageTypeProperty_is_created_correctly_from_message_properties_for_unversioned_message()
{
var typeNameSerialiser = new TypeNameSerializer();
var properties = new MessageProperties {
Type = typeNameSerialiser.Serialize(typeof(MyMessage))
};
var property = MessageTypeProperty.ExtractFromProperties(properties, typeNameSerialiser);
var messageType = property.GetMessageType();
Assert.That(messageType.Type, Is.EqualTo(typeof(MyMessage)));
}
public void MessageTypeProperty_is_created_correctly_from_message_properties_for_versioned_message()
{
var typeNameSerialiser = new TypeNameSerializer();
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.That( messageType.Type, Is.EqualTo( typeof( MyMessageV2 ) ) );
}
private void CreateBus(Conventions conventions, IModel model)
{
bus = new RabbitBus(
x => TypeNameSerializer.Serialize(x.GetType()),
new JsonSerializer(),
new MockConsumerFactory(),
new MockConnectionFactory(new MockConnection(model)),
new MockLogger(),
CorrelationIdGenerator.GetCorrelationId,
conventions
);
}
public static void Main(string[] args)
{
var typeNameSerializer = new TypeNameSerializer();
// poor man's dependency injection FTW ;)
var program = new Program(
new ArgParser(),
new QueueRetreival(),
new FileMessageWriter(),
new MessageReader(),
new QueueInsertion(),
new ErrorRetry(new JsonSerializer(typeNameSerializer)),
new Conventions(typeNameSerializer));
program.Start(args);
}
public void When_using_the_default_serialization_strategy_messages_are_correctly_round_tripped()
{
var typeNameSerializer = new TypeNameSerializer();
var serializer = new JsonSerializer( typeNameSerializer );
const string correlationId = "CorrelationId";
var serializationStrategy = new DefaultMessageSerializationStrategy( typeNameSerializer, serializer, () => 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.That( deserializedMessage.Message.Body.GetType(), Is.EqualTo( message.Body.GetType() ) );
Assert.That( deserializedMessage.Message.Body.Text, Is.EqualTo( message.Body.Text ) );
}
public void MessageTypeProperty_is_created_correctly_from_message_properties_for_versioned_message()
{
var typeNameSerialiser = new TypeNameSerializer();
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.That(messageType.Type, Is.EqualTo(typeof(MyMessageV2)));
}
public static void Main(string[] args)
{
var typeNameSerializer = new TypeNameSerializer();
// poor man's dependency injection FTW ;)
var program = new Program(
new ArgParser(),
new QueueRetreival(),
new FileMessageWriter(),
new MessageReader(),
new QueueInsertion(),
new ErrorRetry(new JsonSerializer(typeNameSerializer)),
new Conventions(typeNameSerializer));
program.Start(args);
}
public void When_using_the_default_serialization_strategy_messages_are_correctly_round_tripped()
{
var typeNameSerializer = new TypeNameSerializer();
var serializer = new JsonSerializer(typeNameSerializer);
const string correlationId = "CorrelationId";
var serializationStrategy = new DefaultMessageSerializationStrategy(typeNameSerializer, serializer, () => 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.That(deserializedMessage.Message.Body.GetType(), Is.EqualTo(message.Body.GetType()));
Assert.That(deserializedMessage.Message.Body.Text, Is.EqualTo(message.Body.Text));
}
public void When_using_the_versioned_serialization_strategy_messages_are_correctly_round_tripped()
{
var typeNameSerializer = new TypeNameSerializer();
var serializer = new JsonSerializer(typeNameSerializer);
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_throws_exception_if_all_types_unavailable()
{
var typeNameSerialiser = new TypeNameSerializer();
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());
}
private void CreateBus(IConventions conventions, IModel model)
{
var advancedBus = new RabbitAdvancedBus(
new ConnectionConfiguration(),
new MockConnectionFactory(new MockConnection(model)),
TypeNameSerializer.Serialize,
new JsonSerializer(),
new MockConsumerFactory(),
new MockLogger(),
CorrelationIdGenerator.GetCorrelationId,
new Conventions()
);
bus = new RabbitBus(
x => TypeNameSerializer.Serialize(x.GetType()),
new MockLogger(),
conventions,
advancedBus
);
}
public void GetType_returns_first_available_alternative_if_message_type_unavailable()
{
var typeNameSerialiser = new TypeNameSerializer();
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.That(messageType.Type, Is.EqualTo(typeof(MyMessageV2)));
}
public virtual void HandleConsumerError(ConsumerExecutionContext context, Exception exception)
{
Preconditions.CheckNotNull(context, "context");
Preconditions.CheckNotNull(exception, "exception");
try
{
Connect();
using (var model = connection.CreateModel())
{
var errorExchange = DeclareErrorExchangeQueueStructure(model, context.Info.RoutingKey);
var messageBody = CreateErrorMessage(context, exception);
var properties = model.CreateBasicProperties();
properties.SetPersistent(true);
properties.Type = TypeNameSerializer.Serialize(typeof(Error));
model.BasicPublish(errorExchange, context.Info.RoutingKey, properties, messageBody);
}
}
catch (BrokerUnreachableException)
{
// thrown if the broker is unreachable during initial creation.
logger.ErrorWrite("EasyNetQ Consumer Error Handler cannot connect to Broker\n" +
CreateConnectionCheckMessage());
}
catch (OperationInterruptedException interruptedException)
{
// thrown if the broker connection is broken during declare or publish.
logger.ErrorWrite("EasyNetQ Consumer Error Handler: Broker connection was closed while attempting to publish Error message.\n" +
string.Format("Message was: '{0}'\n", interruptedException.Message) +
CreateConnectionCheckMessage());
}
catch (Exception unexpecctedException)
{
// Something else unexpected has gone wrong :(
logger.ErrorWrite("EasyNetQ Consumer Error Handler: Failed to publish error message\nException is:\n"
+ unexpecctedException);
}
}
public void Should_be_able_to_store_a_schedule_with_exchange()
{
var typeNameSerializer = new TypeNameSerializer();
var conventions = new Conventions(typeNameSerializer);
var jsonSerializer = new JsonSerializer(typeNameSerializer);
var messageSerializationStrategy = new DefaultMessageSerializationStrategy(typeNameSerializer, jsonSerializer, new DefaultCorrelationIdGenerationStrategy());
var testScheduleMessage = new TestScheduleMessage { Text = "Hello World" };
var serializedMessage = messageSerializationStrategy.SerializeMessage(new Message<TestScheduleMessage>(testScheduleMessage));
scheduleRepository.Store(new ScheduleMe
{
BindingKey = "",
CancellationKey = "bcd",
Exchange = conventions.ExchangeNamingConvention(typeof(TestScheduleMessage)),
ExchangeType = ExchangeType.Topic,
RoutingKey = "#",
WakeTime = DateTime.UtcNow.AddMilliseconds(-1),
InnerMessage = serializedMessage.Body,
MessageProperties = serializedMessage.Properties
});
}
public void Should_be_able_to_store_a_schedule_with_exchange()
{
var typeNameSerializer = new TypeNameSerializer();
var conventions = new Conventions(typeNameSerializer);
var jsonSerializer = new JsonSerializer(typeNameSerializer);
var messageSerializationStrategy = new DefaultMessageSerializationStrategy(typeNameSerializer, jsonSerializer, new DefaultCorrelationIdGenerationStrategy());
var testScheduleMessage = new TestScheduleMessage {
Text = "Hello World"
};
var serializedMessage = messageSerializationStrategy.SerializeMessage(new Message <TestScheduleMessage>(testScheduleMessage));
scheduleRepository.Store(new ScheduleMe
{
BindingKey = "",
CancellationKey = "bcd",
Exchange = conventions.ExchangeNamingConvention(typeof(TestScheduleMessage)),
ExchangeType = ExchangeType.Topic,
RoutingKey = "#",
WakeTime = DateTime.UtcNow.AddMilliseconds(-1),
InnerMessage = serializedMessage.Body,
MessageProperties = serializedMessage.Properties
});
}
public void Should_serialize_a_type_name()
{
var typeName = TypeNameSerializer.Serialize(typeof(string));
typeName.ShouldEqual(expectedTypeName);
}
public void GetType_throws_exception_if_all_types_unavailable()
{
var typeNameSerialiser = new TypeNameSerializer();
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 void GetType_returns_first_available_alternative_if_message_type_unavailable()
{
var typeNameSerialiser = new TypeNameSerializer();
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.That( messageType.Type, Is.EqualTo( typeof( MyMessageV2 ) ) );
}
public void Should_serialize_a_custom_type()
{
var typeName = TypeNameSerializer.Serialize(typeof(TypeNameSerializer));
typeName.ShouldEqual(expectedCustomTypeName);
}
public void SetUp()
{
var typeNameSerializer = new TypeNameSerializer();
conventions = new Conventions(typeNameSerializer);
errorRetry = new ErrorRetry(new JsonSerializer(typeNameSerializer));
}
public void The_default_rpc_routingkey_naming_convention_should_use_the_TypeNameSerializers_Serialize_method()
{
var result = conventions.RpcRoutingKeyNamingConvention(typeof(TestMessage));
result.ShouldEqual(TypeNameSerializer.Serialize(typeof(TestMessage)));
}
public void The_default_topic_naming_convention_should_use_the_TypeNameSerializers_Serialize_method()
{
var result = conventions.TopicNamingConvention(typeof(TestMessage));
result.ShouldEqual(TypeNameSerializer.Serialize(typeof(TestMessage)));
}
