Using same ExchangeDeclareStrategy for publish and subscribe (#962)

justmara · Pliner · commit 35d5928ad133 · 2019-07-17T10:05:00.000+05:00
* using same ExchangeDeclareStrategy for publish and subscribe

* rename: PublishExchandeDeclareStrategy -&gt; ExchangeDeclareStrategy

* also renamed in tests and argiment constraints constants
diff --git a/Source/EasyNetQ.Tests/MessageVersioningTests/MessageVersioningExtensionsTests.cs b/Source/EasyNetQ.Tests/MessageVersioningTests/MessageVersioningExtensionsTests.cs
@@ -18,7 +18,7 @@ public void When_using_EnableMessageVersioning_extension_method_required_service
 
             serviceRegister.EnableMessageVersioning();
 
-            serviceRegister.AssertServiceRegistered<IPublishExchangeDeclareStrategy, VersionedPublishExchangeDeclareStrategy>();
+            serviceRegister.AssertServiceRegistered<IExchangeDeclareStrategy, VersionedExchangeDeclareStrategy>();
             serviceRegister.AssertServiceRegistered<IMessageSerializationStrategy, VersionedMessageSerializationStrategy>();
         }
 
diff --git a/Source/EasyNetQ.Tests/MessageVersioningTests/VersionedExchangeDeclareStrategyTests.cs b/Source/EasyNetQ.Tests/MessageVersioningTests/VersionedExchangeDeclareStrategyTests.cs
@@ -11,7 +11,7 @@
 
 namespace EasyNetQ.Tests.MessageVersioningTests
 {
-    public class VersionedPublishExchangeDeclareStrategyTests
+    public class VersionedExchangeDeclareStrategyTests
     {
         [Fact]
         public void Should_declare_exchange_again_if_first_attempt_failed()
@@ -33,16 +33,16 @@ public void Should_declare_exchange_again_if_first_attempt_failed()
             var conventions = Substitute.For<IConventions>();
             conventions.ExchangeNamingConvention = t => t.Name;
 
-            var publishExchangeDeclareStrategy = new VersionedPublishExchangeDeclareStrategy(conventions, advancedBus);
+            var exchangeDeclareStrategy = new VersionedExchangeDeclareStrategy(conventions, advancedBus);
             try
             {
-                publishExchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);
+                exchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);
             }
             catch (Exception)
             {
             }
 
-            var declaredExchange = publishExchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);
+            var declaredExchange = exchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);
             advancedBus.Received(2).ExchangeDeclare(exchangeName, "topic");
             declaredExchange.Should().BeSameAs(exchange);
             exchangeDeclareCount.Should().Be(1);
@@ -76,7 +76,7 @@ public void When_declaring_exchanges_for_unversioned_message_one_exchange_create
             var conventions = Substitute.For<IConventions>();
             conventions.ExchangeNamingConvention = t => t.Name;
 
-            var publishExchangeStrategy = new VersionedPublishExchangeDeclareStrategy(conventions, advancedBus);
+            var publishExchangeStrategy = new VersionedExchangeDeclareStrategy(conventions, advancedBus);
 
             publishExchangeStrategy.DeclareExchange(typeof(MyMessage), ExchangeType.Topic);
 
@@ -111,7 +111,7 @@ public void When_declaring_exchanges_for_versioned_message_exchange_per_version_
             var conventions = Substitute.For<IConventions>();
             conventions.ExchangeNamingConvention = t => t.Name;
             
-            var publishExchangeStrategy = new VersionedPublishExchangeDeclareStrategy(conventions, advancedBus);
+            var publishExchangeStrategy = new VersionedExchangeDeclareStrategy(conventions, advancedBus);
 
             publishExchangeStrategy.DeclareExchange(typeof(MyMessageV2), ExchangeType.Topic);
 
@@ -128,4 +128,4 @@ private class ExchangeStub : IExchange
             public ExchangeStub BoundTo { get; set; }
         }
     }
