GH-3883: the Marten integration no longer clobbers an explicit transport schema

IntegrateWithWolverine() registers MartenIntegration as an IWolverineExtension,
so its Configure() runs at host build — after an inline
UsePostgresqlPersistenceAndTransport(..., transportSchema: ...) in the same
options lambda. It then assigned its OWN schema names onto the shared
PostgreSQL transport unconditionally, so the integration's defaults silently
overwrote whatever the caller had asked for.

The failure is silent and lands on the data plane rather than at startup. A
host without Marten honours the configured schema and publishes to
{configured}.wolverine_queue_x; a Marten-backed consumer listens on
wolverine_queues.wolverine_queue_x. Auto-provision creates both tables happily,
no error is logged on either side, and nothing is ever delivered — the
publisher's rows just accumulate in a table nobody polls. Found from a user's
minimal reproduction where the only visible symptom was the same queue table
existing in two schemas.

TransportSchemaName now records whether it was explicitly assigned and is
stamped onto the transport only then; MessageStorageSchemaName is stamped only
when non-empty rather than falling back to public. Both cases that work today
are unchanged: an explicitly-set Marten knob still wins (a deliberate statement
about where the queues go), and a host that configures neither still lands on
wolverine_queues.

Polecat has the mirror-image gap — PolecatIntegration declares the same two
properties but nothing reads them — noted on the issue, not addressed here.

MartenTests 552/552, PostgresqlTests 475/475 (net9.0), including four new
regression tests covering both registration orders, the explicit-Marten-wins
case, and the untouched default.

Closes GH-3883.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ri7jHRKhaFNBesQM1B5i1k

Author: jeremydmiller

src/Persistence/MartenTests/marten_does_not_clobber_transport_schema.cs

@@ -0,0 +1,116 @@
+using IntegrationTests;
+using Marten;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Shouldly;
+using Wolverine;
+using Wolverine.Marten;
+using Wolverine.Persistence.Durability;
+using Wolverine.Postgresql;
+using Wolverine.Postgresql.Transport;
+using Wolverine.Runtime;
+
+namespace MartenTests;
+
+/// <summary>
+/// GH-3883. <c>IntegrateWithWolverine()</c> is an <see cref="IWolverineExtension"/>, so its
+/// Configure() runs at host build — AFTER the inline <c>UsePostgresqlPersistenceAndTransport(...)</c>
+/// call in the same options lambda. It used to unconditionally assign its own
+/// <c>TransportSchemaName</c> (default "wolverine_queues") onto the shared PostgreSQL transport, so
+/// any host combining Marten with an explicitly-schema'd database transport silently lost the
+/// schema it asked for: publishers wrote to one schema's queue table and listeners polled another's,
+/// with no error on either side.
+/// </summary>
+public class marten_does_not_clobber_transport_schema : PostgresqlContext
+{
+    private static IHost buildHost(Action<WolverineOptions> configure)
+    {
+        return Host.CreateDefaultBuilder()
+            .UseWolverine(opts =>
+            {
+                opts.Discovery.DisableConventionalDiscovery();
+                opts.Durability.Mode = DurabilityMode.Solo;
+                configure(opts);
+            })
+            .Build(); // Build, not Start — extensions apply at build and no database is touched.
+    }
+
+    private static PostgresqlTransport transportOf(IHost host)
+    {
+        var runtime = host.Services.GetRequiredService<IWolverineRuntime>();
+        return runtime.Options.Transports.GetOrCreate<PostgresqlTransport>();
+    }
+
+    [Fact]
+    public void an_explicit_transport_schema_survives_marten_integration()
+    {
+        using var host = buildHost(opts =>
+        {
+            opts.UsePostgresqlPersistenceAndTransport(
+                    Servers.PostgresConnectionString,
+                    "myapp",
+                    "myapp_queues",
+                    MessageStoreRole.Ancillary)
+                .AutoProvision();
+
+            opts.Services.AddMarten(m => m.Connection(Servers.PostgresConnectionString))
+                .IntegrateWithWolverine();
+        });
+
+        transportOf(host).TransportSchemaName.ShouldBe("myapp_queues");
+    }
+
+    [Fact]
+    public void the_explicit_schema_survives_regardless_of_registration_order()
+    {
+        using var host = buildHost(opts =>
+        {
+            opts.Services.AddMarten(m => m.Connection(Servers.PostgresConnectionString))
+                .IntegrateWithWolverine();
+
+            opts.UsePostgresqlPersistenceAndTransport(
+                    Servers.PostgresConnectionString,
+                    "myapp",
+                    "myapp_queues",
+                    MessageStoreRole.Ancillary)
+                .AutoProvision();
+        });
+
+        transportOf(host).TransportSchemaName.ShouldBe("myapp_queues");
+    }
+
+    [Fact]
+    public void an_explicit_schema_on_the_marten_integration_still_wins()
+    {
+        // The integration's own knob remains authoritative when the caller sets it — that is a
+        // deliberate statement about where the queues go, not the default leaking through.
+        using var host = buildHost(opts =>
+        {
+            opts.UsePostgresqlPersistenceAndTransport(
+                    Servers.PostgresConnectionString,
+                    "myapp",
+                    "myapp_queues",
+                    MessageStoreRole.Ancillary)
+                .AutoProvision();
+
+            opts.Services.AddMarten(m => m.Connection(Servers.PostgresConnectionString))
+                .IntegrateWithWolverine(x => x.TransportSchemaName = "marten_chosen");
+        });
+
+        transportOf(host).TransportSchemaName.ShouldBe("marten_chosen");
+    }
+
+    [Fact]
+    public void the_default_is_unchanged_when_nobody_configures_a_schema()
+    {
+        using var host = buildHost(opts =>
+        {
+            opts.UsePostgresqlPersistenceAndTransport(Servers.PostgresConnectionString);
+
+            opts.Services.AddMarten(m => m.Connection(Servers.PostgresConnectionString))
+                .IntegrateWithWolverine();
+        });
+
+        transportOf(host).TransportSchemaName.ShouldBe("wolverine_queues");
+    }
+}

