Installer support to opt into index creation

src/NServiceBus.Storage.MongoDB.PersistenceTests/PersistenceTestsConfiguration.cs

@@ -13,6 +13,8 @@
 using Persistence;
 using Storage.MongoDB;
 using Storage.MongoDB.Tests;
+using OutboxStorageFeature = Storage.MongoDB.OutboxStorage;
+using SagaStorageFeature = Storage.MongoDB.SagaStorage;
 using SynchronizedStorageSession = Storage.MongoDB.SynchronizedStorageSession;
 
 public partial class PersistenceTestsConfiguration
@@ -38,25 +40,27 @@ public async Task Configure(CancellationToken cancellationToken = default)
         BsonSerializer.TryRegisterSerializer(new GuidSerializer(GuidRepresentation.Standard));
 
         var memberMapCache = new MemberMapCache();
-        Storage.MongoDB.SagaStorage.InitializeSagaDataTypes(ClientProvider.Client, memberMapCache, databaseName,
-            MongoPersistence.DefaultCollectionNamingConvention, SagaMetadataCollection);
-        SagaStorage = new SagaPersister(SagaPersister.DefaultVersionElementName, memberMapCache);
-        var synchronizedStorage = new StorageSessionFactory(ClientProvider.Client, true, databaseName,
-            MongoPersistence.DefaultCollectionNamingConvention,
-            SessionTimeout ?? MongoPersistence.DefaultTransactionTimeout);
-        CreateStorageSession = () => new SynchronizedStorageSession(synchronizedStorage);
-
         var databaseSettings = new MongoDatabaseSettings
         {
             ReadConcern = ReadConcern.Majority,
             ReadPreference = ReadPreference.Primary,
             WriteConcern = WriteConcern.WMajority
         };
-        var database = ClientProvider.Client.GetDatabase(databaseName, databaseSettings);
-        await database.CreateCollectionAsync(MongoPersistence.DefaultCollectionNamingConvention(typeof(OutboxRecord)),
-            cancellationToken: cancellationToken);
-        OutboxStorage = new OutboxPersister(ClientProvider.Client, databaseName,
-            MongoPersistence.DefaultCollectionNamingConvention);
+
+        SagaStorageFeature.RegisterSagaEntityClassMappings(SagaMetadataCollection, memberMapCache);
+        await SagaInstaller.CreateInfrastructureForSagaDataTypes(ClientProvider.Client, databaseSettings, memberMapCache, databaseName,
+            MongoPersistence.DefaultCollectionNamingConvention, MongoPersistence.DefaultCollectionSettings, SagaMetadataCollection, cancellationToken);
+
+        SagaStorage = new SagaPersister(SagaPersister.DefaultVersionElementName, memberMapCache);
+        var synchronizedStorage = new StorageSessionFactory(ClientProvider.Client, true, databaseName,
+            MongoPersistence.DefaultCollectionNamingConvention,
+            SessionTimeout ?? MongoPersistence.DefaultTransactionTimeout);
+        CreateStorageSession = () => new SynchronizedStorageSession(synchronizedStorage);
+
+        OutboxStorageFeature.RegisterOutboxClassMappings();
+        await OutboxInstaller.CreateInfrastructureForOutboxTypes(ClientProvider.Client, databaseName, MongoPersistence.DefaultDatabaseSettings, MongoPersistence.DefaultCollectionNamingConvention, MongoPersistence.DefaultCollectionSettings, TimeSpan.FromDays(7), cancellationToken);
+
+        OutboxStorage = new OutboxPersister(ClientProvider.Client, databaseName, MongoPersistence.DefaultCollectionNamingConvention);
     }
 
     public async Task Cleanup(CancellationToken cancellationToken = default) =>

src/NServiceBus.Storage.MongoDB.Tests/ApprovalFiles/APIApprovals.Approve.approved.txt

