test: address review feedback — drop Fragile trait, document converter contract, pin fallback

Three issues from claude[bot]'s latest review:

1. The new ASB unit test carried [Trait("Fragile", "CI")], copied by
   mistake from the live-ASB integration tests. The CI pipeline uses
   "Fragile!=CI" as its filter, so the trait skipped the only
   transport-level pin for local-header filtering. Drop it.

2. GetProducerLookupTopic uses `producerTopic is string topic`. Concern
   was that persistent outboxes round-trip Header.Bag through JSON, so
   values would come back as JsonElement and the cast would silently
   fail — reproducing the bug the PR fixes.

   Investigation shows Brighter's bag round-trip uses
   JsonSerialisationOptions.Options, which composes
   DictionaryStringObjectJsonConverter with ObjectToInferredTypesConverter
   to preserve string runtime types. Verified RelationDatabaseOutbox
   (covers MsSql, PostgreSQL, MySql, Sqlite, Spanner), MongoDb, and
   DynamoDB all use those options on deserialise.

   Document the contract on GetProducerLookupTopic and add
   BagStringValueRoundTripTests to pin the converter behaviour. If a
   future change drops one of the converters, the round-trip test fails
   loudly instead of GetProducerLookupTopic regressing silently.

3. Add WrapMatchingPublicationTopicTests to pin the fallback path: when
   a mapper does NOT override Header.Topic, no ProducerTopic bag entry
   is written and producer lookup falls back to Header.Topic. The
   existing test trio (reply-mapper-overrides, null-publication-topic,
   matching-topic) now covers all three branches of WrapPipeline.Wrap.

Co-Authored-By: Claude (claude-opus-4-7) <noreply@anthropic.com>

Author: DevJonny

src/Paramore.Brighter/OutboxProducerMediator.cs

@@ -781,6 +781,14 @@ private static RoutingKey GetProducerLookupTopic(Message message)
             // dynamic reply address. Normal publications don't carry the bag entry, so we
             // fall back to Header.Topic — and a null/empty Header.Topic remains a lookup
             // failure, matching pre-fix behaviour.
+            //
+            // The `is string` cast is safe across persistent outboxes (SQL family,
+            // Mongo, DynamoDB) because Brighter's bag round-trip uses
+            // JsonSerialisationOptions.Options, which registers DictionaryStringObjectJsonConverter
+            // + ObjectToInferredTypesConverter — together they preserve the string runtime
+            // type through serialise/deserialise rather than handing back JsonElement.
+            // See When_Bag_String_Values_Round_Trip_Through_Brighter_Json_Options for
+            // a regression pin on that contract.
             if (message.Header.Bag.TryGetValue(Message.ProducerTopicHeaderName, out var producerTopic)
                 && producerTopic is string topic)
             {

tests/Paramore.Brighter.AzureServiceBus.Tests/MessagingGateway/When_Converting_A_Message_With_Local_Headers.cs

@@ -5,7 +5,6 @@
 namespace Paramore.Brighter.AzureServiceBus.Tests.MessagingGateway;
 
 [Trait("Category", "ASB")]
-[Trait("Fragile", "CI")]
 public class AzureServiceBusMessagePublisherLocalHeaderTests
 {
     [Fact]

tests/Paramore.Brighter.Core.Tests/MessageSerialisation/When_Bag_String_Values_Round_Trip_Through_Brighter_Json_Options.cs

@@ -0,0 +1,34 @@
+using System.Collections.Generic;
+using System.Text.Json;
+using Paramore.Brighter.JsonConverters;
+using Xunit;
+
+namespace Paramore.Brighter.Core.Tests.MessageSerialisation;
+
+// Regression pin for the contract that OutboxProducerMediator.GetProducerLookupTopic
+// relies on: when Header.Bag is round-tripped through Brighter's JsonSerialisationOptions
+// the values come back as their runtime types (string here), NOT as JsonElement.
+// If a future change drops DictionaryStringObjectJsonConverter or
+// ObjectToInferredTypesConverter from the options, the `producerTopic is string` cast in
+// GetProducerLookupTopic would silently fail for persistent outboxes (SQL, Mongo,
+// DynamoDB) and reply-message dispatch would regress to the bug this PR fixes.
+public class BagStringValueRoundTripTests
+{
+    [Fact]
+    public void When_Round_Tripping_A_Bag_String_Value_It_Survives_As_String_Not_JsonElement()
+    {
+        var bag = new Dictionary<string, object>
+        {
+            [Message.ProducerTopicHeaderName] = "the.publication.topic",
+            ["customer.header"] = "customer.value"
+        };
+
+        var json = JsonSerializer.Serialize(bag, JsonSerialisationOptions.Options);
+        var roundTripped = JsonSerializer.Deserialize<Dictionary<string, object>>(json, JsonSerialisationOptions.Options);
+
+        Assert.NotNull(roundTripped);
+        Assert.IsType<string>(roundTripped![Message.ProducerTopicHeaderName]);
+        Assert.Equal("the.publication.topic", roundTripped[Message.ProducerTopicHeaderName]);
+        Assert.IsType<string>(roundTripped["customer.header"]);
+    }
+}

tests/Paramore.Brighter.Core.Tests/MessageSerialisation/When_Wrapping_A_Message_Whose_Topic_Matches_The_Publication.cs

@@ -0,0 +1,45 @@
+using Paramore.Brighter.Core.Tests.CommandProcessors.TestDoubles;
+using Xunit;
+
+namespace Paramore.Brighter.Core.Tests.MessageSerialisation;
+
+// Fallback path for OutboxProducerMediator.GetProducerLookupTopic: when a mapper does
+// NOT override Header.Topic (the normal-publication case), no ProducerTopic bag entry
+// is written. Producer lookup then falls back to Header.Topic. Without this pin, a
+// future change that always wrote the bag entry would leave persistent outbox rows
+// across a rolling upgrade with stale producer hints — exactly the failure mode the
+// pre-fix bug had, just inverted.
+public class WrapMatchingPublicationTopicTests
+{
+    [Fact]
+    public void When_The_Mapper_Topic_Matches_The_Publication_No_Producer_Topic_Bag_Entry_Is_Written()
+    {
+        TransformPipelineBuilder.ClearPipelineCache();
+
+        var mapperRegistry = new MessageMapperRegistry(
+            new SimpleMessageMapperFactory(_ => new MyCommandMessageMapper()),
+            null);
+        mapperRegistry.Register<MyCommand, MyCommandMessageMapper>();
+
+        var publicationTopic = new RoutingKey("normal.publication.topic");
+        var publication = new Publication
+        {
+            Topic = publicationTopic,
+            RequestType = typeof(MyCommand)
+        };
+
+        var pipelineBuilder = new TransformPipelineBuilder(
+            mapperRegistry,
+            new SimpleMessageTransformerFactory(_ => null));
+
+        var message = pipelineBuilder
+            .BuildWrapPipeline<MyCommand>()
+            .Wrap(new MyCommand(), new RequestContext(), publication);
+
+        // mapper produced a topic identical to publication.Topic — fallback path
+        Assert.Equal(publicationTopic, message.Header.Topic);
+
+        // no bag entry → producer lookup falls back to Header.Topic
+        Assert.False(message.Header.Bag.ContainsKey(Message.ProducerTopicHeaderName));
+    }
+}