CSHARP-1742: Added support for $replaceRoot aggregation stage.

Author: rstam

src/MongoDB.Driver/AggregateFluent.cs

@@ -197,6 +197,21 @@ public override IAggregateFluent<TNewResult> Project<TNewResult>(ProjectionDefin
             return AppendStage<TNewResult>(stage);
         }
 
+        public override IAggregateFluent<TNewResult> ReplaceRoot<TNewResult>(AggregateExpressionDefinition<TResult, TNewResult> newRoot)
+        {
+            const string operatorName = "$replaceRoot";
+            var stage = new DelegatedPipelineStageDefinition<TResult, TNewResult>(
+                operatorName,
+                (s, sr) =>
+                {
+                    var document = new BsonDocument(operatorName, new BsonDocument("newRoot", newRoot.Render(s, sr)));
+                    var outputSerializer = sr.GetSerializer<TNewResult>();
+                    return new RenderedPipelineStageDefinition<TNewResult>(operatorName, document, outputSerializer);
+                });
+
+            return AppendStage(stage);
+        }
+
         public override IAggregateFluent<TResult> Skip(int skip)
         {
             return AppendStage<TResult>(new BsonDocument("$skip", skip));

src/MongoDB.Driver/AggregateFluentBase.cs

@@ -76,6 +76,12 @@ public virtual IAsyncCursor<TResult> Out(string collectionName, CancellationToke
         /// <inheritdoc />
         public abstract IAggregateFluent<TNewResult> Project<TNewResult>(ProjectionDefinition<TResult, TNewResult> projection);
 
+        /// <inheritdoc />
+        public virtual IAggregateFluent<TNewResult> ReplaceRoot<TNewResult>(AggregateExpressionDefinition<TResult, TNewResult> newRoot)
+        {
+            throw new NotImplementedException();
+        }
+
         /// <inheritdoc />
         public abstract IAggregateFluent<TResult> Skip(int skip);
 

src/MongoDB.Driver/IAggregateFluent.cs

@@ -133,6 +133,14 @@ public interface IAggregateFluent<TResult> : IAsyncCursorSource<TResult>
         /// </returns>
         IAggregateFluent<TNewResult> Project<TNewResult>(ProjectionDefinition<TResult, TNewResult> projection);
 
+        /// <summary>
+        /// Appends a $replaceRoot stage to the pipeline.
+        /// </summary>
+        /// <typeparam name="TNewResult">The type of the new result.</typeparam>
+        /// <param name="newRoot">The new root.</param>
+        /// <returns>The fluent aggregate interface.</returns>
+        IAggregateFluent<TNewResult> ReplaceRoot<TNewResult>(AggregateExpressionDefinition<TResult, TNewResult> newRoot);
+
         /// <summary>
         /// Appends a skip stage to the pipeline.
         /// </summary>

src/MongoDB.Driver/IAggregateFluentExtensions.cs

@@ -191,6 +191,26 @@ public static IAggregateFluent<TNewResult> Project<TResult, TNewResult>(this IAg
             return aggregate.Project<TNewResult>(new ProjectExpressionProjection<TResult, TNewResult>(projection, aggregate.Options.TranslationOptions));
         }
 
+        /// <summary>
+        /// Appends a $replaceRoot stage to the pipeline.
+        /// </summary>
+        /// <typeparam name="TResult">The type of the result.</typeparam>
+        /// <typeparam name="TNewResult">The type of the new result.</typeparam>
+        /// <param name="aggregate">The aggregate.</param>
+        /// <param name="newRoot">The new root.</param>
+        /// <returns>
+        /// The fluent aggregate interface.
+        /// </returns>
+        public static IAggregateFluent<TNewResult> ReplaceRoot<TResult, TNewResult>(
+            this IAggregateFluent<TResult> aggregate,
+            Expression<Func<TResult, TNewResult>> newRoot)
+        {
+            Ensure.IsNotNull(aggregate, nameof(aggregate));
+            Ensure.IsNotNull(newRoot, nameof(newRoot));
+
+            return aggregate.ReplaceRoot<TNewResult>(new ExpressionAggregateExpressionDefinition<TResult, TNewResult>(newRoot, aggregate.Options.TranslationOptions));
+        }
+
         /// <summary>
         /// Appends an ascending sort stage to the pipeline.
         /// </summary>

tests/MongoDB.Driver.Tests/AggregateFluentTests.cs

@@ -240,6 +240,50 @@ public void Out_should_add_the_expected_stage_and_call_Aggregate(
             }
         }
 
+        [Theory]
+        [ParameterAttributeData]
+        public void ReplaceRoot_should_add_the_expected_stage(
+            [Values(false, true)]
+            bool async)
+        {
+            var subject = CreateSubject();
+
+            var result = subject
+                .ReplaceRoot<BsonDocument>("$X");
+
+            Predicate<PipelineDefinition<C, BsonDocument>> isExpectedPipeline = pipeline =>
+            {
+                var renderedPipeline = RenderPipeline(pipeline);
+                return
+                    renderedPipeline.Documents.Count == 1 &&
+                    renderedPipeline.Documents[0] == BsonDocument.Parse("{ $replaceRoot : { newRoot : '$X' } }") &&
+                    renderedPipeline.OutputSerializer.ValueType == typeof(BsonDocument);
+            };
+
+            if (async)
+            {
+                result.ToCursorAsync().GetAwaiter().GetResult();
+
+                _mockCollection.Verify(
+                    c => c.AggregateAsync<BsonDocument>(
+                        It.Is<PipelineDefinition<C, BsonDocument>>(pipeline => isExpectedPipeline(pipeline)),
+                        It.IsAny<AggregateOptions>(),
+                        CancellationToken.None),
+                    Times.Once);
+            }
+            else
+            {
+                result.ToCursor();
+
+                _mockCollection.Verify(
+                    c => c.Aggregate<BsonDocument>(
+                        It.Is<PipelineDefinition<C, BsonDocument>>(pipeline => isExpectedPipeline(pipeline)),
+                        It.IsAny<AggregateOptions>(),
+                        CancellationToken.None),
+                    Times.Once);
+            }
+        }
+
         [Theory]
         [ParameterAttributeData]
         public void SortByCount_should_add_the_expected_stage(

tests/MongoDB.Driver.Tests/IAggregateFluentExtensionsTests.cs

@@ -231,6 +231,28 @@ public void Project_should_generate_the_correct_document_using_expressions()
             AssertLast(subject, expectedProject);
         }
 
+        [Fact]
+        public void ReplaceRoot_should_generate_the_correct_stage()
+        {
+            var subject = CreateSubject()
+                .ReplaceRoot(x => x.PhoneNumber);
+
+            var expectedStage = BsonDocument.Parse("{ $replaceRoot : { newRoot:  '$PhoneNumber' } }");
+
+            AssertLast(subject, expectedStage);
+        }
+
+        [Fact]
+        public void ReplaceRoot_should_generate_the_correct_stage_with_anonymous_class()
+        {
+            var subject = CreateSubject()
+                .ReplaceRoot(x => new { Name = x.FirstName + " " + x.LastName });
+
+            var expectedStage = BsonDocument.Parse("{ $replaceRoot : { newRoot:  { Name : { $concat : [ '$FirstName', ' ', '$LastName' ] } } } }");
+
+            AssertLast(subject, expectedStage);
+        }
+
         [Theory]
         [ParameterAttributeData]
         public void Single_should_add_limit_and_call_ToCursor(
@@ -579,6 +601,13 @@ public class Person
             public string FirstName;
             public string LastName;
             public int Age;
+            public PhoneNumber PhoneNumber;
+        }
+
+        public class PhoneNumber
+        {
+            public int AreaCode;
+            public int Number;
         }
 
         public class NameMeaning