acceptance test

Author: timbussmann

src/ServiceBus.AcceptanceTests/SimpleTriggerFunctionComponent.cs

@@ -0,0 +1,87 @@
+namespace ServiceBus.Tests
+{
+    using System;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.Extensions.DependencyInjection;
+    using NServiceBus;
+    using NServiceBus.AcceptanceTesting;
+    using NServiceBus.AcceptanceTesting.Customization;
+    using NServiceBus.AcceptanceTesting.Support;
+    using NServiceBus.MessageMutator;
+    using Conventions = NServiceBus.AcceptanceTesting.Customization.Conventions;
+    using ExecutionContext = Microsoft.Azure.WebJobs.ExecutionContext;
+
+    abstract class SimpleTriggerFunctionComponent : IComponentBehavior
+    {
+        public Task<ComponentRunner> CreateRunner(RunDescriptor runDescriptor) =>
+            Task.FromResult<ComponentRunner>(
+                new FunctionRunner(
+                    CustomizeConfiguration,
+                    runDescriptor.ScenarioContext,
+                    GetType(),
+                    TriggerAction));
+
+        public abstract Task TriggerAction(IFunctionEndpoint endpoint, ExecutionContext executionContext);
+
+        public Action<ServiceBusTriggeredEndpointConfiguration> CustomizeConfiguration { private get; set; } = _ => { };
+
+        class FunctionRunner : ComponentRunner
+        {
+            public FunctionRunner(Action<ServiceBusTriggeredEndpointConfiguration> configurationCustomization,
+                ScenarioContext scenarioContext,
+                Type functionComponentType,
+                Func<IFunctionEndpoint, ExecutionContext, Task> triggerAction)
+            {
+                this.configurationCustomization = configurationCustomization;
+                this.scenarioContext = scenarioContext;
+                this.functionComponentType = functionComponentType;
+                this.triggerAction = triggerAction;
+
+                Name = Conventions.EndpointNamingConvention(functionComponentType);
+            }
+
+            public override string Name { get; }
+
+            public override Task Start(CancellationToken token)
+            {
+                var functionEndpointConfiguration = new ServiceBusTriggeredEndpointConfiguration(Name, default, null);
+                var endpointConfiguration = functionEndpointConfiguration.AdvancedConfiguration;
+
+                endpointConfiguration.TypesToIncludeInScan(functionComponentType.GetTypesScopedByTestClass());
+
+                endpointConfiguration.Recoverability()
+                    .Immediate(i => i.NumberOfRetries(0))
+                    .Delayed(d => d.NumberOfRetries(0));
+
+                configurationCustomization(functionEndpointConfiguration);
+                var serverless = functionEndpointConfiguration.MakeServerless();
+
+                endpointConfiguration.RegisterComponents(c => c.AddSingleton(scenarioContext.GetType(), scenarioContext));
+
+                endpointConfiguration.RegisterComponents(c => c.AddSingleton<IMutateOutgoingTransportMessages>(b => new TestIndependenceMutator(scenarioContext)));
+
+                var serviceCollection = new ServiceCollection();
+                var startableEndpointWithExternallyManagedContainer = EndpointWithExternallyManagedContainer.Create(endpointConfiguration, serviceCollection);
+                var serviceProvider = serviceCollection.BuildServiceProvider();
+
+                endpoint = new InProcessFunctionEndpoint(startableEndpointWithExternallyManagedContainer, serverless, serviceProvider);
+
+                return Task.CompletedTask;
+            }
+
+            public override async Task ComponentsStarted(CancellationToken cancellationToken)
+            {
+                await triggerAction(endpoint, new ExecutionContext());
+                await base.ComponentsStarted(cancellationToken);
+            }
+
+            IFunctionEndpoint endpoint;
+
+            readonly Action<ServiceBusTriggeredEndpointConfiguration> configurationCustomization;
+            readonly ScenarioContext scenarioContext;
+            readonly Type functionComponentType;
+            readonly Func<IFunctionEndpoint, ExecutionContext, Task> triggerAction;
+        }
+    }
+}

src/ServiceBus.AcceptanceTests/When_using_sendonly.cs

@@ -0,0 +1,67 @@
+namespace ServiceBus.Tests
+{
+    using System.Threading.Tasks;
+    using Microsoft.Azure.WebJobs;
+    using NServiceBus;
+    using NServiceBus.AcceptanceTesting;
+    using NServiceBus.AcceptanceTesting.Customization;
+    using NUnit.Framework;
+
+    public class When_using_sendonly
+    {
+        [Test]
+        public async Task Should_send_messages()
+        {
+            await Scenario.Define<Context>()
+                .WithEndpoint<ReceivingEndpoint>()
+                .WithComponent(new SendOnlyFunction())
+                .Done(c => c.HandlerReceivedMessage)
+                .Run();
+        }
+
+        class Context : ScenarioContext
+        {
+            public bool HandlerReceivedMessage { get; set; }
+        }
+
+        class ReceivingEndpoint : EndpointConfigurationBuilder
+        {
+            public ReceivingEndpoint() => EndpointSetup<DefaultEndpoint>();
+
+            public class TestMessageHandler : IHandleMessages<TestMessage>
+            {
+                readonly Context testContext;
+
+                public TestMessageHandler(Context testContext) => this.testContext = testContext;
+
+                public Task Handle(TestMessage message, IMessageHandlerContext context)
+                {
+                    testContext.HandlerReceivedMessage = true;
+                    return Task.CompletedTask;
+                }
+            }
+        }
+
+        class SendOnlyFunction : SimpleTriggerFunctionComponent
+        {
+            public SendOnlyFunction()
+            {
+                CustomizeConfiguration = configuration =>
+                {
+                    configuration.AdvancedConfiguration.SendOnly();
+
+                    configuration.Routing.RouteToEndpoint(typeof(TestMessage), typeof(ReceivingEndpoint));
+                };
+            }
+
+            public override Task TriggerAction(IFunctionEndpoint endpoint, ExecutionContext executionContext)
+            {
+                return endpoint.Send(new TestMessage(), executionContext);
+            }
+        }
+
+        class TestMessage : IMessage
+        {
+        }
+    }
+}