address pr comments

Author: adelinowona

src/MongoDB.Driver/Core/IAsyncCursor.cs

@@ -368,7 +368,7 @@ public static class IAsyncCursorExtensions
         /// <returns>An IAsyncEnumerable.</returns>
         public static IAsyncEnumerable<TDocument> ToAsyncEnumerable<TDocument>(this IAsyncCursor<TDocument> cursor)
         {
-            return new AsyncCursorEnumerableOneTimeAdapter<TDocument>(cursor);
+            return new AsyncCursorEnumerableOneTimeAdapter<TDocument>(cursor, CancellationToken.None);
         }
 
         /// <summary>

src/MongoDB.Driver/Core/IAsyncCursorSource.cs

@@ -337,14 +337,15 @@ public static class IAsyncCursorSourceExtensions
         }
 
         /// <summary>
-        /// Wraps a cursor source in an IAsyncEnumerable. Each time GetAsyncEnumerator is called a new cursor is fetched from the cursor source.
+        /// Wraps a cursor source in an IAsyncEnumerable. Each time GetAsyncEnumerator is called a new enumerator is returned and a new cursor
+        /// is fetched from the cursor source on the first call to MoveNextAsync.
         /// </summary>
         /// <typeparam name="TDocument">The type of the document.</typeparam>
         /// <param name="source">The source.</param>
         /// <returns>An IAsyncEnumerable.</returns>
         public static IAsyncEnumerable<TDocument> ToAsyncEnumerable<TDocument>(this IAsyncCursorSource<TDocument> source)
         {
-            return new AsyncCursorSourceEnumerableAdapter<TDocument>(source);
+            return new AsyncCursorSourceEnumerableAdapter<TDocument>(source, CancellationToken.None);
         }
 
         /// <summary>

src/MongoDB.Driver/Core/Operations/AsyncCursorEnumerableOneTimeAdapter.cs

@@ -27,11 +27,6 @@ internal sealed class AsyncCursorEnumerableOneTimeAdapter<TDocument> : IEnumerab
         private readonly IAsyncCursor<TDocument> _cursor;
         private bool _hasBeenEnumerated;
 
