Merge pull request #148 from Particular/release-1.3.0

Release 1.3.0

packaging/nuget/nservicebus.persistence.azurestorage.nuspec

@@ -16,7 +16,7 @@
     <dependencies>
       <dependency id="WindowsAzure.Storage" version="[8.0.0, 9.0.0)" />
       <dependency id="NServiceBus" version="[6.0.0, 7.0.0)" />
-      <dependency id="Newtonsoft.Json" version="[9.0.0, 10.0.0)" />
+      <dependency id="Newtonsoft.Json" version="[10.0.0, 11.0.0)" />
     </dependencies>
   </metadata>
   <files>

src/NServiceBus.Persistence.AzureStorage.AcceptanceTests/App_Packages/NSB.AcceptanceTests.6.3.2/ConfigureEndpointInMemoryPersistence.cs

@@ -0,0 +1,18 @@
+using System.Threading.Tasks;
+using NServiceBus;
+using NServiceBus.AcceptanceTesting.Support;
+
+public class ConfigureEndpointInMemoryPersistence : IConfigureEndpointTestExecution
+{
+    public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
+    {
+        configuration.UsePersistence<InMemoryPersistence>();
+        return Task.FromResult(0);
+    }
+
+    public Task Cleanup()
+    {
+        // Nothing required for in-memory persistence
+        return Task.FromResult(0);
+    }
+}

src/NServiceBus.Persistence.AzureStorage.AcceptanceTests/App_Packages/NSB.AcceptanceTests.6.3.2/ConfigureEndpointLearningPersistence.cs

@@ -0,0 +1,34 @@
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using NServiceBus;
+using NServiceBus.AcceptanceTesting.Support;
+using NServiceBus.Persistence;
+
+public class ConfigureEndpointLearningPersistence : IConfigureEndpointTestExecution
+{
+    public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
+    {
+        //can't use bindir since that will be to long on the build agents
+        storageDir = Path.Combine(@"c:\temp", Guid.NewGuid().ToString("N"));
+
+        configuration.UsePersistence<InMemoryPersistence, StorageType.Subscriptions>();
+        configuration.UsePersistence<InMemoryPersistence, StorageType.Timeouts>();
+
+        configuration.UsePersistence<LearningPersistence, StorageType.Sagas>()
+            .SagaStorageDirectory(storageDir);
+
+        return Task.FromResult(0);
+    }
+
+    public Task Cleanup()
+    {
+        if (Directory.Exists(storageDir))
+        {
+            Directory.Delete(storageDir, true);
+        }
+        return Task.FromResult(0);
+    }
+
+    string storageDir;
+}

src/NServiceBus.Persistence.AzureStorage.AcceptanceTests/App_Packages/NSB.AcceptanceTests.6.3.2/ConfigureEndpointLearningTransport.cs

@@ -0,0 +1,33 @@
+using System.IO;
+using System.Threading.Tasks;
+using NServiceBus;
+using NServiceBus.AcceptanceTesting.Support;
+using NServiceBus.Transport;
+
+public class ConfigureEndpointLearningTransport : IConfigureEndpointTestExecution
+{
+    public Task Cleanup()
+    {
+        if (Directory.Exists(storageDir))
+        {
+            Directory.Delete(storageDir, true);
+        }
+
+        return Task.FromResult(0);
+    }
+
+    public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
+    {
+        storageDir = Path.Combine(@"c:\temp", "att_tests"); //can't use bindir since that will be to long on the build agents
+
+        //we want the tests to be exposed to concurrency
+        configuration.LimitMessageProcessingConcurrencyTo(PushRuntimeSettings.Default.MaxConcurrency);
+
+        configuration.UseTransport<LearningTransport>()
+            .StorageDirectory(storageDir);
+
+        return Task.FromResult(0);
+    }
+
+    string storageDir;
+}

src/NServiceBus.Persistence.AzureStorage.AcceptanceTests/Infrastructure/EndpointTemplates/ConfigureEndpointMsmqTransport.cs → src/NServiceBus.Persistence.AzureStorage.AcceptanceTests/App_Packages/NSB.AcceptanceTests.6.3.2/ConfigureEndpointMsmqTransport.cs

@@ -9,20 +9,16 @@
 using NServiceBus.Configuration.AdvanceExtensibility;
 using NServiceBus.Transport;
 
