CSHARP-1974: Fix Count with a predicate in aggregate group.

Author: DmitryLukyanov

src/MongoDB.Driver/Linq/Processors/AccumulatorBinder.cs

@@ -134,7 +134,7 @@ private bool TryGetAccumulatorTypeAndArgument(PipelineExpression node, out Accum
             if (resultOperator is CountResultOperator)
             {
                 accumulatorType = AccumulatorType.Sum;
-                argument = Expression.Constant(1);
+                argument = GetCountAccumulatorArgument(node.Source);
                 return true;
             }
             if (resultOperator is FirstResultOperator)
@@ -198,6 +198,29 @@ private bool TryGetAccumulatorTypeAndArgument(PipelineExpression node, out Accum
             return false;
         }
 
+        private Expression GetCountAccumulatorArgument(Expression node)
+        {
+            var where = node as WhereExpression;
+            if (where != null)
+            {
+                return Expression.IfThenElse(where.Predicate, Expression.Constant(1), Expression.Constant(0));
+            }
+
+            var document = node as DocumentExpression;
+            if (document != null)
+            {
+                return Expression.Constant(1);
+            }
+
+            var select = node as SelectExpression;
+            if (select != null)
+            {
+                return Expression.Constant(1);
+            }
+
+            throw new NotSupportedException();
+        }
+
         private Expression GetAccumulatorArgument(Expression node)
         {
             // we are looking for a Map
@@ -210,4 +233,4 @@ private Expression GetAccumulatorArgument(Expression node)
             throw new NotSupportedException();
         }
     }
-}
+}

tests/MongoDB.Driver.Tests/Linq/Translators/AggregateGroupTranslatorTests.cs

@@ -17,13 +17,9 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Linq.Expressions;
-using System.Threading.Tasks;
 using FluentAssertions;
 using MongoDB.Bson;
 using MongoDB.Bson.Serialization;
-using MongoDB.Bson.TestHelpers.XunitExtensions;
-using MongoDB.Driver;
-using MongoDB.Driver.Core;
 using MongoDB.Driver.Core.TestHelpers.XunitExtensions;
 using MongoDB.Driver.Linq;
 using MongoDB.Driver.Linq.Translators;
@@ -125,6 +121,46 @@ public void Should_translate_count()
             result.Value.Result.Should().Be(1);
         }
 
+        [Fact]
+        public void Should_translate_count_with_a_predicate()
+        {
+            var result = Group(x => x.A, g => new { Result = g.Count(x => x.A != "Awesome") });
+
+            result.Projection.Should().Be("{ \"_id\" : \"$A\", \"Result\" : { \"$sum\" : { \"$cond\" : [{ \"$ne\" : [\"$A\", \"Awesome\"] }, 1, 0] } } }");
+
+            result.Value.Result.Should().Be(1);
+        }
+
+        [Fact]
+        public void Should_translate_where_with_a_predicate_and_count()
+        {
+            var result = Group(x => x.A, g => new { Result = g.Where(x => x.A != "Awesome").Count() });
+
+            result.Projection.Should().Be("{ \"_id\" : \"$A\", \"Result\" : { \"$sum\" : { \"$cond\" : [{ \"$ne\" : [\"$A\", \"Awesome\"] }, 1, 0] } } }");
+
+            result.Value.Result.Should().Be(1);
+        }
+
+        [Fact]
+        public void Should_translate_where_select_and_count_with_predicates()
+        {
+            var result = Group(x => x.A, g => new { Result = g.Select(x => new { A = x.A }).Count(x => x.A != "Awesome") });
+
+            result.Projection.Should().Be("{ \"_id\" : \"$A\", \"Result\" : { \"$sum\" : { \"$cond\" : [{ \"$ne\" : [\"$A\", \"Awesome\"] }, 1, 0] } } }");
+
+            result.Value.Result.Should().Be(1);
+        }
+
+        [Fact]
+        public void Should_translate_where_select_with_predicate_and_count()
+        {
+            var result = Group(x => x.A, g => new { Result = g.Select(x => new { A = x.A }).Count() });
+
+            result.Projection.Should().Be("{ \"_id\" : \"$A\", \"Result\" : { \"$sum\" : 1 } }");
+
+            result.Value.Result.Should().Be(1);
+        }
+
         [Fact]
         public void Should_translate_long_count()
         {
@@ -394,4 +430,4 @@ private class ProjectedResult<T>
             public T Value;
         }
     }
-}
+}