Allow outbox to be enabled for send only endpoints via an explicit opt-in setting

src/NServiceBus.AcceptanceTests/Core/Outbox/When_outbox_enabled_for_send_only.cs

@@ -0,0 +1,38 @@
+namespace NServiceBus.AcceptanceTests.Outbox
+{
+    using System.Threading.Tasks;
+    using AcceptanceTesting;
+    using EndpointTemplates;
+    using NUnit.Framework;
+
+    public class When_outbox_enabled_for_send_only : NServiceBusAcceptanceTest
+    {
+        [Test]
+        public async Task Should_fail_prerequisites_check()
+        {
+            string startupDiagnostics = null;
+            var context = await Scenario.Define<Context>()
+                .WithEndpoint<Endpoint>(e => e.CustomConfig(c => c.CustomDiagnosticsWriter((d, __) => { startupDiagnostics = d; return Task.CompletedTask; })))
+                .Done(c => c.EndpointsStarted)
+                .Run();
+
+            StringAssert.Contains("Outbox is only relevant for endpoints receiving messages.", startupDiagnostics);
+        }
+
+        public class Context : ScenarioContext
+        {
+        }
+
+        public class Endpoint : EndpointConfigurationBuilder
+        {
+            public Endpoint()
+            {
+                EndpointSetup<DefaultServer>(c =>
+                {
+                    c.EnableOutbox();
+                    c.SendOnly();
+                }).EnableStartupDiagnostics();
+            }
+        }
+    }
+}

src/NServiceBus.AcceptanceTests/Core/Outbox/When_outbox_enabled_with_transaction_mode_above_receive_only.cs

@@ -0,0 +1,37 @@
+namespace NServiceBus.AcceptanceTests.Outbox
+{
+    using System;
+    using AcceptanceTesting;
+    using EndpointTemplates;
+    using NUnit.Framework;
+
+    public class When_outbox_enabled_with_transaction_mode_above_receive_only : NServiceBusAcceptanceTest
+    {
+        [Test]
+        public void Should_fail_to_start()
+        {
+            var exception = Assert.ThrowsAsync<Exception>(async () => await Scenario.Define<Context>()
+                .WithEndpoint<Endpoint>()
+                .Done(_ => false)
+                .Run());
+
+            StringAssert.Contains($"Outbox requires transport to be running in `{nameof(TransportTransactionMode.ReceiveOnly)}` mode", exception.Message);
+        }
+
+        public class Context : ScenarioContext
+        {
+        }
+
+        public class Endpoint : EndpointConfigurationBuilder
+        {
+            public Endpoint()
+            {
+                EndpointSetup<DefaultServer>(c =>
+                {
+                    c.EnableOutbox();
+                    c.ConfigureTransport().TransportTransactionMode = TransportTransactionMode.SendsAtomicWithReceive;
+                });
+            }
+        }
+    }
+}

src/NServiceBus.AcceptanceTests/Core/Outbox/When_outbox_enabled_with_transactions_off.cs

@@ -0,0 +1,38 @@
+namespace NServiceBus.AcceptanceTests.Outbox
+{
+    using System.Threading.Tasks;
+    using AcceptanceTesting;
+    using EndpointTemplates;
+    using NUnit.Framework;
+
+    public class When_outbox_enabled_with_transactions_off : NServiceBusAcceptanceTest
+    {
+        [Test]
+        public async Task Should_fail_prerequisites_check()
+        {
+            string startupDiagnostics = null;
+            var context = await Scenario.Define<Context>()
+                .WithEndpoint<Endpoint>(e => e.CustomConfig(c => c.CustomDiagnosticsWriter((d, __) => { startupDiagnostics = d; return Task.CompletedTask; })))
+                .Done(c => c.EndpointsStarted)
+                .Run();
+
+            StringAssert.Contains("Outbox isn't needed since the receive transactions have been turned off", startupDiagnostics);
+        }
+
+        public class Context : ScenarioContext
+        {
+        }
+
+        public class Endpoint : EndpointConfigurationBuilder
+        {
+            public Endpoint()
+            {
+                EndpointSetup<DefaultServer>(c =>
+                {
+                    c.EnableOutbox();
+                    c.ConfigureTransport().TransportTransactionMode = TransportTransactionMode.None;
+                }).EnableStartupDiagnostics();
+            }
+        }
+    }
+}

