CSHARP-3021: GetMore commands are not sent with the namespace returned in the last batch

Author: MikalaiMazurenka

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

@@ -17,7 +17,6 @@
 using System.Threading;
 using System.Threading.Tasks;
 using MongoDB.Bson;
-using MongoDB.Bson.IO;
 using MongoDB.Bson.Serialization;
 using MongoDB.Bson.Serialization.Serializers;
 using MongoDB.Driver.Core.Bindings;
@@ -468,11 +467,13 @@ internal BsonDocument CreateCommand(ConnectionDescription connectionDescription,
         private AsyncCursor<TDocument> CreateCursor(IChannelSourceHandle channelSource, BsonDocument commandResult)
         {
             var getMoreChannelSource = new ServerChannelSource(channelSource.Server, channelSource.Session.Fork());
-            var firstBatch = CreateCursorBatch(commandResult);
+            var cursorDocument = commandResult["cursor"].AsBsonDocument;
+            var collectionNamespace = CollectionNamespace.FromFullName(cursorDocument["ns"].AsString);
+            var firstBatch = CreateFirstCursorBatch(cursorDocument);
 
             return new AsyncCursor<TDocument>(
                 getMoreChannelSource,
-                _collectionNamespace,
+                collectionNamespace,
                 _filter ?? new BsonDocument(),
                 firstBatch.Documents,
                 firstBatch.CursorId,
@@ -483,9 +484,8 @@ private AsyncCursor<TDocument> CreateCursor(IChannelSourceHandle channelSource,
                 _cursorType == CursorType.TailableAwait ? _maxAwaitTime : null);
         }
 
-        private CursorBatch<TDocument> CreateCursorBatch(BsonDocument commandResult)
+        private CursorBatch<TDocument> CreateFirstCursorBatch(BsonDocument cursorDocument)
         {
-            var cursorDocument = commandResult["cursor"].AsBsonDocument;
             var cursorId = cursorDocument["id"].ToInt64();
             var batch = (RawBsonArray)cursorDocument["firstBatch"];
 

tests/MongoDB.Bson.TestHelpers/Reflector.cs

@@ -70,6 +70,22 @@ public static object Invoke<T1>(object obj, string name, T1 arg1)
             }
         }
 
+        public static object Invoke<T1, T2>(object obj, string name, T1 arg1, T2 arg2)
+        {
+            var parameterTypes = new[] { typeof(T1), typeof(T2) };
+            var methodInfo = obj.GetType().GetMethods(BindingFlags.NonPublic | BindingFlags.Instance)
+                .Where(m => m.Name == name && m.GetParameters().Select(p => p.ParameterType).SequenceEqual(parameterTypes))
+                .Single();
+            try
+            {
+                return methodInfo.Invoke(obj, new object[] { arg1, arg2 });
+            }
+            catch (TargetInvocationException exception)
+            {
+                throw exception.InnerException;
+            }
+        }
+
         public static object Invoke<T1, T2>(object obj, string name, out T1 arg1, out T2 arg2)
         {
             arg1 = default;

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

@@ -16,14 +16,17 @@
 using System;
 using FluentAssertions;
 using MongoDB.Bson;
+using MongoDB.Bson.IO;
 using MongoDB.Bson.Serialization.Serializers;
+using MongoDB.Bson.TestHelpers;
 using MongoDB.Bson.TestHelpers.XunitExtensions;
 using MongoDB.Driver.Core.Bindings;
 using MongoDB.Driver.Core.Clusters;
 using MongoDB.Driver.Core.Misc;
 using MongoDB.Driver.Core.Servers;
 using MongoDB.Driver.Core.TestHelpers;
 using MongoDB.Driver.Core.TestHelpers.XunitExtensions;
+using Moq;
 using Xunit;
 
 namespace MongoDB.Driver.Core.Operations
@@ -773,6 +776,36 @@ public void CreateCommand_should_return_the_expected_result_when_using_causal_co
             result.Should().Be(expectedResult);
         }
 
+        [SkippableFact]
+        public void CreateCursor_should_use_ns_field_instead_of_namespace_passed_in_constructor()
+        {
+            var subject = new FindCommandOperation<BsonDocument>(_collectionNamespace, BsonDocumentSerializer.Instance, _messageEncoderSettings);
+            var firstBatchSlice = new ByteArrayBuffer(new byte[] { 5, 0, 0, 0, 0 }, isReadOnly: true);
+            var cursorCollectionNamespace = CollectionNamespace.FromFullName("cursors.lkajlkasdf-3980238d908sdf");
+            var cursorDocument = new BsonDocument
+            {
+                { "id", 0 },
+                { "firstBatch", new RawBsonArray(firstBatchSlice) },
+                { "ns", cursorCollectionNamespace.FullName }
+            };
+            var commandResult = new BsonDocument
+            {
+                { "ok", 1 },
+                { "cursor", cursorDocument }
+            };
+            var mockServer = new Mock<IServer>();
+            var mockSession = new Mock<ICoreSessionHandle>();
+            var mockSessionFork = new Mock<ICoreSessionHandle>();
+            mockSession.Setup(x => x.Fork()).Returns(mockSessionFork.Object);
+            var mockChannelSource = new Mock<IChannelSourceHandle>();
+            mockChannelSource.Setup(x => x.Server).Returns(mockServer.Object);
+            mockChannelSource.Setup(x => x.Session).Returns(mockSession.Object);
+
+            var cursor = subject.CreateCursor(mockChannelSource.Object, commandResult);
+
+            cursor._collectionNamespace().Should().Be(cursorCollectionNamespace);
+        }
+
         [Theory]
         [ParameterAttributeData]
         public void CursorType_get_and_set_should_work(
@@ -1306,4 +1339,15 @@ private void EnsureTestData()
             });
         }
     }
+
+    public static class FindCommandOperationReflector
+    {
+        public static AsyncCursor<BsonDocument> CreateCursor(
+            this FindCommandOperation<BsonDocument> obj,
+            IChannelSourceHandle channelSource,
+            BsonDocument commandResult)
+        {
+            return (AsyncCursor<BsonDocument>)Reflector.Invoke(obj, nameof(CreateCursor), channelSource, commandResult);
+        }
+    }
 }