CSHARP-1743: Add support for $count stage to IAggregateFluent.

Author: rstam

src/MongoDB.Driver.Core/Core/Misc/Feature.cs

@@ -25,6 +25,7 @@ public class Feature
         #region static
         private static readonly Feature __aggregate = new Feature("Aggregate", new SemanticVersion(2, 2, 0));
         private static readonly Feature __aggregateAllowDiskUse = new Feature("AggregateAllowDiskUse", new SemanticVersion(2, 6, 0));
+        private static readonly Feature __aggregateCountStage = new Feature("AggregateCountStage", new SemanticVersion(3, 3, 11));
         private static readonly Feature __aggregateCursorResult = new Feature("AggregateCursorResult", new SemanticVersion(2, 6, 0));
         private static readonly Feature __aggregateExplain = new Feature("AggregateExplain", new SemanticVersion(2, 6, 0));
         private static readonly Feature __aggregateOut = new Feature("Aggregate", new SemanticVersion(2, 6, 0));
@@ -60,6 +61,11 @@ public class Feature
         /// </summary>
         public static Feature AggregateAllowDiskUse => __aggregateAllowDiskUse;
 
+        /// <summary>
+        /// Gets the aggregate count stage feature.
+        /// </summary>
+        public static Feature AggregateCountStage => __aggregateCountStage;
+
         /// <summary>
         /// Gets the aggregate cursor result feature.
         /// </summary>

src/MongoDB.Driver/AggregateCountResult.cs