-public class ConfigureScenariosForMsmqTransport : IConfigureSupportedScenariosForTestExecution
-{
-    public IEnumerable<Type> UnsupportedScenarioDescriptorTypes { get; } = new[]
-    {
-        typeof(AllTransportsWithCentralizedPubSubSupport)
-    };
-}
-
 public class ConfigureEndpointMsmqTransport : IConfigureEndpointTestExecution
 {
+    const string DefaultConnectionString = "cacheSendConnection=false;journal=false;";
+
     public Task Configure(string endpointName, EndpointConfiguration configuration, RunSettings settings, PublisherMetadata publisherMetadata)
     {
         queueBindings = configuration.GetSettings().Get<QueueBindings>();
-        var connectionString = settings.Get<string>("Transport.ConnectionString");
+        var connectionString =
+            EnvironmentHelper.GetEnvironmentVariable($"{nameof(MsmqTransport)}.ConnectionString")
+            ?? DefaultConnectionString;
         var transportConfig = configuration.UseTransport<MsmqTransport>();
 
         transportConfig.ConnectionString(connectionString);

src/NServiceBus.Persistence.AzureStorage.AcceptanceTests/App_Packages/NSB.AcceptanceTests.6.3.2/ConventionEnforcementTests.cs

@@ -0,0 +1,59 @@
+namespace NServiceBus.AcceptanceTests
+{
+    using System;
+    using System.Linq;
+    using System.Reflection;
+    using NUnit.Framework;
+
+    [TestFixture]
+    public class ConventionEnforcementTests : NServiceBusAcceptanceTest
+    {
+        [Test]
+        public void Ensure_all_tests_derive_from_a_common_base_class()
+        {
+            var testTypes = Assembly.GetExecutingAssembly().GetTypes()
+                .Where(HasTestMethod);
+
+            var missingBaseClass = testTypes
+                .Where(t => t.BaseType == null || !typeof(NServiceBusAcceptanceTest).IsAssignableFrom(t))
+                .ToList();
+
+            CollectionAssert.IsEmpty(missingBaseClass, string.Join(",", missingBaseClass));
+        }
+
+        [Test]
+        public void Ensure_all_messages_are_public()
+        {
+            var testTypes = Assembly.GetExecutingAssembly().GetTypes();
+
+            var missingBaseClass = testTypes
+                .Where(t => !t.IsPublic && !t.IsNestedPublic)
+                .Where(t =>
+                        typeof(ICommand).IsAssignableFrom(t) ||
+                        typeof(IMessage).IsAssignableFrom(t) ||
+                        typeof(IEvent).IsAssignableFrom(t)
+                )
+                .ToList();
+
+            CollectionAssert.IsEmpty(missingBaseClass, string.Join(",", missingBaseClass));
+        }
+
+        [Test]
+        public void Ensure_all_sagadatas_are_public()
+        {
+            var testTypes = Assembly.GetExecutingAssembly().GetTypes();
+
+            var sagaDatas = testTypes
+                .Where(t => !t.IsPublic && !t.IsNestedPublic)
+                .Where(t => typeof(IContainSagaData).IsAssignableFrom(t))
+                .ToList();
+
+            CollectionAssert.IsEmpty(sagaDatas, string.Join(",", sagaDatas));
+        }
+
+        static bool HasTestMethod(Type t)
+        {
+            return t.GetMethods().Any(m => m.GetCustomAttributes<TestAttribute>().Any());
+        }
+    }
+}

src/NServiceBus.Persistence.AzureStorage.AcceptanceTests/App_Packages/NSB.AcceptanceTests.6.3.2/DelayedDelivery/When_Deferring_a_message.cs

@@ -0,0 +1,66 @@
+namespace NServiceBus.AcceptanceTests.DelayedDelivery
+{
+    using System;
+    using System.Threading.Tasks;
+    using AcceptanceTesting;
+    using EndpointTemplates;
+    using Features;
+    using NUnit.Framework;
+
+    public class When_deferring_a_message : NServiceBusAcceptanceTest
+    {
+        [Test]
+        public async Task Should_delay_delivery()
+        {
+            var delay = TimeSpan.FromSeconds(2);
+
+            var context = await Scenario.Define<Context>()
+                .WithEndpoint<Endpoint>(b => b.When((session, c) =>
+                {
+                    var options = new SendOptions();
+
+                    options.DelayDeliveryWith(delay);
+                    options.RouteToThisEndpoint();
+
+                    c.SentAt = DateTime.UtcNow;
+
+                    return session.Send(new MyMessage(), options);
+                }))
+                .Done(c => c.WasCalled)
+                .Run();
+
+            Assert.GreaterOrEqual(context.ReceivedAt - context.SentAt, delay);
+        }
+
+        public class Context : ScenarioContext
+        {
+            public bool WasCalled { get; set; }
+            public DateTime SentAt { get; set; }
+            public DateTime ReceivedAt { get; set; }
+        }
+
+        public class Endpoint : EndpointConfigurationBuilder
+        {
+            public Endpoint()
+            {
+                EndpointSetup<DefaultServer>(config => config.EnableFeature<TimeoutManager>());
+            }
+
+            public class MyMessageHandler : IHandleMessages<MyMessage>
+            {
+                public Context Context { get; set; }
+
+                public Task Handle(MyMessage message, IMessageHandlerContext context)
+                {
+                    Context.ReceivedAt = DateTime.UtcNow;
+                    Context.WasCalled = true;
+                    return Task.FromResult(0);
+                }
+            }
+        }
+
+        public class MyMessage : IMessage
+        {
+        }
+    }
+}

src/NServiceBus.Persistence.AzureStorage.AcceptanceTests/App_Packages/NSB.AcceptanceTests.6.3.2/DelayedDelivery/When_deferring_a_message_to_the_past.cs

@@ -0,0 +1,59 @@
+namespace NServiceBus.AcceptanceTests.DelayedDelivery
+{
+    using System;
+    using System.Threading.Tasks;
+    using AcceptanceTesting;
+    using EndpointTemplates;
+    using Features;
+    using NUnit.Framework;
+
+    public class When_deferring_a_message_to_the_past : NServiceBusAcceptanceTest
+    {
+        [Test]
+        public async Task Should_deliver_message()
+        {
+            var context = await Scenario.Define<Context>()
+                .WithEndpoint<Endpoint>(b => b.When((bus, c) =>
+                {
+                    var options = new SendOptions();
+
+                    options.DoNotDeliverBefore(DateTime.Now.AddHours(-1));
+                    options.RouteToThisEndpoint();
+
+                    return bus.Send(new MyMessage(), options);
+                }))
+                .Done(c => c.MessageReceived)
+                .Run();
+
+            Assert.IsTrue(context.MessageReceived);
+        }
+
+        public class Context : ScenarioContext
+        {
+            public bool MessageReceived { get; set; }
+        }
+
+        public class Endpoint : EndpointConfigurationBuilder
+        {
+            public Endpoint()
+            {
+                EndpointSetup<DefaultServer>(config => config.EnableFeature<TimeoutManager>());
+            }
+
+            public class MyMessageHandler : IHandleMessages<MyMessage>
+            {
+                public Context Context { get; set; }
+
+                public Task Handle(MyMessage message, IMessageHandlerContext context)
+                {
+                    Context.MessageReceived = true;
+                    return Task.FromResult(0);
+                }
+            }
+        }
+
+        public class MyMessage : IMessage
+        {
+        }
+    }
+}

src/NServiceBus.Persistence.AzureStorage.AcceptanceTests/App_Packages/NSB.AcceptanceTests.6.3.2/DelayedDelivery/When_deferring_to_non_local.cs

@@ -0,0 +1,79 @@
+namespace NServiceBus.AcceptanceTests.DelayedDelivery
+{
+    using System;
+    using System.Threading.Tasks;
+    using AcceptanceTesting;
+    using AcceptanceTesting.Customization;
+    using EndpointTemplates;
+    using Features;
+    using NUnit.Framework;
+
+    public class When_deferring_to_non_local : NServiceBusAcceptanceTest
+    {
+        [Test]
+        public async Task Message_should_be_received()
+        {
+            var delay = TimeSpan.FromSeconds(2);
+
+            var context = await Scenario.Define<Context>()
+                .WithEndpoint<Endpoint>(b => b.When((session, c) =>
+                {
+                    var options = new SendOptions();
+
+                    options.DelayDeliveryWith(delay);
+
+                    c.SentAt = DateTime.UtcNow;
+
+                    return session.Send(new MyMessage(), options);
+                }))
+                .WithEndpoint<Receiver>()
+                .Done(c => c.WasCalled)
+                .Run();
+
+            Assert.GreaterOrEqual(context.ReceivedAt - context.SentAt, delay);
+        }
+
+        public class Context : ScenarioContext
+        {
+            public bool WasCalled { get; set; }
+            public DateTime SentAt { get; set; }
+            public DateTime ReceivedAt { get; set; }
+        }
+
+        public class Endpoint : EndpointConfigurationBuilder
+        {
+            public Endpoint()
+            {
+                EndpointSetup<DefaultServer>(config =>
+                {
+                    config.EnableFeature<TimeoutManager>();
+                    config.ConfigureTransport().Routing().RouteToEndpoint(typeof(MyMessage), typeof(Receiver));
+                });
+            }
+        }
+
+        public class Receiver : EndpointConfigurationBuilder
+        {
+            public Receiver()
+            {
+                EndpointSetup<DefaultServer>();
+            }
+
+            public class MyMessageHandler : IHandleMessages<MyMessage>
+            {
+                public Context Context { get; set; }
+
+                public Task Handle(MyMessage message, IMessageHandlerContext context)
+                {
+                    Context.ReceivedAt = DateTime.UtcNow;
+                    Context.WasCalled = true;
+                    return Task.FromResult(0);
+                }
+            }
+        }
+
+        public class MyMessage : ICommand
+        {
+        }
+    }
+}