-}
+}
diff --git a/Source/EasyNetQ.Tests/MultipleExchangeTest/MultipleExchangeExchangeDeclareStrategyTests.cs b/Source/EasyNetQ.Tests/MultipleExchangeTest/MultipleExchangeExchangeDeclareStrategyTests.cs
@@ -7,7 +7,7 @@
 
 namespace EasyNetQ.Tests.MultipleExchangeTest
 {
-    public class AdvancedPolymorphismPublishExchangeDeclareStrategyTests
+    public class AdvancedPolymorphismExchangeDeclareStrategyTests
     {
         [Fact(Skip = "Needs to be updated to XUnit")]
         public void When_declaring_exchanges_for_message_type_that_has_no_interface_one_exchange_created()
@@ -32,9 +32,9 @@ public void When_declaring_exchanges_for_message_type_that_has_no_interface_one_
             var conventions = Substitute.For<IConventions>();
             conventions.ExchangeNamingConvention = t => t.Name;
 
-            var publishExchangeStrategy = new MultipleExchangePublishExchangeDeclareStrategy(conventions, advancedBus);
+            var exchangeStrategy = new MultipleExchangeDeclareStrategy(conventions, advancedBus);
 
-            publishExchangeStrategy.DeclareExchangeAsync(typeof(MyMessage), ExchangeType.Topic).Wait();
+            exchangeStrategy.DeclareExchangeAsync(typeof(MyMessage), ExchangeType.Topic).Wait();
 
 /*
             //ensure that only one exchange is declared
@@ -145,4 +145,4 @@ public void When_declaring_exchanges_for_message_with_two_interfaces_exchange_pe
                 Arg<string>.Is.Anything), opt => opt.Repeat.Times(1));*/
         }
     }
-}
+}
diff --git a/Source/EasyNetQ.Tests/ProducerTests/PublishExchangeDeclareStrategyTests.cs b/Source/EasyNetQ.Tests/ProducerTests/PublishExchangeDeclareStrategyTests.cs
@@ -10,7 +10,7 @@
 
 namespace EasyNetQ.Tests.ProducerTests
 {
-    public class PublishExchangeDeclareStrategyTests
+    public class ExchangeDeclareStrategyTests
     {
         private const string exchangeName = "the_exchange";
 
@@ -27,9 +27,9 @@ public void Should_declare_exchange_the_first_time_declare_is_called()
                     return exchange;
                 });
 
-            var publishExchangeDeclareStrategy = new PublishExchangeDeclareStrategy(Substitute.For<IConventions>(), advancedBus);
+            var exchangeDeclareStrategy = new DefaultExchangeDeclareStrategy(Substitute.For<IConventions>(), advancedBus);
            
-            var declaredExchange = publishExchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);
+            var declaredExchange = exchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);
 
             advancedBus.Received().ExchangeDeclare(exchangeName, "topic");
             declaredExchange.Should().BeSameAs(exchange);
@@ -48,10 +48,10 @@ public void Should_not_declare_exchange_the_second_time_declare_is_called()
                 return exchange;
             });
 
-            var publishExchangeDeclareStrategy = new PublishExchangeDeclareStrategy(Substitute.For<IConventions>(), advancedBus);
+            var exchangeDeclareStrategy = new DefaultExchangeDeclareStrategy(Substitute.For<IConventions>(), advancedBus);
   
-            var _ = publishExchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);
-            var declaredExchange = publishExchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);
+            var _ = exchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);
+            var declaredExchange = exchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);
 
             advancedBus.Received().ExchangeDeclare(exchangeName, "topic");
             declaredExchange.Should().BeSameAs(exchange);
@@ -74,20 +74,20 @@ public void Should_declare_exchange_again_if_first_attempt_failed()
                     return exchange;
                 });
 
-            var publishExchangeDeclareStrategy = new VersionedPublishExchangeDeclareStrategy(Substitute.For<IConventions>(), advancedBus);
+            var exchangeDeclareStrategy = new VersionedExchangeDeclareStrategy(Substitute.For<IConventions>(), advancedBus);
             try
             {
-                publishExchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);
+                exchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);
             }
             catch (Exception)
             {
             }
-            var declaredExchange = publishExchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);
+            var declaredExchange = exchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);
             advancedBus.Received(2).ExchangeDeclare(exchangeName, "topic");
             declaredExchange.Should().BeSameAs(exchange);
             exchangeDeclareCount.Should().Be(1);
         }
     }
 }
 
-// ReSharper restore InconsistentNaming
+// ReSharper restore InconsistentNaming
diff --git a/Source/EasyNetQ/DI/DefaultServicesRegistration.cs b/Source/EasyNetQ/DI/DefaultServicesRegistration.cs
@@ -32,7 +32,7 @@ public static void RegisterDefaultServices(this IServiceRegister container)
                 .Register(AdvancedBusEventHandlers.Default)
                 .Register<IProduceConsumeInterceptor, DefaultInterceptor>()
                 .Register<IConsumerDispatcherFactory, ConsumerDispatcherFactory>()
