Merge branch 'hotfix-2.1.3'

packaging/nuget/NServiceBus.RabbitMQ.nuspec

@@ -12,11 +12,11 @@
     <requireLicenseAcceptance>true</requireLicenseAcceptance>
     <description>RabbitMQ support for NServicebus</description>
     <releaseNotes></releaseNotes>
-    <copyright>Copyright 2010-2014 NServiceBus. All rights reserved</copyright>
+    <copyright>Copyright 2010-2015 NServiceBus. All rights reserved</copyright>
     <tags>nservicebus servicebus msmq cqrs publish subscribe</tags>
     <dependencies>
       <dependency id="NServiceBus" version="[5.0.0, 6.0.0)" />
-      <dependency id="RabbitMQ.Client" version="[3.4.3]" />
+      <dependency id="RabbitMQ.Client" version="[3.5.0, 3.6.0)" />
     </dependencies>
   </metadata>
   <files>

src/NServiceBus.RabbitMQ.AcceptanceTests/App_Packages/NSB.AcceptanceTests.5.2.0/Audit/When_ForwardReceivedMessagesTo_is_set.cs

@@ -0,0 +1,72 @@
+namespace NServiceBus.AcceptanceTests.Audit
+{
+    using System;
+    using EndpointTemplates;
+    using AcceptanceTesting;
+    using NServiceBus.Config;
+    using NUnit.Framework;
+
+    public class When_ForwardReceivedMessagesTo_is_set : NServiceBusAcceptanceTest
+    {
+            [Test]
+            public void Should_forward_message()
+            {
+                var context = new Context();
+
+                Scenario.Define(context)
+                    .WithEndpoint<EndpointThatForwards>(b => b.Given((bus, c) =>
+                    {
+                        bus.SendLocal(new MessageToForward());
+                    }))
+                    .WithEndpoint<ForwardReceiver>()
+                    .Done(c => c.GotForwardedMessage)
+                    .Run();
+
+                Assert.IsTrue(context.GotForwardedMessage);
+            }
+
+            public class Context : ScenarioContext
+            {
+                public bool GotForwardedMessage { get; set; }
+            }
+
+            public class ForwardReceiver : EndpointConfigurationBuilder
+            {
+                public ForwardReceiver()
+                {
+                    EndpointSetup<DefaultServer>(c => c.EndpointName("forward_receiver"));
+                }
+
+                public class MessageToForwardHandler : IHandleMessages<MessageToForward>
+                {
+                    public Context Context { get; set; }
+
+                    public void Handle(MessageToForward message)
+                    {
+                        Context.GotForwardedMessage = true;
+                    }
+                }
+            }
+
+            public class EndpointThatForwards : EndpointConfigurationBuilder
+            {
+                public EndpointThatForwards()
+                {
+                    EndpointSetup<DefaultServer>()
+                        .WithConfig<UnicastBusConfig>(c => c.ForwardReceivedMessagesTo = "forward_receiver");
+                }
+
+                public class MessageToForwardHandler : IHandleMessages<MessageToForward>
+                {
+                    public void Handle(MessageToForward message)
+                    {
+                    }
+                }
+            }
+
+            [Serializable]
+            public class MessageToForward : IMessage
+            {
+            }
+        }
+    }

src/NServiceBus.RabbitMQ.AcceptanceTests/App_Packages/NSB.AcceptanceTests.5.2.0/Basic/When_callback_from_a_send_only.cs

@@ -0,0 +1,52 @@
+namespace NServiceBus.AcceptanceTests.Basic
+{
+    using System;
+    using NServiceBus.AcceptanceTesting;
+    using NServiceBus.AcceptanceTests.EndpointTemplates;
+    using NUnit.Framework;
+
+    public class When_callback_from_a_send_only : NServiceBusAcceptanceTest
+    {
+        [Test]
+        public void Should_throw()
+        {
+            Scenario.Define<Context>()
+                .WithEndpoint<SendOnlyEndpoint>(b => b.Given((bus, c) =>
+                {
+                    var exception = Assert.Throws<Exception>(() => bus.Send(new MyMessage()).Register(result => { }));
+                    Assert.AreEqual("Callbacks are invalid in a sendonly endpoint.", exception.Message);
+
+                }))
+                .WithEndpoint<Receiver>()
+                .Run();
+        }
+
+        public class Context : ScenarioContext
+        {
+        }
+
+        public class SendOnlyEndpoint : EndpointConfigurationBuilder
+        {
+            public SendOnlyEndpoint()
+            {
+                EndpointSetup<DefaultServer>()
+                    .SendOnly()
+                    .AddMapping<MyMessage>(typeof(Receiver));
+            }
+
+        }
+        public class Receiver : EndpointConfigurationBuilder
+        {
+            public Receiver()
+            {
+                EndpointSetup<DefaultServer>();
+            }
+        }
+
+        [Serializable]
+        public class MyMessage : ICommand
+        {
+        }
+
+    }
+}

