CSHARP-4203: IFindFluentExtensions for Any and AnyAsync (#817)

Co-authored-by: Matthew DeJonge <[email protected]>

Author: mhdejonge

src/MongoDB.Driver/IFindFluentExtensions.cs

@@ -140,6 +140,38 @@ public static IOrderedFindFluent<TDocument, TProjection> ThenByDescending<TDocum
             return find;
         }
 
+        /// <summary>
+        /// Determine if there are any results.
+        /// </summary>
+        /// <typeparam name="TDocument">The type of the document.</typeparam>
+        /// <typeparam name="TProjection">The type of the projection (same as TDocument if there is no projection).</typeparam>
+        /// <param name="find">The fluent find.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>True if there is at least one document.</returns>
+        public static bool Any<TDocument, TProjection>(this IFindFluent<TDocument, TProjection> find, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            Ensure.IsNotNull(find, nameof(find));
+
+            var projection = new BsonDocumentProjectionDefinition<TDocument, BsonDocument>(new BsonDocument("_id", 1));
+            return IAsyncCursorSourceExtensions.Any(find.Project(projection).Limit(1), cancellationToken);
+        }
+
+        /// <summary>
+        /// Determine if there are any results.
+        /// </summary>
+        /// <typeparam name="TDocument">The type of the document.</typeparam>
+        /// <typeparam name="TProjection">The type of the projection (same as TDocument if there is no projection).</typeparam>
+        /// <param name="find">The fluent find.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        /// <returns>A Task whose result is true if there is at least one document.</returns>
+        public static Task<bool> AnyAsync<TDocument, TProjection>(this IFindFluent<TDocument, TProjection> find, CancellationToken cancellationToken = default(CancellationToken))
+        {
+            Ensure.IsNotNull(find, nameof(find));
+
+            var projection = new BsonDocumentProjectionDefinition<TDocument, BsonDocument>(new BsonDocument("_id", 1));
+            return IAsyncCursorSourceExtensions.AnyAsync(find.Project(projection).Limit(1), cancellationToken);
+        }
+
         /// <summary>
         /// Get the first result.
         /// </summary>

tests/MongoDB.Driver.Tests/IFindFluentExtensionsTests.cs

@@ -14,6 +14,7 @@
 */
 
 using System;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using FluentAssertions;
@@ -28,6 +29,64 @@ namespace MongoDB.Driver.Tests
     public class IFindFluentExtensionsTests
     {
         // public methods
+        [Theory]
+        [ParameterAttributeData]
+        public void Any_should_add_projection_and_limit_and_return_expected_result(
+            [Values(0, 1, 2)] int count,
+            [Values(false, true)] bool async)
+        {
+            var expectedResult = count > 0;
+
+            var mockSubject1 = new Mock<IFindFluent<Person, Person>>();
+            var mockSubject2 = new Mock<IFindFluent<Person, BsonDocument>>();
+            var mockSubject3 = new Mock<IFindFluent<Person, BsonDocument>>();
+            var mockCursor = new Mock<IAsyncCursor<BsonDocument>>();
+            var firstBatch = Enumerable.Range(0, count).Select(i => new BsonDocument("_id", i)).ToArray();
+            var cancellationToken = new CancellationTokenSource().Token;
+
+            mockSubject1.Setup(s => s.Project(It.Is<BsonDocumentProjectionDefinition<Person, BsonDocument>>(p => p.Document["_id"].AsInt32 == 1))).Returns(mockSubject2.Object);
+            mockSubject2.Setup(s => s.Limit(1)).Returns(mockSubject3.Object);
+            mockCursor.SetupGet(c => c.Current).Returns(firstBatch);
+
+            bool result;
+            if (async)
+            {
+                mockSubject3.Setup(s => s.ToCursorAsync(cancellationToken)).Returns(Task.FromResult(mockCursor.Object));
+                mockCursor.Setup(c => c.MoveNextAsync(cancellationToken)).Returns(Task.FromResult(true));
+
+                result = mockSubject1.Object.AnyAsync(cancellationToken).GetAwaiter().GetResult();
+            }
+            else
+            {
+                mockSubject3.Setup(s => s.ToCursor(cancellationToken)).Returns(mockCursor.Object);
+                mockCursor.Setup(c => c.MoveNext(cancellationToken)).Returns(true);
+
+                result = mockSubject1.Object.Any(cancellationToken);
+            }
+
+            result.Should().Be(expectedResult);
+        }
+
+        [Theory]
+        [ParameterAttributeData]
+        public void Any_should_throw_when_find_is_null(
+            [Values(false, true)] bool async)
+        {
+            IFindFluent<Person, Person> subject = null;
+
+            Action action;
+            if (async)
+            {
+                action = () => subject.AnyAsync().GetAwaiter().GetResult();
+            }
+            else
+            {
+                action = () => subject.Any();
+            }
+
+            action.ShouldThrow<ArgumentNullException>().And.ParamName.Should().Be("find");
+        }
+
         [Theory]
         [ParameterAttributeData]
         public void First_should_add_limit_and_call_ToCursor(