-                .Register<IPublishExchangeDeclareStrategy, PublishExchangeDeclareStrategy>()
+                .Register<IExchangeDeclareStrategy, DefaultExchangeDeclareStrategy>()
                 .Register<IConsumerErrorStrategy, DefaultConsumerErrorStrategy>()
                 .Register<IErrorMessageSerializer, DefaultErrorMessageSerializer>()
                 .Register<IHandlerRunner, HandlerRunner>()
diff --git a/Source/EasyNetQ/MessageVersioning/ISupersede.cs b/Source/EasyNetQ/MessageVersioning/ISupersede.cs
@@ -6,7 +6,7 @@ namespace EasyNetQ.MessageVersioning
     /// Marker interface to indicate that a message supersedes a previous version.
     /// </summary>
     /// <remarks>
-    /// Requires that <see cref="VersionedMessageSerializationStrategy"/> and <see cref="VersionedPublishExchangeDeclareStrategy"/> are
+    /// Requires that <see cref="VersionedMessageSerializationStrategy"/> and <see cref="VersionedExchangeDeclareStrategy"/> are
     /// registered in the <see cref="IServiceRegister"/> to take advantage of message version support.
     /// </remarks>
     /// <typeparam name="T">The type of the message being superseded.</typeparam>
diff --git a/Source/EasyNetQ/MessageVersioning/MessageVersioningExtensions.cs b/Source/EasyNetQ/MessageVersioning/MessageVersioningExtensions.cs
@@ -8,8 +8,8 @@ public static class MessageVersioningExtensions
          public static IServiceRegister EnableMessageVersioning( this IServiceRegister serviceRegister )
          {
              return serviceRegister
-                 .Register<IPublishExchangeDeclareStrategy, VersionedPublishExchangeDeclareStrategy>()
+                 .Register<IExchangeDeclareStrategy, VersionedExchangeDeclareStrategy>()
                  .Register<IMessageSerializationStrategy, VersionedMessageSerializationStrategy>();
          }
     }
-}
+}
diff --git a/Source/EasyNetQ/MessageVersioning/VersionedExchangeDeclareStrategy.cs b/Source/EasyNetQ/MessageVersioning/VersionedExchangeDeclareStrategy.cs
@@ -7,14 +7,14 @@
 
 namespace EasyNetQ.MessageVersioning
 {
-    public class VersionedPublishExchangeDeclareStrategy : IPublishExchangeDeclareStrategy
+    public class VersionedExchangeDeclareStrategy : IExchangeDeclareStrategy
     {
         private readonly IAdvancedBus advancedBus;
         private readonly AsyncLock asyncLock = new AsyncLock();
         private readonly IConventions conventions;
         private readonly ConcurrentDictionary<string, IExchange> exchanges = new ConcurrentDictionary<string, IExchange>();
 
-        public VersionedPublishExchangeDeclareStrategy(IConventions conventions, IAdvancedBus advancedBus)
+        public VersionedExchangeDeclareStrategy(IConventions conventions, IAdvancedBus advancedBus)
         {
             Preconditions.CheckNotNull(conventions, "conventions");
             Preconditions.CheckNotNull(advancedBus, "advancedBus");
@@ -90,4 +90,4 @@ private IExchange DeclareVersionedExchanges(MessageVersionStack messageVersions,
             return destinationExchange;
         }
     }
-}
+}
diff --git a/Source/EasyNetQ/MultipleExchange/MultipleExchangeDeclareStrategy.cs b/Source/EasyNetQ/MultipleExchange/MultipleExchangeDeclareStrategy.cs
@@ -7,14 +7,14 @@
 
 namespace EasyNetQ.MultipleExchange
 {
-    public class MultipleExchangePublishExchangeDeclareStrategy : IPublishExchangeDeclareStrategy
+    public class MultipleExchangeDeclareStrategy : IExchangeDeclareStrategy
     {
         private readonly IAdvancedBus advancedBus;
         private readonly AsyncLock asyncLock = new AsyncLock();
         private readonly IConventions conventions;
         private readonly ConcurrentDictionary<string, IExchange> exchanges = new ConcurrentDictionary<string, IExchange>();
 
-        public MultipleExchangePublishExchangeDeclareStrategy(IConventions conventions, IAdvancedBus advancedBus)
+        public MultipleExchangeDeclareStrategy(IConventions conventions, IAdvancedBus advancedBus)
         {
             Preconditions.CheckNotNull(conventions, "conventions");
             Preconditions.CheckNotNull(advancedBus, "advancedBus");
@@ -81,4 +81,4 @@ public async Task<IExchange> DeclareExchangeAsync(string exchangeName, string ex
             }
         }
     }
-}
+}
diff --git a/Source/EasyNetQ/MultipleExchange/MultipleExchangeExtension.cs b/Source/EasyNetQ/MultipleExchange/MultipleExchangeExtension.cs
@@ -8,7 +8,7 @@ public static class MultipleExchangeExtension
         public static IServiceRegister EnableAdvancedMessagePolymorphism(this IServiceRegister serviceRegister)
         {
             return serviceRegister
-                .Register<IPublishExchangeDeclareStrategy, MultipleExchangePublishExchangeDeclareStrategy>();
+                .Register<IExchangeDeclareStrategy, MultipleExchangeDeclareStrategy>();
         }
     }
 }