src/NServiceBus.AcceptanceTests/Core/Outbox/When_outbox_enabled_without_persister_supporting_it.cs

@@ -0,0 +1,43 @@
+namespace NServiceBus.AcceptanceTests.Outbox
+{
+    using System;
+    using AcceptanceTesting;
+    using EndpointTemplates;
+    using NServiceBus.Persistence;
+    using NUnit.Framework;
+
+    public class When_outbox_enabled_without_persister_supporting_it : NServiceBusAcceptanceTest
+    {
+        [Test]
+        public void Should_fail_to_start()
+        {
+            var exception = Assert.ThrowsAsync<Exception>(async () => await Scenario.Define<Context>()
+                .WithEndpoint<Endpoint>()
+                .Done(_ => false)
+                .Run());
+
+            StringAssert.Contains("The selected persistence doesn't have support for outbox storage", exception.Message);
+        }
+
+        public class Context : ScenarioContext
+        {
+        }
+
+        public class Endpoint : EndpointConfigurationBuilder
+        {
+            public Endpoint()
+            {
+                EndpointSetup<ServerWithNoDefaultPersistenceDefinitions>(c =>
+                {
+                    c.EnableOutbox();
+                    c.ConfigureTransport().TransportTransactionMode = TransportTransactionMode.ReceiveOnly;
+                    c.UsePersistence<FakeNoOutboxSupportPersistence>();
+                });
+            }
+        }
+
+        class FakeNoOutboxSupportPersistence : PersistenceDefinition
+        {
+        }
+    }
+}

src/NServiceBus.AcceptanceTests/Core/Reliability/SynchronizedStorage/When_opening_storage_session_outside_pipeline.cs

@@ -8,27 +8,47 @@ namespace NServiceBus.AcceptanceTests.Reliability.SynchronizedStorage
     using Extensibility;
     using Features;
     using Microsoft.Extensions.DependencyInjection;
+    using NServiceBus.Configuration.AdvancedExtensibility;
+    using NServiceBus.Outbox;
     using NUnit.Framework;
     using Persistence;
 
     public class When_opening_storage_session_outside_pipeline : NServiceBusAcceptanceTest
     {
-        [Test]
-        public async Task Should_provide_adapted_session_with_same_scope()
+        [Test, Combinatorial]
+        public async Task Should_provide_adapted_session_with_same_scope([Values(true, false)] bool useOutbox, [Values(true, false)] bool sendOnly)
         {
             var context = await Scenario.Define<Context>()
-                .WithEndpoint<Endpoint>()
+                .WithEndpoint<Endpoint>(e => e.CustomConfig(c =>
+                {
+                    if (sendOnly)
+                    {
+                        c.SendOnly();
+                        c.GetSettings().Set("Outbox.AllowUseWithoutReceiving", true);
+                    }
+                    if (useOutbox)
+                    {
+                        c.ConfigureTransport().TransportTransactionMode = TransportTransactionMode.ReceiveOnly;
+                        c.EnableOutbox();
+                    }
+                }))
                 .Done(c => c.Done)
                 .Run();
 
             Assert.True(context.SessionNotNullAfterOpening, "The adapted session was null after opening the session.");
             Assert.True(context.StorageSessionEqual, "The scoped storage session should be equal.");
+
+            if (useOutbox)
+            {
+                Assert.True(context.OutboxNotNullAfterOpening, "The scoped storage session should be equal.");
+            }
         }
 
         public class Context : ScenarioContext
         {
             public bool StorageSessionEqual { get; set; }
             public bool SessionNotNullAfterOpening { get; set; }
+            public bool OutboxNotNullAfterOpening { get; set; }
             public bool Done { get; set; }
         }
 
@@ -75,6 +95,8 @@ protected override async Task OnStart(IMessageSession session, CancellationToken
                             scenarioContext.StorageSessionEqual =
                                 completableSynchronizedStorageSession == synchronizedStorage;
 
+                            scenarioContext.OutboxNotNullAfterOpening = scope.ServiceProvider.GetService<IOutboxStorage>() != null;
+
                             await completableSynchronizedStorageSession.CompleteAsync(cancellationToken);
                         }
 
@@ -89,4 +111,4 @@ protected override async Task OnStart(IMessageSession session, CancellationToken
             }
         }
     }