-        public AsyncCursorEnumerableOneTimeAdapter(IAsyncCursor<TDocument> cursor)
-            : this(cursor, CancellationToken.None)
-        {
-        }
-
         public AsyncCursorEnumerableOneTimeAdapter(IAsyncCursor<TDocument> cursor, CancellationToken cancellationToken)
         {
             _cursor = Ensure.IsNotNull(cursor, nameof(cursor));

src/MongoDB.Driver/Core/Operations/AsyncCursorEnumerator.cs

@@ -75,8 +75,11 @@ public void Dispose()
 
         public ValueTask DisposeAsync()
         {
+            // TODO: implement true async disposal (CSHARP-5630)
             Dispose();
-            return default;
+
+            // TODO: convert to ValueTask.CompletedTask once we stop supporting older target frameworks
+            return default; // Equivalent to ValueTask.CompletedTask which is not available on older target frameworks.
         }
 
         public bool MoveNext()

src/MongoDB.Driver/Core/Operations/AsyncCursorSourceEnumerableAdapter.cs

@@ -27,11 +27,6 @@ internal class AsyncCursorSourceEnumerableAdapter<TDocument> : IEnumerable<TDocu
         private readonly IAsyncCursorSource<TDocument> _source;
 
         // constructors
-        public AsyncCursorSourceEnumerableAdapter(IAsyncCursorSource<TDocument> source)
-            : this(source, CancellationToken.None)
-        {
-        }
-
         public AsyncCursorSourceEnumerableAdapter(IAsyncCursorSource<TDocument> source, CancellationToken cancellationToken)
         {
             _source = Ensure.IsNotNull(source, nameof(source));
@@ -40,8 +35,7 @@ public AsyncCursorSourceEnumerableAdapter(IAsyncCursorSource<TDocument> source,
 
         public IAsyncEnumerator<TDocument> GetAsyncEnumerator(CancellationToken cancellationToken = default)
         {
-            var cursor = _source.ToCursor(cancellationToken);
-            return new AsyncCursorEnumerator<TDocument>(cursor, cancellationToken);
+            return new AsyncCursorSourceEnumerator<TDocument>(_source, cancellationToken);
         }
 
         // public methods

src/MongoDB.Driver/Core/Operations/AsyncCursorSourceEnumerator.cs

@@ -0,0 +1,94 @@
+/* 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 System;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using MongoDB.Driver.Core.Misc;
+
+namespace MongoDB.Driver.Core.Operations
+{
+#pragma warning disable CA1001
+    internal class AsyncCursorSourceEnumerator<TDocument> : IAsyncEnumerator<TDocument>
+#pragma warning restore CA1001
+    {
+        private readonly CancellationToken _cancellationToken;
+        private AsyncCursorEnumerator<TDocument> _cursorEnumerator;
+        private readonly IAsyncCursorSource<TDocument> _cursorSource;
+        private bool _disposed;
+
+        public AsyncCursorSourceEnumerator(IAsyncCursorSource<TDocument> cursorSource, CancellationToken cancellationToken)
+        {
+            _cursorSource = Ensure.IsNotNull(cursorSource, nameof(cursorSource));
+            _cancellationToken = cancellationToken;
+        }
+
+        public TDocument Current
+        {
+            get
+            {
+                if (_cursorEnumerator == null)
+                {
+                    throw new InvalidOperationException("Enumeration has not started. Call MoveNextAsync.");
+                }
+                return _cursorEnumerator.Current;
+            }
+        }
+
+        public async ValueTask DisposeAsync()
+        {
+            if (!_disposed)
+            {
+                _disposed = true;
+
+                if (_cursorEnumerator != null)
+                {
+                    await _cursorEnumerator.DisposeAsync().ConfigureAwait(false);
+                }
+
+                GC.SuppressFinalize(this);
+            }
+        }
+
+        public async ValueTask<bool> MoveNextAsync()
+        {
+            ThrowIfDisposed();
+
+            if (_cursorEnumerator == null)
+            {
+                var cursor = await _cursorSource.ToCursorAsync(_cancellationToken).ConfigureAwait(false);
+                _cursorEnumerator = new AsyncCursorEnumerator<TDocument>(cursor, _cancellationToken);
+            }
+
+            return await _cursorEnumerator.MoveNextAsync().ConfigureAwait(false);
+        }
+
+        public void Reset()
+        {
+            ThrowIfDisposed();
+            throw new NotSupportedException();
+        }
+
+        // private methods
+        private void ThrowIfDisposed()
+        {
+            if (_disposed)
+            {
+                throw new ObjectDisposedException(GetType().Name);
+            }
+        }
+    }
+}

tests/MongoDB.Driver.Tests/Core/Operations/AsyncCursorEnumerableOneTimeAdapterTests.cs

@@ -15,6 +15,7 @@
 
 using System;
 using System.Threading;
+using System.Threading.Tasks;
 using FluentAssertions;
 using MongoDB.Bson;
 using Moq;
@@ -32,6 +33,37 @@ public void constructor_should_throw_when_cursor_is_null()
             action.ShouldThrow<ArgumentNullException>().And.ParamName.Should().Be("cursor");
         }
 
+        [Fact]
+        public async Task GetAsyncEnumerator_should_return_expected_result()
+        {
+            var mockCursor = new Mock<IAsyncCursor<BsonDocument>>();
+            mockCursor.SetupSequence(c => c.MoveNextAsync(CancellationToken.None)).ReturnsAsync(true).ReturnsAsync(false);
+            mockCursor.Setup(c => c.Current).Returns(new[] { new BsonDocument("_id", 0) });
+            var subject = new AsyncCursorEnumerableOneTimeAdapter<BsonDocument>(mockCursor.Object, CancellationToken.None);
+
+            var result = subject.GetAsyncEnumerator();
+
+            var result1 = await result.MoveNextAsync();
+            result1.Should().BeTrue();
+
+            result.Current.Should().Be(new BsonDocument("_id", 0));
+
+            var result2 = await result.MoveNextAsync();
+            result2.Should().BeFalse();
+        }
+
+        [Fact]
+        public void GetAsyncEnumerator_should_throw_when_called_more_than_once()
+        {
+            var mockCursor = new Mock<IAsyncCursor<BsonDocument>>();
+            var subject = new AsyncCursorEnumerableOneTimeAdapter<BsonDocument>(mockCursor.Object, CancellationToken.None);
+            subject.GetAsyncEnumerator();
+
+            Action action = () => subject.GetAsyncEnumerator();
+
+            action.ShouldThrow<InvalidOperationException>();
+        }
+
         [Fact]
         public void GetEnumerator_should_return_expected_result()
         {