diff --git a/Source/EasyNetQ/NonGeneric/NonGenericExtensions.cs b/Source/EasyNetQ/NonGeneric/NonGenericExtensions.cs
@@ -89,10 +89,10 @@ public static Task PublishAsync(this IBus bus, Type messageType, object message,
             Preconditions.CheckTypeMatches(messageType, message, "message", "message must be of type " + messageType);
             
             var advancedBus = bus.Advanced.Container.Resolve<IAdvancedBus>();
-            var publishExchangeDeclareStrategy = bus.Advanced.Container.Resolve<IPublishExchangeDeclareStrategy>();
+            var exchangeDeclareStrategy = bus.Advanced.Container.Resolve<IExchangeDeclareStrategy>();
             var messageDeliveryModeStrategy = bus.Advanced.Container.Resolve<IMessageDeliveryModeStrategy>();
             
-            var exchange = publishExchangeDeclareStrategy.DeclareExchange(messageType, ExchangeType.Topic);
+            var exchange = exchangeDeclareStrategy.DeclareExchange(messageType, ExchangeType.Topic);
             var easyNetQMessage = MessageFactory.CreateInstance(messageType, message);
             easyNetQMessage.Properties.DeliveryMode = messageDeliveryModeStrategy.GetDeliveryMode(messageType);
 
@@ -110,4 +110,4 @@ private static bool HasCorrectParameters(MethodInfo methodInfo)
                 parameters[2].ParameterType == typeof(Action<ISubscriptionConfiguration>);
         }
     }
