Remove newtonsoft hack from rpc (#903)

Pliner · web-flow · commit 6d93be10e870 · 2019-02-19T21:00:15.000+05:00
* Setting message type explicitly

* Fix tests
diff --git a/Source/EasyNetQ.Hosepipe.Tests/ErrorMessageRepublishSpike.cs b/Source/EasyNetQ.Hosepipe.Tests/ErrorMessageRepublishSpike.cs
@@ -7,17 +7,24 @@
 using RabbitMQ.Client;
 using RabbitMQ.Client.Exceptions;
 using EasyNetQ.Tests;
+using Xunit.Abstractions;
 
 namespace EasyNetQ.Hosepipe.Tests
 {
     public class ErrorMessageRepublishSpike
     {
+        private readonly ITestOutputHelper testOutputHelper;
         readonly ISerializer serializer = new JsonSerializer();
 
+        public ErrorMessageRepublishSpike(ITestOutputHelper testOutputHelper)
+        {
+            this.testOutputHelper = testOutputHelper;
+        }
+
         [Fact]
         public void Should_deserialise_error_message_correctly()
         {
-            var error = serializer.BytesToMessage<Error>(Encoding.UTF8.GetBytes(errorMessage));
+            var error = (Error)serializer.BytesToMessage(typeof(Error), Encoding.UTF8.GetBytes(errorMessage));
 
             error.RoutingKey.ShouldEqual("originalRoutingKey");
             error.Message.ShouldEqual("{ Text:\"Hello World\"}");
@@ -27,14 +34,14 @@ public void Should_deserialise_error_message_correctly()
         public void Should_fail_to_deseralize_some_other_random_message()
         {
             const string randomMessage = "{\"Text\":\"Hello World\"}";
-            var error = serializer.BytesToMessage<Error>(Encoding.UTF8.GetBytes(randomMessage));
+            var error = (Error)serializer.BytesToMessage(typeof(Error), Encoding.UTF8.GetBytes(randomMessage));
             error.Message.ShouldBeNull();
         }
 
         [Fact][Explicit("Requires a localhost instance of RabbitMQ to run")]
         public void Should_be_able_to_republish_message()
         {
-            var error = serializer.BytesToMessage<Error>(Encoding.UTF8.GetBytes(errorMessage));
+            var error = (Error)serializer.BytesToMessage(typeof(Error), Encoding.UTF8.GetBytes(errorMessage));
 
             var connectionFactory = new ConnectionFactory
             {
@@ -59,8 +66,7 @@ public void Should_be_able_to_republish_message()
                 }
                 catch (OperationInterruptedException)
                 {
-                    Console.WriteLine("The exchange, '{0}', described in the error message does not exist on '{1}', '{2}'",
-                        error.Exchange, connectionFactory.HostName, connectionFactory.VirtualHost);
+                    testOutputHelper.WriteLine("The exchange, '{0}', described in the error message does not exist on '{1}', '{2}'", error.Exchange, connectionFactory.HostName, connectionFactory.VirtualHost);
                 }
             }
         }
diff --git a/Source/EasyNetQ.Hosepipe/ErrorRetry.cs b/Source/EasyNetQ.Hosepipe/ErrorRetry.cs
@@ -24,7 +24,7 @@ public void RetryErrors(IEnumerable<HosepipeMessage> rawErrorMessages, QueuePara
         {
             foreach (var rawErrorMessage in rawErrorMessages)
             {
-                var error = serializer.BytesToMessage<Error>(errorMessageSerializer.Deserialize(rawErrorMessage.Body));
+                var error = (Error)serializer.BytesToMessage(typeof(Error), errorMessageSerializer.Deserialize(rawErrorMessage.Body));
                 RepublishError(error, parameters);
             }
         }
diff --git a/Source/EasyNetQ.Tests/ConsumeTests/When_a_consumer_has_multiple_handlers.cs b/Source/EasyNetQ.Tests/ConsumeTests/When_a_consumer_has_multiple_handlers.cs
@@ -60,7 +60,7 @@ public void Dispose()
 
         private void Deliver<T>(T message) where T : class
         {
-            var body = new JsonSerializer().MessageToBytes(message);
+            var body = new JsonSerializer().MessageToBytes(typeof(T), message);
             var properties = new BasicProperties
             {
                 Type = new DefaultTypeNameSerializer().Serialize(typeof(T))
diff --git a/Source/EasyNetQ.Tests/ConsumeTests/When_a_polymorphic_message_is_delivered_to_the_consumer.cs b/Source/EasyNetQ.Tests/ConsumeTests/When_a_polymorphic_message_is_delivered_to_the_consumer.cs
@@ -1,6 +1,6 @@
-﻿using System;
+﻿// ReSharper disable InconsistentNaming
+using System;
 using FluentAssertions;
-// ReSharper disable InconsistentNaming
 using System.Threading;
 using System.Threading.Tasks;
 using EasyNetQ.Tests.Mocking;
@@ -29,7 +29,7 @@ public When_a_polymorphic_message_is_delivered_to_the_consumer()
                 }));
 
             var publishedMessage = new Implementation { Text = "Hello Polymorphs!" };
-            var body = new JsonSerializer().MessageToBytes(publishedMessage);
+            var body = new JsonSerializer().MessageToBytes(typeof(Implementation), publishedMessage);
             var properties = new BasicProperties
                 {
                     Type = new DefaultTypeNameSerializer().Serialize(typeof(Implementation))
diff --git a/Source/EasyNetQ.Tests/ConsumeTests/When_a_responder_is_cancelled.cs b/Source/EasyNetQ.Tests/ConsumeTests/When_a_responder_is_cancelled.cs
@@ -1,4 +1,5 @@
-﻿using System;
+﻿// ReSharper disable InconsistentNaming
+using System;
 using System.Threading;
 using System.Threading.Tasks;
 using EasyNetQ.Events;
@@ -61,7 +62,7 @@ private void DeliverMessage(RpcRequest request)
                 ReplyTo = conventions.RpcReturnQueueNamingConvention()
             };
 
-            var body = serializer.MessageToBytes(request);
+            var body = serializer.MessageToBytes(typeof(RpcRequest), request);
 
             var waiter = new CountdownEvent(2);
             mockBuilder.EventBus.Subscribe<PublishedMessageEvent>(x => waiter.Signal());
diff --git a/Source/EasyNetQ.Tests/DefaultMessageSerializationStrategyTests.cs b/Source/EasyNetQ.Tests/DefaultMessageSerializationStrategyTests.cs
@@ -25,7 +25,7 @@ public void When_using_the_default_serialization_strategy_messages_are_correctly
         }
 
         [Fact]
-        public void When_serializing_a_message_with_a_correlationid_it_is_not_overwritten()
+        public void When_serializing_a_message_with_a_correlation_id_it_is_not_overwritten()
         {
             const string messageType = "MyMessageTypeName";
             var serializedMessageBody = Encoding.UTF8.GetBytes("Hello world!");
@@ -98,18 +98,18 @@ private void AssertMessageDeserializedCorrectly(IMessage<MyMessage> message, str
             Assert.Equal(message.Properties.ToString(), expectedMessageProperties); //, "Deserialized message properties do not match expected value");
         }
 
-        private DefaultMessageSerializationStrategy CreateSerializationStrategy(IMessage<MyMessage> message, string messageType, byte[] messageBody, string correlationId)
+        private static DefaultMessageSerializationStrategy CreateSerializationStrategy(IMessage<MyMessage> message, string messageType, byte[] messageBody, string correlationId)
         {
             var typeNameSerializer = Substitute.For<ITypeNameSerializer>();
             typeNameSerializer.Serialize(message.MessageType).Returns(messageType);
 
             var serializer = Substitute.For<ISerializer>();
-            serializer.MessageToBytes(message.GetBody()).Returns(messageBody);
+            serializer.MessageToBytes(message.MessageType, message.GetBody()).Returns(messageBody);
 
             return new DefaultMessageSerializationStrategy(typeNameSerializer, serializer, new StaticCorrelationIdGenerationStrategy(correlationId));
         }
 
-        private DefaultMessageSerializationStrategy CreateDeserializationStrategy(IMessage<MyMessage> message, byte[] messageBody, string correlationId)
+        private static DefaultMessageSerializationStrategy CreateDeserializationStrategy(IMessage<MyMessage> message, byte[] messageBody, string correlationId)
         {
             var typeNameSerializer = Substitute.For<ITypeNameSerializer>();
             typeNameSerializer.DeSerialize(message.Properties.Type).Returns(message.Body.GetType());
diff --git a/Source/EasyNetQ.Tests/Integration/ConsumerErrorConditionsTests.cs b/Source/EasyNetQ.Tests/Integration/ConsumerErrorConditionsTests.cs
@@ -95,7 +95,7 @@ public void Should_wrap_error_messages_correctly()
                 CorrelationId = correlationId
             };
 
-             bus.Advanced.Publish(exchange, typeNameSerializer.Serialize(typeof(MyErrorTestMessage)), true, props, serializer.MessageToBytes(message));
+             bus.Advanced.Publish(exchange, typeNameSerializer.Serialize(typeof(MyErrorTestMessage)), true, props, serializer.MessageToBytes(typeof(MyErrorTestMessage), message));
 
             // give the publish a chance to get to rabbit and back
             // also allow the DefaultConsumerErrorStrategy time to spin up its connection
diff --git a/Source/EasyNetQ.Tests/Integration/DefaultConsumerErrorStrategyTests.cs b/Source/EasyNetQ.Tests/Integration/DefaultConsumerErrorStrategyTests.cs
@@ -85,7 +85,7 @@ public void Should_handle_an_exception_by_writing_to_the_error_queue()
                 }
                 else
                 {
-                    var message = serializer.BytesToMessage<Error>(getArgs.Body);
+                    var message = (Error)serializer.BytesToMessage(typeof(Error), getArgs.Body);
 
                     message.RoutingKey.Should().Be(context.Info.RoutingKey);
                     message.Exchange.Should().Be(context.Info.Exchange);
diff --git a/Source/EasyNetQ.Tests/JsonSerializerTests.cs b/Source/EasyNetQ.Tests/JsonSerializerTests.cs
@@ -11,22 +11,30 @@ namespace EasyNetQ.Tests
 {
     public class JsonSerializerTests
     {
-        private ISerializer serializer;
+        private readonly ISerializer serializer;
 
         public JsonSerializerTests()
         {
             serializer = new JsonSerializer();
         }
+        
+        [Fact]
+        public void Should_be_able_to_serialize_and_deserialize_a_default_message()
+        {
+            var binaryMessage = serializer.MessageToBytes(typeof(MyMessage), default(MyMessage));
+            var deserializedMessage = (MyMessage)serializer.BytesToMessage(typeof(MyMessage), binaryMessage);
+            deserializedMessage.Should().BeNull();
+        }
 
         [Fact]
         public void Should_be_able_to_serialize_and_deserialize_a_message()
         {
             var message = new MyMessage {Text = "Hello World"};
 
-            var binaryMessage = serializer.MessageToBytes(message);
-            var deseralizedMessage = serializer.BytesToMessage<MyMessage>(binaryMessage);
+            var binaryMessage = serializer.MessageToBytes(typeof(MyMessage), message);
+            var deserializedMessage = (MyMessage)serializer.BytesToMessage(typeof(MyMessage), binaryMessage);
 
-            message.Text.Should().Be(deseralizedMessage.Text);
+            message.Text.Should().Be(deserializedMessage.Text);
         }
 
         [Fact]
@@ -55,8 +63,8 @@ public void Should_be_able_to_serialize_basic_properties()
             };
 
             var messageBasicProperties = new MessageProperties(originalProperties);
-            var binaryMessage = serializer.MessageToBytes(messageBasicProperties);
-            var deserializedMessageBasicProperties = serializer.BytesToMessage<MessageProperties>(binaryMessage);
+            var binaryMessage = serializer.MessageToBytes(typeof(MessageProperties), messageBasicProperties);
+            var deserializedMessageBasicProperties = (MessageProperties)serializer.BytesToMessage(typeof(MessageProperties), binaryMessage);
 
             var newProperties = new BasicProperties();
             deserializedMessageBasicProperties.CopyTo(newProperties);
@@ -81,17 +89,17 @@ class PolyMessage
         [Fact]
         public void Should_be_able_to_serialize_and_deserialize_polymorphic_properties()
         {
-            var bytes = serializer.MessageToBytes<PolyMessage>(new PolyMessage { AorB = new B() });
+            var bytes = serializer.MessageToBytes(typeof(PolyMessage), new PolyMessage { AorB = new B() });
 
-            var result = serializer.BytesToMessage<PolyMessage>(bytes);
+            var result = (PolyMessage)serializer.BytesToMessage(typeof(PolyMessage), bytes);
 
             Assert.IsType<B>(result.AorB);
         }
 
         [Fact]
         public void Should_be_able_to_serialize_and_deserialize_polymorphic_properties_when_using_TypeNameSerializer()
         {
-            var bytes = serializer.MessageToBytes(new PolyMessage { AorB = new B() });
+            var bytes = serializer.MessageToBytes(typeof(PolyMessage), new PolyMessage { AorB = new B() });
             var result = (PolyMessage)serializer.BytesToMessage(typeof(PolyMessage), bytes);
 
             Assert.IsType<B>(result.AorB);
diff --git a/Source/EasyNetQ.Tests/MessageVersioningTests/VersionedMessageSerializationStrategyTests.cs b/Source/EasyNetQ.Tests/MessageVersioningTests/VersionedMessageSerializationStrategyTests.cs
@@ -30,7 +30,7 @@ public void When_using_the_versioned_serialization_strategy_messages_are_correct
         }
 
         [Fact]
-        public void When_serializing_a_message_with_a_correlationid_it_is_not_overwritten()
+        public void When_serializing_a_message_with_a_correlation_id_it_is_not_overwritten()
         {
             const string messageType = "MyMessageTypeName";
             var serializedMessageBody = Encoding.UTF8.GetBytes("Hello world!");
@@ -115,7 +115,7 @@ public void When_using_the_versioned_serialization_strategy_versioned_messages_a
         }
 
         [Fact]
-        public void When_serializing_a_versioned_message_with_a_correlationid_it_is_not_overwritten()
+        public void When_serializing_a_versioned_message_with_a_correlation_id_it_is_not_overwritten()
         {
             const string messageType = "MyMessageV2TypeName";
             const string supersededMessageType = "MyMessageTypeName";
@@ -220,33 +220,33 @@ public void When_deserializing_versioned_message_use_first_available_message_typ
             Assert.Equal(((Message<MyMessageV2>)deserializedMessage).Body.Number, message.Body.Number);
         }
 
-        private void AssertMessageSerializedCorrectly(SerializedMessage message, byte[] expectedBody, Action<MessageProperties> assertMessagePropertiesCorrect)
+        private static void AssertMessageSerializedCorrectly(SerializedMessage message, byte[] expectedBody, Action<MessageProperties> assertMessagePropertiesCorrect)
         {
             Assert.Equal(message.Body, expectedBody); //, "Serialized message body does not match expected value");
             assertMessagePropertiesCorrect(message.Properties); //;
         }
 
-        private void AssertMessageDeserializedCorrectly(IMessage<MyMessage> message, string expectedBodyText, Type expectedMessageType, Action<MessageProperties> assertMessagePropertiesCorrect)
+        private static void AssertMessageDeserializedCorrectly(IMessage<MyMessage> message, string expectedBodyText, Type expectedMessageType, Action<MessageProperties> assertMessagePropertiesCorrect)
         {
             Assert.Equal(message.Body.Text, expectedBodyText); //, "Deserialized message body text does not match expected value");
             Assert.Equal(message.MessageType, expectedMessageType); //, "Deserialized message type does not match expected value");
 
             assertMessagePropertiesCorrect(message.Properties);
         }
 
-        private void AssertDefaultMessagePropertiesCorrect(MessageProperties properties, string expectedType, string expectedCorrelationId)
+        private static void AssertDefaultMessagePropertiesCorrect(MessageProperties properties, string expectedType, string expectedCorrelationId)
         {
             Assert.Equal(properties.Type, expectedType); //, "Message type does not match expected value");
             Assert.Equal(properties.CorrelationId, expectedCorrelationId); //, "Message correlation id does not match expected value");
         }
 
-        private void AssertVersionedMessagePropertiesCorrect(MessageProperties properties, string expectedType, string expectedCorrelationId, string alternativeTypes)
+        private static void AssertVersionedMessagePropertiesCorrect(MessageProperties properties, string expectedType, string expectedCorrelationId, string alternativeTypes)
         {
             AssertDefaultMessagePropertiesCorrect(properties, expectedType, expectedCorrelationId);
             Assert.Equal(properties.Headers[AlternativeMessageTypesHeaderKey], alternativeTypes); //, "Alternative message types do not match expected value");
         }
 
-        private VersionedMessageSerializationStrategy CreateSerializationStrategy<T>(IMessage<T> message, IEnumerable<KeyValuePair<string, Type>> messageTypes, byte[] messageBody, string correlationId) where T : class
+        private static VersionedMessageSerializationStrategy CreateSerializationStrategy<T>(IMessage<T> message, IEnumerable<KeyValuePair<string, Type>> messageTypes, byte[] messageBody, string correlationId) where T : class
         {
             var typeNameSerializer = Substitute.For<ITypeNameSerializer>();
             foreach (var messageType in messageTypes)
@@ -256,12 +256,12 @@ private VersionedMessageSerializationStrategy CreateSerializationStrategy<T>(IMe
             }
 
             var serializer = Substitute.For<ISerializer>();
-            serializer.MessageToBytes(message.GetBody()).Returns(messageBody);
+            serializer.MessageToBytes(typeof(T), message.GetBody()).Returns(messageBody);
 
             return new VersionedMessageSerializationStrategy(typeNameSerializer, serializer, new StaticCorrelationIdGenerationStrategy(correlationId));
         }
 
-        private VersionedMessageSerializationStrategy CreateDeserializationStrategy<T>(T message, IEnumerable<KeyValuePair<string, Type>> messageTypes, Type expectedMessageType, byte[] messageBody) where T : class
+        private static VersionedMessageSerializationStrategy CreateDeserializationStrategy<T>(T message, IEnumerable<KeyValuePair<string, Type>> messageTypes, Type expectedMessageType, byte[] messageBody) where T : class
         {
             var typeNameSerializer = Substitute.For<ITypeNameSerializer>();
             foreach (var messageType in messageTypes)
diff --git a/Source/EasyNetQ.Tests/SubscribeTests.cs b/Source/EasyNetQ.Tests/SubscribeTests.cs
@@ -247,7 +247,7 @@ public When_a_message_is_delivered()
             const string text = "Hello there, I am the text!";
             originalMessage = new MyMessage { Text = text };
 
-            var body = new JsonSerializer().MessageToBytes(originalMessage);
+            var body = new JsonSerializer().MessageToBytes(typeof(MyMessage), originalMessage);
 
             // deliver a message
             mockBuilder.Consumers[0].HandleBasicDeliver(
@@ -334,7 +334,7 @@ public When_the_handler_throws_an_exception()
             const string text = "Hello there, I am the text!";
             originalMessage = new MyMessage { Text = text };
 
-            var body = new JsonSerializer().MessageToBytes(originalMessage);
+            var body = new JsonSerializer().MessageToBytes(typeof(MyMessage), originalMessage);
 
             // deliver a message
             mockBuilder.Consumers[0].HandleBasicDeliver(
diff --git a/Source/EasyNetQ/Consumer/DefaultConsumerErrorStrategy.cs b/Source/EasyNetQ/Consumer/DefaultConsumerErrorStrategy.cs
@@ -227,7 +227,7 @@ private byte[] CreateErrorMessage(ConsumerExecutionContext context, Exception ex
                     kvp => kvp.Value is byte[] ? Encoding.UTF8.GetString((byte[])kvp.Value) : kvp.Value);
             }
 
-            return serializer.MessageToBytes(error);
+            return serializer.MessageToBytes(typeof(Error), error);
         }
 
         private bool disposed;
diff --git a/Source/EasyNetQ/Consumer/InternalConsumer.cs b/Source/EasyNetQ/Consumer/InternalConsumer.cs
@@ -118,18 +118,18 @@ public void HandleBasicDeliver(string consumerTag, ulong deliveryTag, bool redel
             }
 
             var messageReceivedInfo = new MessageReceivedInfo(consumerTag, deliveryTag, redelivered, exchange, routingKey, Queue.Name);
-            var messsageProperties = new MessageProperties(properties);
-            var context = new ConsumerExecutionContext(OnMessage, messageReceivedInfo, messsageProperties, body);
+            var messageProperties = new MessageProperties(properties);
+            var context = new ConsumerExecutionContext(OnMessage, messageReceivedInfo, messageProperties, body);
 
-            eventBus.Publish(new DeliveredMessageEvent(messageReceivedInfo, messsageProperties, body));
+            eventBus.Publish(new DeliveredMessageEvent(messageReceivedInfo, messageProperties, body));
             handlerRunner.InvokeUserMessageHandlerAsync(context)
                          .ContinueWith(async x =>
                             {
                                 var ackStrategy = await x.ConfigureAwait(false);
                                 consumerDispatcher.QueueAction(() =>
                                 {
                                     var ackResult = ackStrategy(Model, deliveryTag);
-                                    eventBus.Publish(new AckEvent(messageReceivedInfo, messsageProperties, body, ackResult));
+                                    eventBus.Publish(new AckEvent(messageReceivedInfo, messageProperties, body, ackResult));
                                 });
                             },
                             TaskContinuationOptions.ExecuteSynchronously
diff --git a/Source/EasyNetQ/DefaultMessageSerializationStrategy.cs b/Source/EasyNetQ/DefaultMessageSerializationStrategy.cs
@@ -16,7 +16,7 @@ public DefaultMessageSerializationStrategy(ITypeNameSerializer typeNameSerialize
         public SerializedMessage SerializeMessage(IMessage message)
         {
             var typeName = typeNameSerializer.Serialize(message.MessageType);
-            var messageBody = serializer.MessageToBytes(message.GetBody());
+            var messageBody = serializer.MessageToBytes(message.MessageType, message.GetBody());
             var messageProperties = message.Properties;
 
             messageProperties.Type = typeName;
diff --git a/Source/EasyNetQ/IMessage.cs b/Source/EasyNetQ/IMessage.cs
diff --git a/Source/EasyNetQ/ISerializer.cs b/Source/EasyNetQ/ISerializer.cs
diff --git a/Source/EasyNetQ/JsonSerializer.cs b/Source/EasyNetQ/JsonSerializer.cs
diff --git a/Source/EasyNetQ/MessageVersioning/VersionedMessageSerializationStrategy.cs b/Source/EasyNetQ/MessageVersioning/VersionedMessageSerializationStrategy.cs
diff --git a/Source/EasyNetQ/Producer/Rpc.cs b/Source/EasyNetQ/Producer/Rpc.cs

Original file line number	Diff line number	Diff line change
`@@ -7,17 +7,24 @@`
`7`	`7`	`using RabbitMQ.Client;`
`8`	`8`	`using RabbitMQ.Client.Exceptions;`
`9`	`9`	`using EasyNetQ.Tests;`
	`10`	`+using Xunit.Abstractions;`
`10`	`11`
`11`	`12`	`namespace EasyNetQ.Hosepipe.Tests`
`12`	`13`	`{`
`13`	`14`	`public class ErrorMessageRepublishSpike`
`14`	`15`	`{`
	`16`	`+ private readonly ITestOutputHelper testOutputHelper;`
`15`	`17`	`readonly ISerializer serializer = new JsonSerializer();`
`16`	`18`
	`19`	`+ public ErrorMessageRepublishSpike(ITestOutputHelper testOutputHelper)`
	`20`	`+ {`
	`21`	`+ this.testOutputHelper = testOutputHelper;`
	`22`	`+ }`
	`23`	`+`
`17`	`24`	`[Fact]`
`18`	`25`	`public void Should_deserialise_error_message_correctly()`
`19`	`26`	`{`
`20`		`- var error = serializer.BytesToMessage<Error>(Encoding.UTF8.GetBytes(errorMessage));`
	`27`	`+ var error = (Error)serializer.BytesToMessage(typeof(Error), Encoding.UTF8.GetBytes(errorMessage));`
`21`	`28`
`22`	`29`	`error.RoutingKey.ShouldEqual("originalRoutingKey");`
`23`	`30`	`error.Message.ShouldEqual("{ Text:\"Hello World\"}");`
`@@ -27,14 +34,14 @@ public void Should_deserialise_error_message_correctly()`
`27`	`34`	`public void Should_fail_to_deseralize_some_other_random_message()`
`28`	`35`	`{`
`29`	`36`	`const string randomMessage = "{\"Text\":\"Hello World\"}";`
`30`		`- var error = serializer.BytesToMessage<Error>(Encoding.UTF8.GetBytes(randomMessage));`
	`37`	`+ var error = (Error)serializer.BytesToMessage(typeof(Error), Encoding.UTF8.GetBytes(randomMessage));`
`31`	`38`	`error.Message.ShouldBeNull();`
`32`	`39`	`}`
`33`	`40`
`34`	`41`	`[Fact][Explicit("Requires a localhost instance of RabbitMQ to run")]`
`35`	`42`	`public void Should_be_able_to_republish_message()`
`36`	`43`	`{`
`37`		`- var error = serializer.BytesToMessage<Error>(Encoding.UTF8.GetBytes(errorMessage));`
	`44`	`+ var error = (Error)serializer.BytesToMessage(typeof(Error), Encoding.UTF8.GetBytes(errorMessage));`
`38`	`45`
`39`	`46`	`var connectionFactory = new ConnectionFactory`
`40`	`47`	`{`
`@@ -59,8 +66,7 @@ public void Should_be_able_to_republish_message()`
`59`	`66`	`}`
`60`	`67`	`catch (OperationInterruptedException)`
`61`	`68`	`{`
`62`		`- Console.WriteLine("The exchange, '{0}', described in the error message does not exist on '{1}', '{2}'",`
`63`		`- error.Exchange, connectionFactory.HostName, connectionFactory.VirtualHost);`
	`69`	`+ testOutputHelper.WriteLine("The exchange, '{0}', described in the error message does not exist on '{1}', '{2}'", error.Exchange, connectionFactory.HostName, connectionFactory.VirtualHost);`
`64`	`70`	`}`
`65`	`71`	`}`
`66`	`72`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public void RetryErrors(IEnumerable<HosepipeMessage> rawErrorMessages, QueuePara`
`24`	`24`	`{`
`25`	`25`	`foreach (var rawErrorMessage in rawErrorMessages)`
`26`	`26`	`{`
`27`		`- var error = serializer.BytesToMessage<Error>(errorMessageSerializer.Deserialize(rawErrorMessage.Body));`
	`27`	`+ var error = (Error)serializer.BytesToMessage(typeof(Error), errorMessageSerializer.Deserialize(rawErrorMessage.Body));`
`28`	`28`	`RepublishError(error, parameters);`
`29`	`29`	`}`
`30`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,7 +60,7 @@ public void Dispose()`
`60`	`60`
`61`	`61`	`private void Deliver<T>(T message) where T : class`
`62`	`62`	`{`
`63`		`- var body = new JsonSerializer().MessageToBytes(message);`
	`63`	`+ var body = new JsonSerializer().MessageToBytes(typeof(T), message);`
`64`	`64`	`var properties = new BasicProperties`
`65`	`65`	`{`
`66`	`66`	`Type = new DefaultTypeNameSerializer().Serialize(typeof(T))`
Original file line number	Diff line number	Diff line change
`@@ -25,7 +25,7 @@ public void When_using_the_default_serialization_strategy_messages_are_correctly`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`[Fact]`
`28`		`- public void When_serializing_a_message_with_a_correlationid_it_is_not_overwritten()`
	`28`	`+ public void When_serializing_a_message_with_a_correlation_id_it_is_not_overwritten()`
`29`	`29`	`{`
`30`	`30`	`const string messageType = "MyMessageTypeName";`
`31`	`31`	`var serializedMessageBody = Encoding.UTF8.GetBytes("Hello world!");`
`@@ -98,18 +98,18 @@ private void AssertMessageDeserializedCorrectly(IMessage<MyMessage> message, str`
`98`	`98`	`Assert.Equal(message.Properties.ToString(), expectedMessageProperties); //, "Deserialized message properties do not match expected value");`
`99`	`99`	`}`
`100`	`100`
`101`		`- private DefaultMessageSerializationStrategy CreateSerializationStrategy(IMessage<MyMessage> message, string messageType, byte[] messageBody, string correlationId)`
	`101`	`+ private static DefaultMessageSerializationStrategy CreateSerializationStrategy(IMessage<MyMessage> message, string messageType, byte[] messageBody, string correlationId)`
`102`	`102`	`{`
`103`	`103`	`var typeNameSerializer = Substitute.For<ITypeNameSerializer>();`
`104`	`104`	`typeNameSerializer.Serialize(message.MessageType).Returns(messageType);`
`105`	`105`
`106`	`106`	`var serializer = Substitute.For<ISerializer>();`
`107`		`- serializer.MessageToBytes(message.GetBody()).Returns(messageBody);`
	`107`	`+ serializer.MessageToBytes(message.MessageType, message.GetBody()).Returns(messageBody);`
`108`	`108`
`109`	`109`	`return new DefaultMessageSerializationStrategy(typeNameSerializer, serializer, new StaticCorrelationIdGenerationStrategy(correlationId));`
`110`	`110`	`}`
`111`	`111`
`112`		`- private DefaultMessageSerializationStrategy CreateDeserializationStrategy(IMessage<MyMessage> message, byte[] messageBody, string correlationId)`
	`112`	`+ private static DefaultMessageSerializationStrategy CreateDeserializationStrategy(IMessage<MyMessage> message, byte[] messageBody, string correlationId)`
`113`	`113`	`{`
`114`	`114`	`var typeNameSerializer = Substitute.For<ITypeNameSerializer>();`
`115`	`115`	`typeNameSerializer.DeSerialize(message.Properties.Type).Returns(message.Body.GetType());`
Original file line number	Diff line number	Diff line change
`@@ -85,7 +85,7 @@ public void Should_handle_an_exception_by_writing_to_the_error_queue()`
`85`	`85`	`}`
`86`	`86`	`else`
`87`	`87`	`{`
`88`		`- var message = serializer.BytesToMessage<Error>(getArgs.Body);`
	`88`	`+ var message = (Error)serializer.BytesToMessage(typeof(Error), getArgs.Body);`
`89`	`89`
`90`	`90`	`message.RoutingKey.Should().Be(context.Info.RoutingKey);`
`91`	`91`	`message.Exchange.Should().Be(context.Info.Exchange);`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ public void When_using_the_versioned_serialization_strategy_messages_are_correct`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`[Fact]`
`33`		`- public void When_serializing_a_message_with_a_correlationid_it_is_not_overwritten()`
	`33`	`+ public void When_serializing_a_message_with_a_correlation_id_it_is_not_overwritten()`
`34`	`34`	`{`
`35`	`35`	`const string messageType = "MyMessageTypeName";`
`36`	`36`	`var serializedMessageBody = Encoding.UTF8.GetBytes("Hello world!");`
`@@ -115,7 +115,7 @@ public void When_using_the_versioned_serialization_strategy_versioned_messages_a`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`[Fact]`
`118`		`- public void When_serializing_a_versioned_message_with_a_correlationid_it_is_not_overwritten()`
	`118`	`+ public void When_serializing_a_versioned_message_with_a_correlation_id_it_is_not_overwritten()`
`119`	`119`	`{`
`120`	`120`	`const string messageType = "MyMessageV2TypeName";`
`121`	`121`	`const string supersededMessageType = "MyMessageTypeName";`
`@@ -220,33 +220,33 @@ public void When_deserializing_versioned_message_use_first_available_message_typ`
`220`	`220`	`Assert.Equal(((Message<MyMessageV2>)deserializedMessage).Body.Number, message.Body.Number);`
`221`	`221`	`}`
`222`	`222`
`223`		`- private void AssertMessageSerializedCorrectly(SerializedMessage message, byte[] expectedBody, Action<MessageProperties> assertMessagePropertiesCorrect)`
	`223`	`+ private static void AssertMessageSerializedCorrectly(SerializedMessage message, byte[] expectedBody, Action<MessageProperties> assertMessagePropertiesCorrect)`
`224`	`224`	`{`
`225`	`225`	`Assert.Equal(message.Body, expectedBody); //, "Serialized message body does not match expected value");`
`226`	`226`	`assertMessagePropertiesCorrect(message.Properties); //;`
`227`	`227`	`}`
`228`	`228`
`229`		`- private void AssertMessageDeserializedCorrectly(IMessage<MyMessage> message, string expectedBodyText, Type expectedMessageType, Action<MessageProperties> assertMessagePropertiesCorrect)`
	`229`	`+ private static void AssertMessageDeserializedCorrectly(IMessage<MyMessage> message, string expectedBodyText, Type expectedMessageType, Action<MessageProperties> assertMessagePropertiesCorrect)`
`230`	`230`	`{`
`231`	`231`	`Assert.Equal(message.Body.Text, expectedBodyText); //, "Deserialized message body text does not match expected value");`
`232`	`232`	`Assert.Equal(message.MessageType, expectedMessageType); //, "Deserialized message type does not match expected value");`
`233`	`233`
`234`	`234`	`assertMessagePropertiesCorrect(message.Properties);`
`235`	`235`	`}`
`236`	`236`
`237`		`- private void AssertDefaultMessagePropertiesCorrect(MessageProperties properties, string expectedType, string expectedCorrelationId)`
	`237`	`+ private static void AssertDefaultMessagePropertiesCorrect(MessageProperties properties, string expectedType, string expectedCorrelationId)`
`238`	`238`	`{`
`239`	`239`	`Assert.Equal(properties.Type, expectedType); //, "Message type does not match expected value");`
`240`	`240`	`Assert.Equal(properties.CorrelationId, expectedCorrelationId); //, "Message correlation id does not match expected value");`
`241`	`241`	`}`
`242`	`242`
`243`		`- private void AssertVersionedMessagePropertiesCorrect(MessageProperties properties, string expectedType, string expectedCorrelationId, string alternativeTypes)`
	`243`	`+ private static void AssertVersionedMessagePropertiesCorrect(MessageProperties properties, string expectedType, string expectedCorrelationId, string alternativeTypes)`
`244`	`244`	`{`
`245`	`245`	`AssertDefaultMessagePropertiesCorrect(properties, expectedType, expectedCorrelationId);`
`246`	`246`	`Assert.Equal(properties.Headers[AlternativeMessageTypesHeaderKey], alternativeTypes); //, "Alternative message types do not match expected value");`
`247`	`247`	`}`
`248`	`248`
`249`		`- private VersionedMessageSerializationStrategy CreateSerializationStrategy<T>(IMessage<T> message, IEnumerable<KeyValuePair<string, Type>> messageTypes, byte[] messageBody, string correlationId) where T : class`
	`249`	`+ private static VersionedMessageSerializationStrategy CreateSerializationStrategy<T>(IMessage<T> message, IEnumerable<KeyValuePair<string, Type>> messageTypes, byte[] messageBody, string correlationId) where T : class`
`250`	`250`	`{`
`251`	`251`	`var typeNameSerializer = Substitute.For<ITypeNameSerializer>();`
`252`	`252`	`foreach (var messageType in messageTypes)`
`@@ -256,12 +256,12 @@ private VersionedMessageSerializationStrategy CreateSerializationStrategy<T>(IMe`
`256`	`256`	`}`
`257`	`257`
`258`	`258`	`var serializer = Substitute.For<ISerializer>();`
`259`		`- serializer.MessageToBytes(message.GetBody()).Returns(messageBody);`
	`259`	`+ serializer.MessageToBytes(typeof(T), message.GetBody()).Returns(messageBody);`
`260`	`260`
`261`	`261`	`return new VersionedMessageSerializationStrategy(typeNameSerializer, serializer, new StaticCorrelationIdGenerationStrategy(correlationId));`
`262`	`262`	`}`
`263`	`263`
`264`		`- private VersionedMessageSerializationStrategy CreateDeserializationStrategy<T>(T message, IEnumerable<KeyValuePair<string, Type>> messageTypes, Type expectedMessageType, byte[] messageBody) where T : class`
	`264`	`+ private static VersionedMessageSerializationStrategy CreateDeserializationStrategy<T>(T message, IEnumerable<KeyValuePair<string, Type>> messageTypes, Type expectedMessageType, byte[] messageBody) where T : class`
`265`	`265`	`{`
`266`	`266`	`var typeNameSerializer = Substitute.For<ITypeNameSerializer>();`
`267`	`267`	`foreach (var messageType in messageTypes)`