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 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))); }