src/NServiceBus.RabbitMQ.AcceptanceTests/App_Packages/NSB.AcceptanceTests.5.2.0/Basic/When_injecting_handler_props.cs

@@ -0,0 +1,67 @@
+namespace NServiceBus.AcceptanceTests.Basic
+{
+    using System;
+    using NServiceBus.AcceptanceTesting;
+    using NServiceBus.AcceptanceTests.EndpointTemplates;
+    using NUnit.Framework;
+
+    public class When_injecting_handler_props : NServiceBusAcceptanceTest
+    {
+        [Test]
+        public void Run()
+        {
+            var context = new Context();
+
+            Scenario.Define(context)
+                    .WithEndpoint<Receiver>(c=>c.When(b=>b.SendLocal(new MyMessage())))
+                    .Done(c => c.WasCalled)
+                    .Run();
+
+            Assert.AreEqual(10, context.Number);
+            Assert.AreEqual("Foo", context.Name);
+        }
+
+        public class Context : ScenarioContext
+        {
+            public bool WasCalled { get; set; }
+            public string Name { get; set; }
+            public int Number { get; set; }
+        }
+
+        public class Receiver : EndpointConfigurationBuilder
+        {
+            public Receiver()
+            {
+                EndpointSetup<DefaultServer>(c =>
+                {
+                    c.InitializeHandlerProperty<MyMessageHandler>("Number", 10);
+                    c.InitializeHandlerProperty<MyMessageHandler>("Name", "Foo");
+                });
+
+            }
+
+            public class MyMessageHandler : IHandleMessages<MyMessage>
+            {
+                public Context Context { get; set; }
+
+                public IBus Bus { get; set; }
+
+                public string Name { get; set; }
+
+                public int Number { get; set; }
+
+                public void Handle(MyMessage message)
+                {
+                    Context.Number = Number;
+                    Context.Name = Name;
+                    Context.WasCalled = true;
+                }
+            }
+        }
+
+        [Serializable]
+        public class MyMessage : ICommand
+        {
+        }
+    }
+}

src/NServiceBus.RabbitMQ.AcceptanceTests/App_Packages/NSB.AcceptanceTests.5.1.3/Basic/When_registering_custom_serializer.cs → src/NServiceBus.RabbitMQ.AcceptanceTests/App_Packages/NSB.AcceptanceTests.5.2.0/Basic/When_registering_custom_serializer.cs

@@ -3,6 +3,7 @@
     using System;
     using System.Collections.Generic;
     using System.IO;
+    using System.Runtime.Serialization.Formatters.Binary;
     using NServiceBus.AcceptanceTesting;
     using NServiceBus.AcceptanceTests.EndpointTemplates;
     using NServiceBus.Features;