@@ -0,0 +1,49 @@
+/* Copyright 2016 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;
+using MongoDB.Bson.Serialization.Attributes;
+
+namespace MongoDB.Driver
+{
+    /// <summary>
+    /// Default result type for the aggregate $count stage.
+    /// </summary>
+    public sealed class AggregateCountResult
+    {
+        private long _count;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AggregateCountResult"/> class.
+        /// </summary>
+        /// <param name="count">The count.</param>
+        public AggregateCountResult(long count)
+        {
+            _count = count;
+        }
+
+        /// <summary>
+        /// Gets the count.
+        /// </summary>
+        /// <value>
+        /// The count.
+        /// </value>
+        [BsonElement("count")]
+        public long Count
+        {
+            get { return _count; }
+        }
+    }
+}

src/MongoDB.Driver/AggregateFluent.cs

@@ -1,4 +1,4 @@
-/* Copyright 2010-2015 MongoDB Inc.
+/* Copyright 2010-2016 MongoDB Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -67,6 +67,22 @@ public override IAggregateFluent<TNewResult> As<TNewResult>(IBsonSerializer<TNew
             return Project(projection);
         }
 
+        public override IAggregateFluent<AggregateCountResult> Count()
+        {
+            const string operatorName = "$count";
+            var stage = new DelegatedPipelineStageDefinition<TResult, AggregateCountResult>(
+                operatorName,
+                (s, sr) =>
+                {
+                    return new RenderedPipelineStageDefinition<AggregateCountResult>(
+                        operatorName,
+                        new BsonDocument(operatorName, "count"),
+                        sr.GetSerializer<AggregateCountResult>());
+                });
+
+            return AppendStage<AggregateCountResult>(stage);
+        }
+
         public override IAggregateFluent<TNewResult> Group<TNewResult>(ProjectionDefinition<TResult, TNewResult> group)
         {
             const string operatorName = "$group";

src/MongoDB.Driver/AggregateFluentBase.cs

@@ -1,4 +1,4 @@
-/* Copyright 2010-2015 MongoDB Inc.
+/* Copyright 2010-2016 MongoDB Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -40,6 +40,12 @@ public abstract class AggregateFluentBase<TResult> : IOrderedAggregateFluent<TRe
         /// <inheritdoc />
         public abstract IAggregateFluent<TNewResult> As<TNewResult>(IBsonSerializer<TNewResult> newResultSerializer);
 
+        /// <inheritdoc />
+        public virtual IAggregateFluent<AggregateCountResult> Count()
+        {
+            throw new NotImplementedException();
+        }
+
         /// <inheritdoc />
         public abstract IAggregateFluent<TNewResult> Group<TNewResult>(ProjectionDefinition<TResult, TNewResult> group);
 

src/MongoDB.Driver/IAggregateFluent.cs

@@ -1,4 +1,4 @@
-/* Copyright 2010-2015 MongoDB Inc.
+/* Copyright 2010-2016 MongoDB Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
@@ -58,6 +58,12 @@ public interface IAggregateFluent<TResult> : IAsyncCursorSource<TResult>
         /// <returns>The fluent aggregate interface.</returns>
         IAggregateFluent<TNewResult> As<TNewResult>(IBsonSerializer<TNewResult> newResultSerializer = null);
 
+        /// <summary>
+        /// Appends a count stage to the pipeline.
+        /// </summary>
+        /// <returns>The fluent aggregate interface.</returns>
+        IAggregateFluent<AggregateCountResult> Count();
+
         /// <summary>
         /// Appends a group stage to the pipeline.
         /// </summary>

src/MongoDB.Driver/MongoDB.Driver.csproj

@@ -77,6 +77,7 @@
     <Compile Include="..\MongoDB.Shared\Hasher.cs">
       <Link>Support\Hasher.cs</Link>
     </Compile>
+    <Compile Include="AggregateCountResult.cs" />
     <Compile Include="AggregateFluent.cs" />
     <Compile Include="AggregateLookupOptions.cs" />
     <Compile Include="AggregateStringTranslationMode.cs" />

tests/MongoDB.Driver.Tests/AggregateFluentTests.cs

@@ -16,10 +16,13 @@
 using System;
 using System.Linq;
 using System.Threading;
+using FluentAssertions;
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
 using MongoDB.Bson.Serialization.Serializers;
 using MongoDB.Bson.TestHelpers.XunitExtensions;
+using MongoDB.Driver.Core.Misc;
+using MongoDB.Driver.Core.TestHelpers.XunitExtensions;
 using Moq;
 using Xunit;
 
@@ -70,7 +73,79 @@ public void As_should_add_the_expected_stage(
                         It.IsAny<AggregateOptions>(),
                         CancellationToken.None),
                     Times.Once);
-                }
+            }
+        }
+
+        [Theory]
+        [ParameterAttributeData]
+        public void Count_should_add_the_expected_stage(
+            [Values(false, true)]
+            bool async)
+        {
+            var subject = CreateSubject();
+
+            var result = subject.Count();
+
+            Predicate<PipelineDefinition<C, AggregateCountResult>> isExpectedPipeline = pipeline =>
+            {
+                var renderedPipeline = RenderPipeline(pipeline);
+                return
+                    renderedPipeline.Documents.Count == 1 &&
+                    renderedPipeline.Documents[0] == BsonDocument.Parse("{ $count : 'count' }") &&
+                    renderedPipeline.OutputSerializer.ValueType == typeof(AggregateCountResult);
+            };
+
+            if (async)
+            {
+                result.ToCursorAsync().GetAwaiter().GetResult();
+
+                _mockCollection.Verify(
+                    c => c.AggregateAsync<AggregateCountResult>(
+                        It.Is<PipelineDefinition<C, AggregateCountResult>>(pipeline => isExpectedPipeline(pipeline)),
+                        It.IsAny<AggregateOptions>(),
+                        CancellationToken.None),
+                    Times.Once);
+            }
+            else
+            {
+                result.ToCursor();
+
+                _mockCollection.Verify(
+                    c => c.Aggregate<AggregateCountResult>(
+                        It.Is<PipelineDefinition<C, AggregateCountResult>>(pipeline => isExpectedPipeline(pipeline)),
+                        It.IsAny<AggregateOptions>(),
+                        CancellationToken.None),
+                    Times.Once);
+            }
+        }
+
+        [SkippableTheory]
+        [ParameterAttributeData]
+        public void Count_should_return_the_expected_result(
+            [Values(false, true)]
+            bool async)
+        {
+            RequireServer.Check().Supports(Feature.AggregateCountStage);
+            var client = DriverTestConfiguration.Client;
+            var databaseNamespace = CoreTestConfiguration.DatabaseNamespace;
+            var collectionNamespace = CoreTestConfiguration.GetCollectionNamespaceForTestMethod();
+            var database = client.GetDatabase(databaseNamespace.DatabaseName);
+            database.DropCollection(collectionNamespace.CollectionName);
+            var collection = database.GetCollection<BsonDocument>(collectionNamespace.CollectionName);
+            collection.InsertOne(new BsonDocument());
+            var subject = collection.Aggregate();
+
+            long result;
+            if (async)
+            {
+                result = subject.Count().SingleAsync().GetAwaiter().GetResult().Count;
+            }
+            else
+            {
+                result = subject.Count().Single().Count;
+            }
+
+            result.Should().Be(1);
         }
 
         [Theory]