@@ -15,6 +15,7 @@ namespace NServiceBus
     {
         public static NServiceBus.CompatibilitySettings CommunityPersistenceCompatibility(this NServiceBus.PersistenceExtensions<NServiceBus.MongoPersistence> persistenceExtensions) { }
         public static NServiceBus.PersistenceExtensions<NServiceBus.MongoPersistence> DatabaseName(this NServiceBus.PersistenceExtensions<NServiceBus.MongoPersistence> persistenceExtensions, string databaseName) { }
+        public static void DisableInstaller(this NServiceBus.PersistenceExtensions<NServiceBus.MongoPersistence> persistenceExtensions) { }
         public static NServiceBus.PersistenceExtensions<NServiceBus.MongoPersistence> MongoClient(this NServiceBus.PersistenceExtensions<NServiceBus.MongoPersistence> persistenceExtensions, MongoDB.Driver.IMongoClient mongoClient) { }
         public static NServiceBus.PersistenceExtensions<NServiceBus.MongoPersistence> TimeToKeepOutboxDeduplicationData(this NServiceBus.PersistenceExtensions<NServiceBus.MongoPersistence> persistenceExtensions, System.TimeSpan timeToKeepOutboxDeduplicationData) { }
         public static NServiceBus.PersistenceExtensions<NServiceBus.MongoPersistence> UseTransactions(this NServiceBus.PersistenceExtensions<NServiceBus.MongoPersistence> persistenceExtensions, bool useTransactions) { }

src/NServiceBus.Storage.MongoDB.Tests/Outbox/OutboxInitializationTests.cs

@@ -12,49 +12,54 @@ namespace NServiceBus.Storage.MongoDB.Tests;
 public class OutboxInitializationTests
 {
     [OneTimeSetUp]
-    public async Task OneTimeSetUp()
+    public Task OneTimeSetUp()
     {
         databaseName = "Test_" + DateTime.UtcNow.Ticks.ToString(CultureInfo.InvariantCulture);
 
-        var databaseSettings = new MongoDatabaseSettings
-        {
-            ReadConcern = ReadConcern.Majority,
-            ReadPreference = ReadPreference.Primary,
-            WriteConcern = WriteConcern.WMajority
-        };
+        database = ClientProvider.Client.GetDatabase(databaseName, MongoPersistence.DefaultDatabaseSettings);
+        outboxCollection = database.GetCollection<OutboxRecord>(CollectionNamingConvention<OutboxRecord>(), MongoPersistence.DefaultCollectionSettings);
 
-        var database = ClientProvider.Client.GetDatabase(databaseName, databaseSettings);
-
-        await database.CreateCollectionAsync(CollectionNamingConvention<OutboxRecord>());
-
-        outboxCollection = ClientProvider.Client.GetDatabase(databaseName)
-            .GetCollection<OutboxRecord>(CollectionNamingConvention<OutboxRecord>());
+        return Task.CompletedTask;
     }
 
     static string CollectionNamingConvention<T>() => CollectionNamingConvention(typeof(T));
 
     static string CollectionNamingConvention(Type type) => type.Name.ToLower();
 
     [SetUp]
-    public async Task Setup() => await outboxCollection.Indexes.DropAllAsync();
+    public async Task Setup() => await database.DropCollectionAsync(CollectionNamingConvention<OutboxRecord>());
+
+    [Theory]
+    public async Task Should_create_collection_when_it_doesnt_exist(TimeSpan timeToKeepOutboxDeduplicationData)
+    {
+        await database.DropCollectionAsync(CollectionNamingConvention<OutboxRecord>());
+
+        await OutboxInstaller.CreateInfrastructureForOutboxTypes(ClientProvider.Client, databaseName, MongoPersistence.DefaultDatabaseSettings, CollectionNamingConvention,
+            MongoPersistence.DefaultCollectionSettings, timeToKeepOutboxDeduplicationData);
+
+        var collections = await (await database
+            .ListCollectionsAsync()).ToListAsync();
+
+        Assert.That(collections, Has.One.Matches<BsonDocument>(b => b.GetElement("name").Value == CollectionNamingConvention<OutboxRecord>()));
+    }
 
     [Theory]
     public async Task Should_create_index_when_it_doesnt_exist(TimeSpan timeToKeepOutboxDeduplicationData)
     {
-        OutboxStorage.InitializeOutboxTypes(ClientProvider.Client, databaseName, CollectionNamingConvention,
-            timeToKeepOutboxDeduplicationData);
+        await OutboxInstaller.CreateInfrastructureForOutboxTypes(ClientProvider.Client, databaseName, MongoPersistence.DefaultDatabaseSettings, CollectionNamingConvention,
+            MongoPersistence.DefaultCollectionSettings, timeToKeepOutboxDeduplicationData);
 
         await AssertIndexCorrect(outboxCollection, timeToKeepOutboxDeduplicationData);
     }
 
     [Theory]
     public async Task Should_recreate_when_expiry_drifts(TimeSpan timeToKeepOutboxDeduplicationData)
     {
-        OutboxStorage.InitializeOutboxTypes(ClientProvider.Client, databaseName, CollectionNamingConvention,
-            timeToKeepOutboxDeduplicationData.Add(TimeSpan.FromSeconds(30)));
+        await OutboxInstaller.CreateInfrastructureForOutboxTypes(ClientProvider.Client, databaseName, MongoPersistence.DefaultDatabaseSettings, CollectionNamingConvention,
+            MongoPersistence.DefaultCollectionSettings, timeToKeepOutboxDeduplicationData.Add(TimeSpan.FromSeconds(30)));
 
-        OutboxStorage.InitializeOutboxTypes(ClientProvider.Client, databaseName, CollectionNamingConvention,
-            timeToKeepOutboxDeduplicationData);
+        await OutboxInstaller.CreateInfrastructureForOutboxTypes(ClientProvider.Client, databaseName, MongoPersistence.DefaultDatabaseSettings, CollectionNamingConvention,
+            MongoPersistence.DefaultCollectionSettings, timeToKeepOutboxDeduplicationData);
 
         await AssertIndexCorrect(outboxCollection, timeToKeepOutboxDeduplicationData);
     }
@@ -64,22 +69,22 @@ public async Task Should_recreate_when_expiry_column_dropped(TimeSpan timeToKeep
     {
         var indexModel = new CreateIndexModel<OutboxRecord>(
             Builders<OutboxRecord>.IndexKeys.Ascending(record => record.Dispatched),
-            new CreateIndexOptions { Name = OutboxStorage.OutboxCleanupIndexName, Background = true });
+            new CreateIndexOptions { Name = OutboxInstaller.OutboxCleanupIndexName, Background = true });
         await outboxCollection.Indexes.CreateOneAsync(indexModel);
 
-        OutboxStorage.InitializeOutboxTypes(ClientProvider.Client, databaseName, CollectionNamingConvention,
-            timeToKeepOutboxDeduplicationData);
+        await OutboxInstaller.CreateInfrastructureForOutboxTypes(ClientProvider.Client, databaseName, MongoPersistence.DefaultDatabaseSettings, CollectionNamingConvention,
+            MongoPersistence.DefaultCollectionSettings, timeToKeepOutboxDeduplicationData);
 
         await AssertIndexCorrect(outboxCollection, timeToKeepOutboxDeduplicationData);
     }
 
     [DatapointSource]
-    public TimeSpan[] Expiry = new TimeSpan[] { TimeSpan.FromHours(1), TimeSpan.FromHours(3), TimeSpan.FromDays(1) };
+    public TimeSpan[] Expiry = [TimeSpan.FromHours(1), TimeSpan.FromHours(3), TimeSpan.FromDays(1)];
 
     static async Task AssertIndexCorrect(IMongoCollection<OutboxRecord> outboxCollection, TimeSpan expiry)
     {
         var outboxCleanupIndex = (await outboxCollection.Indexes.ListAsync()).ToList().SingleOrDefault(indexDocument =>
-            indexDocument.GetElement("name").Value == OutboxStorage.OutboxCleanupIndexName);
+            indexDocument.GetElement("name").Value == OutboxInstaller.OutboxCleanupIndexName);
 
         Assert.That(outboxCleanupIndex, Is.Not.Null);
 
@@ -92,4 +97,5 @@ static async Task AssertIndexCorrect(IMongoCollection<OutboxRecord> outboxCollec
 
     IMongoCollection<OutboxRecord> outboxCollection;
     string databaseName;
+    IMongoDatabase database;
 }

src/NServiceBus.Storage.MongoDB.Tests/Outbox/OutboxTestsConfiguration.cs

@@ -4,8 +4,7 @@
 using System.Globalization;
 using System.Threading.Tasks;
 using Extensibility;
-using global::MongoDB.Driver;
-using NServiceBus.Outbox;
+using Outbox;
 
 public class OutboxTestsConfiguration
 {
@@ -31,34 +30,21 @@ public OutboxTestsConfiguration(TimeSpan? transactionTimeout = null) : this(t =>
 
     public IOutboxStorage OutboxStorage { get; private set; }
 
-    public Task<IOutboxTransaction> CreateTransaction(ContextBag context)
-    {
-        return transactionFactory.BeginTransaction(context);
-    }
+    public Task<IOutboxTransaction> CreateTransaction(ContextBag context) => transactionFactory.BeginTransaction(context);
 
     public async Task Configure()
     {
-        var databaseSettings = new MongoDatabaseSettings
-        {
-            ReadConcern = ReadConcern.Majority,
-            ReadPreference = ReadPreference.Primary,
-            WriteConcern = WriteConcern.WMajority
-        };
-
-        var database = ClientProvider.Client.GetDatabase(DatabaseName, databaseSettings);
+        var database = ClientProvider.Client.GetDatabase(DatabaseName, MongoPersistence.DefaultDatabaseSettings);
 
         await database.CreateCollectionAsync(CollectionNamingConvention(typeof(OutboxRecord)));
 
-        MongoDB.OutboxStorage.InitializeOutboxTypes(ClientProvider.Client, DatabaseName, CollectionNamingConvention,
-            TimeSpan.FromHours(1));
+        await OutboxInstaller.CreateInfrastructureForOutboxTypes(ClientProvider.Client, DatabaseName, MongoPersistence.DefaultDatabaseSettings, CollectionNamingConvention,
+            MongoPersistence.DefaultCollectionSettings, TimeSpan.FromHours(1));
 
         OutboxStorage = new OutboxPersister(ClientProvider.Client, DatabaseName, CollectionNamingConvention);
     }
 
-    public async Task Cleanup()
-    {
-        await ClientProvider.Client.DropDatabaseAsync(DatabaseName);
-    }
+    public async Task Cleanup() => await ClientProvider.Client.DropDatabaseAsync(DatabaseName);
 
     readonly MongoOutboxTransactionFactory transactionFactory;
 }

src/NServiceBus.Storage.MongoDB.Tests/Sagas/SagaTestsConfiguration.cs

@@ -9,6 +9,7 @@
 using global::MongoDB.Driver;
 using MongoDB;
 using Sagas;
+using SagaStorageFeature = SagaStorage;
 using SynchronizedStorageSession = SynchronizedStorageSession;
 
 public class SagaTestsConfiguration
@@ -76,12 +77,8 @@ public async Task Configure()
             WriteConcern = WriteConcern.WMajority
         };
 
-        var database = ClientProvider.Client.GetDatabase(DatabaseName, databaseSettings);
-
-        await database.CreateCollectionAsync(CollectionNamingConvention(typeof(OutboxRecord)));
-
-        MongoDB.SagaStorage.InitializeSagaDataTypes(ClientProvider.Client, memberMapCache, DatabaseName,
-            CollectionNamingConvention, SagaMetadataCollection);
+        SagaStorageFeature.RegisterSagaEntityClassMappings(SagaMetadataCollection, memberMapCache);
+        await SagaInstaller.CreateInfrastructureForSagaDataTypes(ClientProvider.Client, databaseSettings, memberMapCache, DatabaseName, CollectionNamingConvention, MongoPersistence.DefaultCollectionSettings, SagaMetadataCollection);
     }
 
     public async Task Cleanup() => await ClientProvider.Client.DropDatabaseAsync(DatabaseName);