Various fixes about RenderArgs plus new tests

papafe · papafe · commit a31265a7a58d · 2025-07-01T14:34:45.000+02:00
diff --git a/src/MongoDB.Bson/Serialization/BsonSerializationDomain.cs b/src/MongoDB.Bson/Serialization/BsonSerializationDomain.cs
@@ -35,15 +35,15 @@ internal class BsonSerializationDomain : IBsonSerializationDomain, IDisposable
         private bool _useZeroIdChecker;
 
         // constructor
-        public BsonSerializationDomain(string name = null) //TODO name is used for testing
+        public BsonSerializationDomain(string name = null)
         {
             CreateSerializerRegistry();
             CreateSubDomains();
             RegisterIdGenerators();
-            Name = name ?? "CUSTOM";  //TODO remove after testing is done
+            Name = name ?? "CUSTOM";
         }
 
-        public string Name { get; private set; }
+        public string Name { get; }
 
         // public properties
         /// <summary>
diff --git a/src/MongoDB.Bson/Serialization/IBsonSerializationDomain.cs b/src/MongoDB.Bson/Serialization/IBsonSerializationDomain.cs
@@ -11,6 +11,8 @@ namespace MongoDB.Bson.Serialization
     /// </summary>
     internal interface IBsonSerializationDomain
     {
+        string Name { get; } //FP This is used for debugging purposes, but we could decide to make it public if needed.
+
         /// <summary>
         /// Returns whether the given type has any discriminators registered for any of its subclasses.
         /// </summary>
diff --git a/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToPipelineTranslators/AppendStageMethodToPipelineTranslator.cs b/src/MongoDB.Driver/Linq/Linq3Implementation/Translators/ExpressionToPipelineTranslators/AppendStageMethodToPipelineTranslator.cs
@@ -39,7 +39,7 @@ public static TranslatedPipeline Translate(TranslationContext context, MethodCal
 
                 var sourceSerializer = pipeline.OutputSerializer;
                 var stageExpression = arguments[1];
-                var renderedStage = TranslateStage(expression, stageExpression, sourceSerializer, context.SerializationDomain.SerializerRegistry, context.TranslationOptions);
+                var renderedStage = TranslateStage(expression, stageExpression, sourceSerializer, context.SerializationDomain, context.TranslationOptions);
                 var stage = AstStage.Universal(renderedStage.Document);
 
                 var resultSerializerExpression = arguments[2];
@@ -57,11 +57,11 @@ private static IRenderedPipelineStageDefinition TranslateStage(
             Expression expression,
             Expression stageExpression,
             IBsonSerializer inputSerializer,
-            IBsonSerializerRegistry serializerRegistry,
+            IBsonSerializationDomain serializationDomain,
             ExpressionTranslationOptions translationOptions)
         {
-            var stageDefinition = stageExpression.GetConstantValue<IPipelineStageDefinition>(stageExpression);
-            return stageDefinition.Render(inputSerializer, serializerRegistry, translationOptions);
+            var stageDefinition = stageExpression.GetConstantValue<IPipelineStageStageDefinitionInternal>(stageExpression);
+            return stageDefinition.Render(inputSerializer, serializationDomain, translationOptions);
         }
     }
 }
diff --git a/src/MongoDB.Driver/MongoClientSettings.cs b/src/MongoDB.Driver/MongoClientSettings.cs
@@ -474,11 +474,6 @@ public ReadPreference ReadPreference
             }
         }
 