-}
+}
diff --git a/Source/EasyNetQ/Producer/DefaultExchangeDeclareStrategy.cs b/Source/EasyNetQ/Producer/DefaultExchangeDeclareStrategy.cs
@@ -6,14 +6,14 @@
 
 namespace EasyNetQ.Producer
 {
-    public class PublishExchangeDeclareStrategy : IPublishExchangeDeclareStrategy
+    public class DefaultExchangeDeclareStrategy : IExchangeDeclareStrategy
     {
         private readonly IAdvancedBus advancedBus;
         private readonly AsyncLock asyncLock = new AsyncLock();
         private readonly IConventions conventions;
         private readonly ConcurrentDictionary<string, IExchange> exchanges = new ConcurrentDictionary<string, IExchange>();
 
-        public PublishExchangeDeclareStrategy(IConventions conventions, IAdvancedBus advancedBus)
+        public DefaultExchangeDeclareStrategy(IConventions conventions, IAdvancedBus advancedBus)
         {
             Preconditions.CheckNotNull(conventions, "conventions");
             Preconditions.CheckNotNull(advancedBus, "advancedBus");
@@ -58,4 +58,4 @@ public Task<IExchange> DeclareExchangeAsync(Type messageType, string exchangeTyp
             return DeclareExchangeAsync(exchangeName, exchangeType);
         }
     }
-}
+}
diff --git a/Source/EasyNetQ/Producer/IExchangeDeclareStrategy.cs b/Source/EasyNetQ/Producer/IExchangeDeclareStrategy.cs
@@ -4,7 +4,7 @@
 
 namespace EasyNetQ.Producer
 {
-    public interface IPublishExchangeDeclareStrategy
+    public interface IExchangeDeclareStrategy
     {
         IExchange DeclareExchange(string exchangeName, string exchangeType);
         IExchange DeclareExchange(Type messageType, string exchangeType);        
diff --git a/Source/EasyNetQ/Producer/Rpc.cs b/Source/EasyNetQ/Producer/Rpc.cs
@@ -17,7 +17,7 @@ public class Rpc : IRpc
         private readonly ConnectionConfiguration connectionConfiguration;
         protected readonly IAdvancedBus advancedBus;
         protected readonly IConventions conventions;
-        protected readonly IPublishExchangeDeclareStrategy publishExchangeDeclareStrategy;
+        protected readonly IExchangeDeclareStrategy exchangeDeclareStrategy;
         protected readonly IMessageDeliveryModeStrategy messageDeliveryModeStrategy;
         private readonly ITimeoutStrategy timeoutStrategy;
         private readonly ITypeNameSerializer typeNameSerializer;
@@ -36,24 +36,24 @@ public Rpc(
             IAdvancedBus advancedBus,
             IEventBus eventBus,
             IConventions conventions,
-            IPublishExchangeDeclareStrategy publishExchangeDeclareStrategy,
+            IExchangeDeclareStrategy exchangeDeclareStrategy,
             IMessageDeliveryModeStrategy messageDeliveryModeStrategy,
             ITimeoutStrategy timeoutStrategy,
             ITypeNameSerializer typeNameSerializer)
         {
-            Preconditions.CheckNotNull(connectionConfiguration, "configuration");
-            Preconditions.CheckNotNull(advancedBus, "advancedBus");
-            Preconditions.CheckNotNull(eventBus, "eventBus");
-            Preconditions.CheckNotNull(conventions, "conventions");
-            Preconditions.CheckNotNull(publishExchangeDeclareStrategy, "publishExchangeDeclareStrategy");
-            Preconditions.CheckNotNull(messageDeliveryModeStrategy, "messageDeliveryModeStrategy");
-            Preconditions.CheckNotNull(timeoutStrategy, "timeoutStrategy");
-            Preconditions.CheckNotNull(typeNameSerializer, "typeNameSerializer");
+            Preconditions.CheckNotNull(connectionConfiguration, nameof(connectionConfiguration));
+            Preconditions.CheckNotNull(advancedBus, nameof(advancedBus));
+            Preconditions.CheckNotNull(eventBus, nameof(eventBus));
+            Preconditions.CheckNotNull(conventions, nameof(conventions));
+            Preconditions.CheckNotNull(exchangeDeclareStrategy, nameof(exchangeDeclareStrategy));
+            Preconditions.CheckNotNull(messageDeliveryModeStrategy, nameof(messageDeliveryModeStrategy));
+            Preconditions.CheckNotNull(timeoutStrategy, nameof(timeoutStrategy));
+            Preconditions.CheckNotNull(typeNameSerializer, nameof(typeNameSerializer));
 
             this.connectionConfiguration = connectionConfiguration;
             this.advancedBus = advancedBus;
             this.conventions = conventions;
-            this.publishExchangeDeclareStrategy = publishExchangeDeclareStrategy;
+            this.exchangeDeclareStrategy = exchangeDeclareStrategy;
             this.messageDeliveryModeStrategy = messageDeliveryModeStrategy;
             this.timeoutStrategy = timeoutStrategy;
             this.typeNameSerializer = typeNameSerializer;
@@ -347,7 +347,7 @@ private IExchange DeclareRpcExchange(string exchangeName)
         {
             if (exchangeName != Exchange.GetDefault().Name)
             {
-                return publishExchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Direct);
+                return exchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Direct);
             }
             else
             {
diff --git a/Source/EasyNetQ/RabbitBus.cs b/Source/EasyNetQ/RabbitBus.cs
diff --git a/Source/EasyNetQ/Scheduling/ExternalScheduler.cs b/Source/EasyNetQ/Scheduling/ExternalScheduler.cs

Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ public void When_using_EnableMessageVersioning_extension_method_required_service`
`18`	`18`
`19`	`19`	`serviceRegister.EnableMessageVersioning();`
`20`	`20`
`21`		`- serviceRegister.AssertServiceRegistered<IPublishExchangeDeclareStrategy, VersionedPublishExchangeDeclareStrategy>();`
	`21`	`+ serviceRegister.AssertServiceRegistered<IExchangeDeclareStrategy, VersionedExchangeDeclareStrategy>();`
`22`	`22`	`serviceRegister.AssertServiceRegistered<IMessageSerializationStrategy, VersionedMessageSerializationStrategy>();`
`23`	`23`	`}`
`24`	`24`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@`
`11`	`11`
`12`	`12`	`namespace EasyNetQ.Tests.MessageVersioningTests`
`13`	`13`	`{`
`14`		`- public class VersionedPublishExchangeDeclareStrategyTests`
	`14`	`+ public class VersionedExchangeDeclareStrategyTests`
`15`	`15`	`{`
`16`	`16`	`[Fact]`
`17`	`17`	`public void Should_declare_exchange_again_if_first_attempt_failed()`
`@@ -33,16 +33,16 @@ public void Should_declare_exchange_again_if_first_attempt_failed()`
`33`	`33`	`var conventions = Substitute.For<IConventions>();`
`34`	`34`	`conventions.ExchangeNamingConvention = t => t.Name;`
`35`	`35`
`36`		`- var publishExchangeDeclareStrategy = new VersionedPublishExchangeDeclareStrategy(conventions, advancedBus);`
	`36`	`+ var exchangeDeclareStrategy = new VersionedExchangeDeclareStrategy(conventions, advancedBus);`
`37`	`37`	`try`
`38`	`38`	`{`
`39`		`- publishExchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);`
	`39`	`+ exchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);`
`40`	`40`	`}`
`41`	`41`	`catch (Exception)`
`42`	`42`	`{`
`43`	`43`	`}`
`44`	`44`
`45`		`- var declaredExchange = publishExchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);`
	`45`	`+ var declaredExchange = exchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);`
`46`	`46`	`advancedBus.Received(2).ExchangeDeclare(exchangeName, "topic");`
`47`	`47`	`declaredExchange.Should().BeSameAs(exchange);`
`48`	`48`	`exchangeDeclareCount.Should().Be(1);`
`@@ -76,7 +76,7 @@ public void When_declaring_exchanges_for_unversioned_message_one_exchange_create`
`76`	`76`	`var conventions = Substitute.For<IConventions>();`
`77`	`77`	`conventions.ExchangeNamingConvention = t => t.Name;`
`78`	`78`
`79`		`- var publishExchangeStrategy = new VersionedPublishExchangeDeclareStrategy(conventions, advancedBus);`
	`79`	`+ var publishExchangeStrategy = new VersionedExchangeDeclareStrategy(conventions, advancedBus);`
`80`	`80`
`81`	`81`	`publishExchangeStrategy.DeclareExchange(typeof(MyMessage), ExchangeType.Topic);`
`82`	`82`
`@@ -111,7 +111,7 @@ public void When_declaring_exchanges_for_versioned_message_exchange_per_version_`
`111`	`111`	`var conventions = Substitute.For<IConventions>();`
`112`	`112`	`conventions.ExchangeNamingConvention = t => t.Name;`
`113`	`113`
`114`		`- var publishExchangeStrategy = new VersionedPublishExchangeDeclareStrategy(conventions, advancedBus);`
	`114`	`+ var publishExchangeStrategy = new VersionedExchangeDeclareStrategy(conventions, advancedBus);`
`115`	`115`
`116`	`116`	`publishExchangeStrategy.DeclareExchange(typeof(MyMessageV2), ExchangeType.Topic);`
`117`	`117`
`@@ -128,4 +128,4 @@ private class ExchangeStub : IExchange`
`128`	`128`	`public ExchangeStub BoundTo { get; set; }`
`129`	`129`	`}`
`130`	`130`	`}`
`131`		`-}`
	`131`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@`
`7`	`7`
`8`	`8`	`namespace EasyNetQ.Tests.MultipleExchangeTest`
`9`	`9`	`{`
`10`		`- public class AdvancedPolymorphismPublishExchangeDeclareStrategyTests`
	`10`	`+ public class AdvancedPolymorphismExchangeDeclareStrategyTests`
`11`	`11`	`{`
`12`	`12`	`[Fact(Skip = "Needs to be updated to XUnit")]`
`13`	`13`	`public void When_declaring_exchanges_for_message_type_that_has_no_interface_one_exchange_created()`
`@@ -32,9 +32,9 @@ public void When_declaring_exchanges_for_message_type_that_has_no_interface_one_`
`32`	`32`	`var conventions = Substitute.For<IConventions>();`
`33`	`33`	`conventions.ExchangeNamingConvention = t => t.Name;`
`34`	`34`
`35`		`- var publishExchangeStrategy = new MultipleExchangePublishExchangeDeclareStrategy(conventions, advancedBus);`
	`35`	`+ var exchangeStrategy = new MultipleExchangeDeclareStrategy(conventions, advancedBus);`
`36`	`36`
`37`		`- publishExchangeStrategy.DeclareExchangeAsync(typeof(MyMessage), ExchangeType.Topic).Wait();`
	`37`	`+ exchangeStrategy.DeclareExchangeAsync(typeof(MyMessage), ExchangeType.Topic).Wait();`
`38`	`38`
`39`	`39`	`/*`
`40`	`40`	`//ensure that only one exchange is declared`
`@@ -145,4 +145,4 @@ public void When_declaring_exchanges_for_message_with_two_interfaces_exchange_pe`
`145`	`145`	`Arg<string>.Is.Anything), opt => opt.Repeat.Times(1));*/`
`146`	`146`	`}`
`147`	`147`	`}`
`148`		`-}`
	`148`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@`
`10`	`10`
`11`	`11`	`namespace EasyNetQ.Tests.ProducerTests`
`12`	`12`	`{`
`13`		`- public class PublishExchangeDeclareStrategyTests`
	`13`	`+ public class ExchangeDeclareStrategyTests`
`14`	`14`	`{`
`15`	`15`	`private const string exchangeName = "the_exchange";`
`16`	`16`
`@@ -27,9 +27,9 @@ public void Should_declare_exchange_the_first_time_declare_is_called()`
`27`	`27`	`return exchange;`
`28`	`28`	`});`
`29`	`29`
`30`		`- var publishExchangeDeclareStrategy = new PublishExchangeDeclareStrategy(Substitute.For<IConventions>(), advancedBus);`
	`30`	`+ var exchangeDeclareStrategy = new DefaultExchangeDeclareStrategy(Substitute.For<IConventions>(), advancedBus);`
`31`	`31`
`32`		`- var declaredExchange = publishExchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);`
	`32`	`+ var declaredExchange = exchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);`
`33`	`33`
`34`	`34`	`advancedBus.Received().ExchangeDeclare(exchangeName, "topic");`
`35`	`35`	`declaredExchange.Should().BeSameAs(exchange);`
`@@ -48,10 +48,10 @@ public void Should_not_declare_exchange_the_second_time_declare_is_called()`
`48`	`48`	`return exchange;`
`49`	`49`	`});`
`50`	`50`
`51`		`- var publishExchangeDeclareStrategy = new PublishExchangeDeclareStrategy(Substitute.For<IConventions>(), advancedBus);`
	`51`	`+ var exchangeDeclareStrategy = new DefaultExchangeDeclareStrategy(Substitute.For<IConventions>(), advancedBus);`
`52`	`52`
`53`		`- var _ = publishExchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);`
`54`		`- var declaredExchange = publishExchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);`
	`53`	`+ var _ = exchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);`
	`54`	`+ var declaredExchange = exchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);`
`55`	`55`
`56`	`56`	`advancedBus.Received().ExchangeDeclare(exchangeName, "topic");`
`57`	`57`	`declaredExchange.Should().BeSameAs(exchange);`
`@@ -74,20 +74,20 @@ public void Should_declare_exchange_again_if_first_attempt_failed()`
`74`	`74`	`return exchange;`
`75`	`75`	`});`
`76`	`76`
`77`		`- var publishExchangeDeclareStrategy = new VersionedPublishExchangeDeclareStrategy(Substitute.For<IConventions>(), advancedBus);`
	`77`	`+ var exchangeDeclareStrategy = new VersionedExchangeDeclareStrategy(Substitute.For<IConventions>(), advancedBus);`
`78`	`78`	`try`
`79`	`79`	`{`
`80`		`- publishExchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);`
	`80`	`+ exchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);`
`81`	`81`	`}`
`82`	`82`	`catch (Exception)`
`83`	`83`	`{`
`84`	`84`	`}`
`85`		`- var declaredExchange = publishExchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);`
	`85`	`+ var declaredExchange = exchangeDeclareStrategy.DeclareExchange(exchangeName, ExchangeType.Topic);`
`86`	`86`	`advancedBus.Received(2).ExchangeDeclare(exchangeName, "topic");`
`87`	`87`	`declaredExchange.Should().BeSameAs(exchange);`
`88`	`88`	`exchangeDeclareCount.Should().Be(1);`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`
`93`		`-// ReSharper restore InconsistentNaming`
	`93`	`+// ReSharper restore InconsistentNaming`
Original file line number	Diff line number	Diff line change
`@@ -8,8 +8,8 @@ public static class MessageVersioningExtensions`
`8`	`8`	`public static IServiceRegister EnableMessageVersioning( this IServiceRegister serviceRegister )`
`9`	`9`	`{`
`10`	`10`	`return serviceRegister`
`11`		`- .Register<IPublishExchangeDeclareStrategy, VersionedPublishExchangeDeclareStrategy>()`
	`11`	`+ .Register<IExchangeDeclareStrategy, VersionedExchangeDeclareStrategy>()`
`12`	`12`	`.Register<IMessageSerializationStrategy, VersionedMessageSerializationStrategy>();`
`13`	`13`	`}`
`14`	`14`	`}`
`15`		`-}`
	`15`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -7,14 +7,14 @@`
`7`	`7`
`8`	`8`	`namespace EasyNetQ.MessageVersioning`
`9`	`9`	`{`
`10`		`- public class VersionedPublishExchangeDeclareStrategy : IPublishExchangeDeclareStrategy`
	`10`	`+ public class VersionedExchangeDeclareStrategy : IExchangeDeclareStrategy`
`11`	`11`	`{`
`12`	`12`	`private readonly IAdvancedBus advancedBus;`
`13`	`13`	`private readonly AsyncLock asyncLock = new AsyncLock();`
`14`	`14`	`private readonly IConventions conventions;`
`15`	`15`	`private readonly ConcurrentDictionary<string, IExchange> exchanges = new ConcurrentDictionary<string, IExchange>();`
`16`	`16`
`17`		`- public VersionedPublishExchangeDeclareStrategy(IConventions conventions, IAdvancedBus advancedBus)`
	`17`	`+ public VersionedExchangeDeclareStrategy(IConventions conventions, IAdvancedBus advancedBus)`
`18`	`18`	`{`
`19`	`19`	`Preconditions.CheckNotNull(conventions, "conventions");`
`20`	`20`	`Preconditions.CheckNotNull(advancedBus, "advancedBus");`
`@@ -90,4 +90,4 @@ private IExchange DeclareVersionedExchanges(MessageVersionStack messageVersions,`
`90`	`90`	`return destinationExchange;`
`91`	`91`	`}`
`92`	`92`	`}`
`93`		`-}`
	`93`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -7,14 +7,14 @@`
`7`	`7`
`8`	`8`	`namespace EasyNetQ.MultipleExchange`
`9`	`9`	`{`
`10`		`- public class MultipleExchangePublishExchangeDeclareStrategy : IPublishExchangeDeclareStrategy`
	`10`	`+ public class MultipleExchangeDeclareStrategy : IExchangeDeclareStrategy`
`11`	`11`	`{`
`12`	`12`	`private readonly IAdvancedBus advancedBus;`
`13`	`13`	`private readonly AsyncLock asyncLock = new AsyncLock();`
`14`	`14`	`private readonly IConventions conventions;`
`15`	`15`	`private readonly ConcurrentDictionary<string, IExchange> exchanges = new ConcurrentDictionary<string, IExchange>();`
`16`	`16`
`17`		`- public MultipleExchangePublishExchangeDeclareStrategy(IConventions conventions, IAdvancedBus advancedBus)`
	`17`	`+ public MultipleExchangeDeclareStrategy(IConventions conventions, IAdvancedBus advancedBus)`
`18`	`18`	`{`
`19`	`19`	`Preconditions.CheckNotNull(conventions, "conventions");`
`20`	`20`	`Preconditions.CheckNotNull(advancedBus, "advancedBus");`
`@@ -81,4 +81,4 @@ public async Task<IExchange> DeclareExchangeAsync(string exchangeName, string ex`
`81`	`81`	`}`
`82`	`82`	`}`
`83`	`83`	`}`
`84`		`-}`
	`84`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -8,7 +8,7 @@ public static class MultipleExchangeExtension`
`8`	`8`	`public static IServiceRegister EnableAdvancedMessagePolymorphism(this IServiceRegister serviceRegister)`
`9`	`9`	`{`
`10`	`10`	`return serviceRegister`
`11`		`- .Register<IPublishExchangeDeclareStrategy, MultipleExchangePublishExchangeDeclareStrategy>();`
	`11`	`+ .Register<IExchangeDeclareStrategy, MultipleExchangeDeclareStrategy>();`
`12`	`12`	`}`
`13`	`13`	`}`
`14`	`14`	`}`