@@ -114,24 +115,27 @@ protected override void Setup(FeatureConfigurationContext context)
 
         class MyCustomSerializer : IMessageSerializer
         {
-            object lastMessage;
-
             public Context Context { get; set; }
 
             public void Serialize(object message, Stream stream)
             {
+                var serializer = new BinaryFormatter();
+                serializer.Serialize(stream, message);
+
                 Context.SerializeCalled = true;
-                stream.WriteByte(1); //Need this because we internally we check to see if body is 0
-                lastMessage = message;
             }
 
             public object[] Deserialize(Stream stream, IList<Type> messageTypes = null)
             {
+                var serializer = new BinaryFormatter();
+
                 Context.DeserializeCalled = true;
+                stream.Position = 0;
+                var msg = serializer.Deserialize(stream);
 
                 return new[]
                 {
-                    lastMessage
+                    msg
                 };
             }
 

src/NServiceBus.RabbitMQ.AcceptanceTests/App_Packages/NSB.AcceptanceTests.5.1.3/Basic/When_sending_to_another_endpoint.cs → src/NServiceBus.RabbitMQ.AcceptanceTests/App_Packages/NSB.AcceptanceTests.5.2.0/Basic/When_sending_to_another_endpoint.cs

@@ -4,35 +4,37 @@
     using System.Collections.Generic;
     using NServiceBus.AcceptanceTesting;
     using NServiceBus.AcceptanceTests.EndpointTemplates;
-    using NServiceBus.AcceptanceTests.ScenarioDescriptors;
     using NUnit.Framework;
 
     public class When_sending_to_another_endpoint : NServiceBusAcceptanceTest
     {
         [Test]
         public void Should_receive_the_message()
         {
-            Scenario.Define(() => new Context { Id = Guid.NewGuid() })
-                    .WithEndpoint<Sender>(b => b.Given((bus, context) =>
+            var context = new Context
+            {
+                Id = Guid.NewGuid()
+            };
+
+            Scenario.Define(context)
+                    .WithEndpoint<Sender>(b => b.Given((bus, c) =>
                     {
                         bus.OutgoingHeaders["MyStaticHeader"] = "StaticHeaderValue";
                         bus.Send<MyMessage>(m=>
                         {
-                            m.Id = context.Id;
+                            m.Id = c.Id;
                             bus.SetMessageHeader(m, "MyHeader", "MyHeaderValue");
                         });
                     }))
                     .WithEndpoint<Receiver>()
                     .Done(c => c.WasCalled)
-                    .Repeat(r =>r.For(Serializers.Binary))
-                    .Should(c =>
-                        {
-                            Assert.True(c.WasCalled, "The message handler should be called");
-                            Assert.AreEqual(1, c.TimesCalled, "The message handler should only be invoked once");
-                            Assert.AreEqual("StaticHeaderValue",c.ReceivedHeaders["MyStaticHeader"], "Static headers should be attached to outgoing messages");
-                            Assert.AreEqual("MyHeaderValue", c.MyHeader, "Static headers should be attached to outgoing messages");
-                        })
                     .Run();
+
+            Assert.True(context.WasCalled, "The message handler should be called");
+            Assert.AreEqual(1, context.TimesCalled, "The message handler should only be invoked once");
+            Assert.AreEqual("StaticHeaderValue", context.ReceivedHeaders["MyStaticHeader"], "Static headers should be attached to outgoing messages");
+            Assert.AreEqual("MyHeaderValue", context.MyHeader, "Static headers should be attached to outgoing messages");
+
         }
 
         public class Context : ScenarioContext
@@ -63,33 +65,32 @@ public Receiver()
             {
                 EndpointSetup<DefaultServer>();
             }
-        }
-
-        [Serializable]
-        public class MyMessage : ICommand
-        {
-            public Guid Id { get; set; }
-        }
 
-        public class MyMessageHandler : IHandleMessages<MyMessage>
-        {
-            public Context Context { get; set; }
+            public class MyMessageHandler : IHandleMessages<MyMessage>
+            {
+                public Context Context { get; set; }
 
-            public IBus Bus { get; set; }
+                public IBus Bus { get; set; }
 
-            public void Handle(MyMessage message)
-            {
-                if (Context.Id != message.Id)
-                    return;
+                public void Handle(MyMessage message)
+                {
+                    if (Context.Id != message.Id)
+                        return;
 
-                Context.TimesCalled++;
+                    Context.TimesCalled++;
 
-                Context.MyHeader = Bus.GetMessageHeader(message, "MyHeader");
+                    Context.MyHeader = Bus.GetMessageHeader(message, "MyHeader");
 
-                Context.ReceivedHeaders = Bus.CurrentMessageContext.Headers;
+                    Context.ReceivedHeaders = Bus.CurrentMessageContext.Headers;
 
-                Context.WasCalled = true;
+                    Context.WasCalled = true;
+                }
             }
         }
+
+        public class MyMessage : IMessage
+        {
+            public Guid Id { get; set; }
+        }
     }
 }

src/NServiceBus.RabbitMQ.AcceptanceTests/App_Packages/NSB.AcceptanceTests.5.1.3/Basic/When_using_callbacks_with_messageid_eq_cid_.cs → src/NServiceBus.RabbitMQ.AcceptanceTests/App_Packages/NSB.AcceptanceTests.5.2.0/Basic/When_using_callbacks_with_messageid_eq_cid_.cs

@@ -55,7 +55,7 @@ class BodyMutator : IMutateOutgoingTransportMessages, INeedInitialization
         {
             public void MutateOutgoing(LogicalMessage logicalMessage, TransportMessage transportMessage)
             {
-                //to simulate native interop cases where msgid == corrid
+                //to simulate native interop cases where MessageId == CorrelationId
                 transportMessage.Headers[Headers.MessageId] = transportMessage.Headers[Headers.CorrelationId];
             }
 

src/NServiceBus.RabbitMQ.AcceptanceTests/App_Packages/NSB.AcceptanceTests.5.2.0/DeterministicGuid.cs

@@ -0,0 +1,21 @@
+namespace NServiceBus.Utils
+{
+    using System;
+    using System.Security.Cryptography;
+    using System.Text;
+
+    static class DeterministicGuid
+    {
+        public static Guid Create(params object[] data)
+        {
+            // use MD5 hash to get a 16-byte hash of the string
+            using (var provider = new MD5CryptoServiceProvider())
+            {
+                var inputBytes = Encoding.Default.GetBytes(String.Concat(data));
+                var hashBytes = provider.ComputeHash(inputBytes);
+                // generate a guid from the hash:
+                return new Guid(hashBytes);
+            }
+        } 
+    }
+}