src/Persistence/Wolverine.Marten/MartenIntegration.cs

@@ -97,9 +97,24 @@ public void Configure(WolverineOptions options)
 
         options.Policies.ForwardHandledTypes(new EventWrapperForwarder());
 
+        // GH-3883: only stamp the transport with schema names the caller actually asked for. This
+        // Configure() runs at host build — AFTER an inline UsePostgresqlPersistenceAndTransport(...)
+        // in the same options lambda — so assigning unconditionally meant this integration's own
+        // DEFAULTS silently overwrote the caller's explicit transport schema. That is invisible and
+        // it breaks the data plane rather than startup: a Marten-backed consumer ends up listening
+        // on wolverine_queues.wolverine_queue_x while non-Marten publishers write to
+        // {configured}.wolverine_queue_x, auto-provision creates both, and nothing is ever delivered.
         var transport = options.Transports.GetOrCreate<PostgresqlTransport>();
-        transport.TransportSchemaName = TransportSchemaName;
-        transport.MessageStorageSchemaName = MessageStorageSchemaName ?? "public";
+
+        if (_transportSchemaNameIsExplicit)
+        {
+            transport.TransportSchemaName = TransportSchemaName;
+        }
+
+        if (MessageStorageSchemaName.IsNotEmpty())
+        {
+            transport.MessageStorageSchemaName = MessageStorageSchemaName;
+        }
 
         options.Policies.Add<MartenOpPolicy>();
 
@@ -125,14 +140,25 @@ public void Configure(WolverineOptions options)
     internal MartenEventRouter EventRouter { get; } = new();
 
     private string _transportSchemaName = "wolverine_queues";
+    private bool _transportSchemaNameIsExplicit;
 
     /// <summary>
-    /// The database schema to place postgres-backed queues. The default is "wolverine_queues"
+    /// The database schema to place postgres-backed queues. The default is "wolverine_queues".
     /// </summary>
+    /// <remarks>
+    /// GH-3883: setting this is authoritative — it overwrites whatever the PostgreSQL transport was
+    /// configured with, because this integration applies at host build. Leaving it alone leaves the
+    /// transport's own configuration (its default, or an explicit
+    /// <c>UsePostgresqlPersistenceAndTransport(..., transportSchema: ...)</c>) untouched.
+    /// </remarks>
     public string TransportSchemaName
     {
         get => _transportSchemaName;
-        set => _transportSchemaName = value.ToLowerInvariant();
+        set
+        {
+            _transportSchemaName = value.ToLowerInvariant();
+            _transportSchemaNameIsExplicit = true;
+        }
     }
 
     private string? _messageStorageSchemaName;