-        /// <summary>
-        /// //TODO
-        /// </summary>
-        /// <exception cref="InvalidOperationException"></exception>
-        /// <exception cref="ArgumentNullException"></exception>
         IBsonSerializationDomain IInheritableMongoClientSettings.SerializationDomain
         {
             get => _serializationDomain;
diff --git a/src/MongoDB.Driver/PipelineDefinition.cs b/src/MongoDB.Driver/PipelineDefinition.cs
@@ -21,6 +21,7 @@
 using MongoDB.Bson.Serialization.Serializers;
 using MongoDB.Driver.Core.Misc;
 using MongoDB.Driver.Linq;
+using MongoDB.Driver.Support;
 
 namespace MongoDB.Driver
 {
@@ -329,7 +330,7 @@ public override RenderedPipelineDefinition<TOutput> Render(RenderArgs<TInput> ar
             IBsonSerializer currentSerializer = args.DocumentSerializer;
             foreach (var stage in _stages)
             {
-                var renderedStage = stage.Render(currentSerializer, args.SerializerRegistry, args.TranslationOptions);
+                var renderedStage = stage.RenderInternal(currentSerializer, args.SerializationDomain, args.SerializerRegistry, args.TranslationOptions);
                 currentSerializer = renderedStage.OutputSerializer;
                 foreach (var document in renderedStage.Documents)
                 {
diff --git a/src/MongoDB.Driver/PipelineStageDefinition.cs b/src/MongoDB.Driver/PipelineStageDefinition.cs
@@ -16,7 +16,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Transactions;
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
 using MongoDB.Driver.Core.Misc;
@@ -168,12 +167,17 @@ public interface IPipelineStageDefinition
         string ToString(IBsonSerializer inputSerializer, IBsonSerializerRegistry serializerRegistry);
     }
 
+    internal interface IPipelineStageStageDefinitionInternal : IPipelineStageDefinition
+    {
+        IRenderedPipelineStageDefinition Render(IBsonSerializer inputSerializer, IBsonSerializationDomain serializationDomain, ExpressionTranslationOptions translationOptions);
+    }
+
     /// <summary>
     /// Base class for pipeline stages.
     /// </summary>
     /// <typeparam name="TInput">The type of the input.</typeparam>
     /// <typeparam name="TOutput">The type of the output.</typeparam>
-    public abstract class PipelineStageDefinition<TInput, TOutput> : IPipelineStageDefinition
+    public abstract class PipelineStageDefinition<TInput, TOutput> : IPipelineStageStageDefinitionInternal
     {
         /// <summary>
         /// Gets the type of the input.
@@ -293,6 +297,12 @@ IRenderedPipelineStageDefinition IPipelineStageDefinition.Render(IBsonSerializer
         {
             return Render(new((IBsonSerializer<TInput>)inputSerializer, serializerRegistry, translationOptions: translationOptions));
         }
+
+        IRenderedPipelineStageDefinition IPipelineStageStageDefinitionInternal.Render(IBsonSerializer inputSerializer, IBsonSerializationDomain serializationDomain,
+            ExpressionTranslationOptions translationOptions)
+        {
+            return Render(new((IBsonSerializer<TInput>)inputSerializer, serializationDomain, translationOptions: translationOptions));
+        }
     }
 
     /// <summary>
diff --git a/src/MongoDB.Driver/Support/InternalExtensions.cs b/src/MongoDB.Driver/Support/InternalExtensions.cs
@@ -0,0 +1,39 @@
+/* Copyright 2010-present MongoDB Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+using MongoDB.Bson.Serialization;
+
+namespace MongoDB.Driver.Support
+{
+    internal static class InternalExtensions
+    {
+        #region IPipelineStageDefinition
+
+        public static IRenderedPipelineStageDefinition RenderInternal(this IPipelineStageDefinition pipelineStageDefinition, IBsonSerializer inputSerializer,
+            IBsonSerializationDomain serializationDomain, IBsonSerializerRegistry serializerRegistry, ExpressionTranslationOptions translationOptions)
+        {
+            if (pipelineStageDefinition is IPipelineStageStageDefinitionInternal pipelineStageStageDefinitionInternal)
+            {
+                return pipelineStageStageDefinitionInternal
+                    .Render(inputSerializer, serializationDomain, translationOptions);
+            }
+
+            return pipelineStageDefinition
+                .Render(inputSerializer, serializerRegistry, translationOptions);
+        }
+
+        #endregion
+    }
+}
diff --git a/tests/MongoDB.Driver.Tests/MultipleRegistriesTests.cs b/tests/MongoDB.Driver.Tests/MultipleRegistriesTests.cs
@@ -20,6 +20,7 @@
 using MongoDB.Bson.Serialization.Conventions;
 using MongoDB.Bson.Serialization.Serializers;
 using MongoDB.Driver.Core.TestHelpers.XunitExtensions;
+using MongoDB.Driver.Linq;
 using Xunit;
 
 namespace MongoDB.Driver.Tests
@@ -169,31 +170,68 @@ public void TestConventions()
         }
 
         [Fact]
-        public void TestAggregate()
+        public void TestDiscriminators()
         {
             RequireServer.Check();
 
             var customDomain = BsonSerializer.CreateSerializationDomain();
-            customDomain.RegisterSerializer(new CustomStringSerializer());
+
+            customDomain.BsonClassMap.RegisterClassMap<BasePerson>(cm =>
+            {
+                cm.AutoMap();
+                cm.SetIsRootClass(true);
+            });
+
+            customDomain.BsonClassMap.RegisterClassMap<DerivedPerson1>(cm =>
+            {
+                cm.AutoMap();
+                cm.SetDiscriminator("dp1");
+            });
+
+            customDomain.BsonClassMap.RegisterClassMap<DerivedPerson2>(cm =>
+            {
+                cm.AutoMap();
+                cm.SetDiscriminator("dp2");
+            });
 
             var client = DriverTestConfiguration.CreateMongoClient((MongoClientSettings c) => (c as IInheritableMongoClientSettings).SerializationDomain = customDomain);
             var db = client.GetDatabase(DriverTestConfiguration.DatabaseNamespace.DatabaseName);
             db.DropCollection(DriverTestConfiguration.CollectionNamespace.CollectionName);
-            var collection = db.GetCollection<Person>(DriverTestConfiguration.CollectionNamespace.CollectionName);
+            var collection = db.GetCollection<BasePerson>(DriverTestConfiguration.CollectionNamespace.CollectionName);
             var untypedCollection = db.GetCollection<BsonDocument>(DriverTestConfiguration.CollectionNamespace.CollectionName);
 
-            var person = new Person { Id = ObjectId.Parse("6797b56bf5495bf53aa3078f"), Name = "Mario", Age = 24 };
-            collection.InsertOne(person);
+            var bp1 = new DerivedPerson1 { Name = "Alice", Age = 30, ExtraField1 = "Field1" };
+            var bp2 = new DerivedPerson2 { Name = "Bob", Age = 40, ExtraField2 = "Field2" };
+            collection.InsertMany(new BasePerson[] { bp1, bp2 });
 
-            var retrievedAsBson = untypedCollection.FindSync("{}").ToList().Single();
-            var toString = retrievedAsBson.ToString();
+            var test1 = collection.Aggregate().OfType<DerivedPerson1>().Single();
+            var test2 = collection.Aggregate().OfType<DerivedPerson2>().Single();
 
-            var expectedVal =
-                """{ "_id" : { "$oid" : "6797b56bf5495bf53aa3078f" }, "Name" : "Mariotest", "Age" : 24 }""";
-            Assert.Equal(expectedVal, toString);
+            Assert.Equal(bp1.Id, test1.Id);
+            Assert.Equal(bp2.Id, test2.Id);
 
-            var retrievedTyped = collection.AsQueryable().Where(x => x.Name == "Mario").ToList();  //The string serializer is correctly serializing "Mario" to "Mariotest"
-            Assert.NotEmpty(retrievedTyped);
+            var a1 = collection.AsQueryable().AppendStage(PipelineStageDefinitionBuilder.OfType<BasePerson, DerivedPerson1>())
+                .OfType<DerivedPerson1>().Single();
+            var a2 = collection.AsQueryable().AppendStage(PipelineStageDefinitionBuilder.OfType<BasePerson, DerivedPerson2>())
+                .OfType<DerivedPerson2>().Single();
+
+            Assert.Equal(bp1.Id, a1.Id);
+            Assert.Equal(bp2.Id, a2.Id);
+
+            var res1 = collection.AsQueryable().OfType<DerivedPerson1>().Single();
+            var res2 = collection.AsQueryable().OfType<DerivedPerson2>().Single();
+
+            Assert.Equal(bp1.Id, res1.Id);
+            Assert.Equal(bp2.Id, res2.Id);
+
+            var filter1 = Builders<BasePerson>.Filter.OfType<DerivedPerson1>();
+            var dp1 = collection.FindSync(filter1).Single();
+
+            var filter2 = Builders<BasePerson>.Filter.OfType<DerivedPerson2>();
+            var dp2 = collection.FindSync(filter2).Single();
+
+            Assert.Equal(bp1.Id, dp1.Id);
+            Assert.Equal(bp2.Id, dp2.Id);
         }
 
         public class Person
@@ -212,15 +250,22 @@ public class Person1
 
         public class BasePerson
         {
-            [BsonId] public ObjectId Id { get; set; }
+            [BsonId] public ObjectId Id { get; set; } = ObjectId.GenerateNewId();
             public string Name { get; set; }
             public int Age { get; set; }
         }
 
-        public class DerivedPerson : BasePerson
+        public class DerivedPerson1 : BasePerson
         {
+            public string ExtraField1 { get; set; }
         }
 
+        public class DerivedPerson2 : BasePerson
+        {
+            public string ExtraField2 { get; set; }
+        }
+
+
         public class CustomStringSerializer : SealedClassSerializerBase<string> //This serializer just adds "test" to any serialised string
         {
             /// <inheritdoc/>

Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,8 @@ namespace MongoDB.Bson.Serialization`
`11`	`11`	`/// </summary>`
`12`	`12`	`internal interface IBsonSerializationDomain`
`13`	`13`	`{`
	`14`	`+ string Name { get; } //FP This is used for debugging purposes, but we could decide to make it public if needed.`
	`15`	`+`
`14`	`16`	`/// <summary>`
`15`	`17`	`/// Returns whether the given type has any discriminators registered for any of its subclasses.`
`16`	`18`	`/// </summary>`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,7 @@ public static TranslatedPipeline Translate(TranslationContext context, MethodCal`
`39`	`39`
`40`	`40`	`var sourceSerializer = pipeline.OutputSerializer;`
`41`	`41`	`var stageExpression = arguments[1];`
`42`		`- var renderedStage = TranslateStage(expression, stageExpression, sourceSerializer, context.SerializationDomain.SerializerRegistry, context.TranslationOptions);`
	`42`	`+ var renderedStage = TranslateStage(expression, stageExpression, sourceSerializer, context.SerializationDomain, context.TranslationOptions);`
`43`	`43`	`var stage = AstStage.Universal(renderedStage.Document);`
`44`	`44`
`45`	`45`	`var resultSerializerExpression = arguments[2];`
`@@ -57,11 +57,11 @@ private static IRenderedPipelineStageDefinition TranslateStage(`
`57`	`57`	`Expression expression,`
`58`	`58`	`Expression stageExpression,`
`59`	`59`	`IBsonSerializer inputSerializer,`
`60`		`- IBsonSerializerRegistry serializerRegistry,`
	`60`	`+ IBsonSerializationDomain serializationDomain,`
`61`	`61`	`ExpressionTranslationOptions translationOptions)`
`62`	`62`	`{`
`63`		`- var stageDefinition = stageExpression.GetConstantValue<IPipelineStageDefinition>(stageExpression);`
`64`		`- return stageDefinition.Render(inputSerializer, serializerRegistry, translationOptions);`
	`63`	`+ var stageDefinition = stageExpression.GetConstantValue<IPipelineStageStageDefinitionInternal>(stageExpression);`
	`64`	`+ return stageDefinition.Render(inputSerializer, serializationDomain, translationOptions);`
`65`	`65`	`}`
`66`	`66`	`}`
`67`	`67`	`}`
Original file line number	Diff line number	Diff line change
`@@ -474,11 +474,6 @@ public ReadPreference ReadPreference`
`474`	`474`	`}`
`475`	`475`	`}`
`476`	`476`
`477`		`- /// <summary>`
`478`		`- /// //TODO`
`479`		`- /// </summary>`
`480`		`- /// <exception cref="InvalidOperationException"></exception>`
`481`		`- /// <exception cref="ArgumentNullException"></exception>`
`482`	`477`	`IBsonSerializationDomain IInheritableMongoClientSettings.SerializationDomain`
`483`	`478`	`{`
`484`	`479`	`get => _serializationDomain;`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,7 @@`
`21`	`21`	`using MongoDB.Bson.Serialization.Serializers;`
`22`	`22`	`using MongoDB.Driver.Core.Misc;`
`23`	`23`	`using MongoDB.Driver.Linq;`
	`24`	`+using MongoDB.Driver.Support;`
`24`	`25`
`25`	`26`	`namespace MongoDB.Driver`
`26`	`27`	`{`
`@@ -329,7 +330,7 @@ public override RenderedPipelineDefinition<TOutput> Render(RenderArgs<TInput> ar`
`329`	`330`	`IBsonSerializer currentSerializer = args.DocumentSerializer;`
`330`	`331`	`foreach (var stage in _stages)`
`331`	`332`	`{`
`332`		`- var renderedStage = stage.Render(currentSerializer, args.SerializerRegistry, args.TranslationOptions);`
	`333`	`+ var renderedStage = stage.RenderInternal(currentSerializer, args.SerializationDomain, args.SerializerRegistry, args.TranslationOptions);`
`333`	`334`	`currentSerializer = renderedStage.OutputSerializer;`
`334`	`335`	`foreach (var document in renderedStage.Documents)`
`335`	`336`	`{`