-}
+}

src/NServiceBus.AcceptanceTests/NServiceBus.AcceptanceTests.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFrameworks>net472;net6.0;net7.0</TargetFrameworks>

src/NServiceBus.Core/Reliability/Outbox/Outbox.cs

@@ -1,7 +1,8 @@
 namespace NServiceBus.Features
 {
-    using ConsistencyGuarantees;
     using System;
+    using ConsistencyGuarantees;
+    using NServiceBus.Settings;
     using Transport;
 
     /// <summary>
@@ -14,19 +15,24 @@ internal Outbox()
             Defaults(s =>
             {
                 s.SetDefault(TimeToKeepDeduplicationEntries, TimeSpan.FromDays(5));
-
                 s.EnableFeatureByDefault<SynchronizedStorage>();
             });
-            Prerequisite(context => !context.Settings.GetOrDefault<bool>("Endpoint.SendOnly"),
+
+            Prerequisite(context => ReceivingEnabled(context.Settings) || AllowUseWithoutReceiving(context.Settings),
                 "Outbox is only relevant for endpoints receiving messages.");
 
-            Prerequisite(c => !c.Settings.GetOrDefault<bool>("Endpoint.SendOnly")
-                && c.Settings.GetRequiredTransactionModeForReceives() != TransportTransactionMode.None,
+            Prerequisite(context => !ReceivingEnabled(context.Settings) || TransactionsEnabled(context.Settings),
                 "Outbox isn't needed since the receive transactions have been turned off");
 
             DependsOn<SynchronizedStorage>();
         }
 
+        bool ReceivingEnabled(IReadOnlySettings settings) => !settings.GetOrDefault<bool>("Endpoint.SendOnly");
+
+        bool TransactionsEnabled(IReadOnlySettings settings) => settings.GetRequiredTransactionModeForReceives() != TransportTransactionMode.None;
+
+        bool AllowUseWithoutReceiving(IReadOnlySettings settings) => settings.GetOrDefault<bool>("Outbox.AllowUseWithoutReceiving");
+
         /// <summary>
         /// See <see cref="Feature.Setup" />.
         /// </summary>
@@ -37,6 +43,11 @@ protected internal override void Setup(FeatureConfigurationContext context)
                 throw new Exception("The selected persistence doesn't have support for outbox storage. Select another persistence or disable the outbox feature using endpointConfiguration.DisableFeature<Outbox>()");
             }
 
+            if (!ReceivingEnabled(context.Settings))
+            {
+                return;
+            }
+
             // ForceBatchDispatchToBeIsolatedBehavior set the dispatch consistency to isolated which instructs
             // the transport to not enlist the outgoing operation in the incoming message transaction. Unfortunately
             // this is not enough. We cannot allow the transport to operate in SendsWithAtomicReceive because a transport
@@ -54,6 +65,7 @@ protected internal override void Setup(FeatureConfigurationContext context)
             //note: in the future we should change the persister api to give us a "outbox factory" so that we can register it in DI here instead of relying on the persister to do it
             context.Pipeline.Register("ForceBatchDispatchToBeIsolated", new ForceBatchDispatchToBeIsolatedBehavior(), "Makes sure that we dispatch straight to the transport so that we can safely set the outbox record to dispatched once the dispatch pipeline returns.");
         }
+
         internal const string TimeToKeepDeduplicationEntries = "Outbox.TimeToKeepDeduplicationEntries";
     }
 }

src/NServiceBus.Learning.AcceptanceTests/NServiceBus.Learning.AcceptanceTests.csproj

@@ -22,7 +22,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <Compile Include="../NServiceBus.AcceptanceTests/**/*.cs" Exclude="../NServiceBus.AcceptanceTests/obj/**/*.*" />
+    <Compile Include="../NServiceBus.AcceptanceTests/**/*.cs" Exclude="../NServiceBus.AcceptanceTests/obj/**/*.*;../NServiceBus.AcceptanceTests/Core/**/*.cs" />
     <Compile Remove="../NServiceBus.AcceptanceTests/Core/TestSuiteConstraints.cs" />
   </ItemGroup>