SERVER-39796 Remove oplog name parameter from OplogInterfaceLocal. Remove uses of OplogInterfaceLocal for non-oplog documents

14 files changed, 110 insertions, 102 deletions

diff --git a/src/mongo/db/op_observer_impl_test.cpp b/src/mongo/db/op_observer_impl_test.cpp
index 40adb8c515b..f31f81d9463 100644
--- a/src/mongo/db/op_observer_impl_test.cpp
+++ b/src/mongo/db/op_observer_impl_test.cpp
@@ -84,7 +84,7 @@ protected:
     // Assert that the oplog has the expected number of entries, and return them
     std::vector<BSONObj> getNOplogEntries(OperationContext* opCtx, int n) {
         std::vector<BSONObj> result(n);
-        repl::OplogInterfaceLocal oplogInterface(opCtx, NamespaceString::kRsOplogNamespace.ns());
+        repl::OplogInterfaceLocal oplogInterface(opCtx);
         auto oplogIter = oplogInterface.makeIterator();
         for (int i = n - 1; i >= 0; i--) {
             // The oplogIterator returns the entries in reverse order.
@@ -854,7 +854,7 @@ TEST_F(OpObserverTransactionTest, TransactionalPreparedCommitTest) {
         prepareTimestamp,
         txnParticipant.retrieveCompletedTransactionOperations(opCtx()));
 
-    repl::OplogInterfaceLocal oplogInterface(opCtx(), NamespaceString::kRsOplogNamespace.ns());
+    repl::OplogInterfaceLocal oplogInterface(opCtx());
     auto oplogIter = oplogInterface.makeIterator();
     {
         auto oplogEntryObj = unittest::assertGet(oplogIter->next()).first;
@@ -919,7 +919,7 @@ TEST_F(OpObserverTransactionTest, TransactionalPreparedAbortTest) {
     opObserver().onTransactionAbort(opCtx(), abortSlot);
     txnParticipant.transitionToAbortedWithPrepareforTest(opCtx());
 
-    repl::OplogInterfaceLocal oplogInterface(opCtx(), NamespaceString::kRsOplogNamespace.ns());
+    repl::OplogInterfaceLocal oplogInterface(opCtx());
     auto oplogIter = oplogInterface.makeIterator();
     {
         auto oplogEntryObj = unittest::assertGet(oplogIter->next()).first;
@@ -974,7 +974,7 @@ TEST_F(OpObserverTransactionTest, TransactionalUnpreparedAbortTest) {
     }
 
     // Assert no oplog entries were written.
-    repl::OplogInterfaceLocal oplogInterface(opCtx(), NamespaceString::kRsOplogNamespace.ns());
+    repl::OplogInterfaceLocal oplogInterface(opCtx());
     auto oplogIter = oplogInterface.makeIterator();
     ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, oplogIter->next().getStatus());
 }
diff --git a/src/mongo/db/repl/SConscript b/src/mongo/db/repl/SConscript
index d71c9bfb33c..e4a39ceeddc 100644
--- a/src/mongo/db/repl/SConscript
+++ b/src/mongo/db/repl/SConscript
@@ -298,6 +298,7 @@ env.CppUnitTest(
         'oplog_interface_local',
         'replmocks',
         'storage_interface_impl',
+        'sync_tail_test_fixture',
         '$BUILD_DIR/mongo/db/auth/authmocks',
         '$BUILD_DIR/mongo/db/service_context_d_test_fixture',
     ],
@@ -367,6 +368,7 @@ env.CppUnitTest(
         'replication_recovery',
         'replmocks',
         'storage_interface_impl',
+        'sync_tail_test_fixture',
         '$BUILD_DIR/mongo/db/auth/authmocks',
         '$BUILD_DIR/mongo/db/op_observer',
         '$BUILD_DIR/mongo/db/service_context_d_test_fixture',
@@ -486,6 +488,7 @@ env.CppUnitTest(
         'oplog_interface_local',
         'replmocks',
         'storage_interface_impl',
+        'sync_tail_test_fixture',
         '$BUILD_DIR/mongo/db/auth/authmocks',
         '$BUILD_DIR/mongo/db/service_context_d_test_fixture',
     ],
diff --git a/src/mongo/db/repl/bgsync.cpp b/src/mongo/db/repl/bgsync.cpp
index 28c50c11e82..5b5b85c6af5 100644
--- a/src/mongo/db/repl/bgsync.cpp
+++ b/src/mongo/db/repl/bgsync.cpp
@@ -580,7 +580,7 @@ void BackgroundSync::_runRollback(OperationContext* opCtx,
         }
     }
 
-    OplogInterfaceLocal localOplog(opCtx, NamespaceString::kRsOplogNamespace.ns());
+    OplogInterfaceLocal localOplog(opCtx);
 
     const int messagingPortTags = 0;
     ConnectionPool connectionPool(messagingPortTags);
diff --git a/src/mongo/db/repl/do_txn_test.cpp b/src/mongo/db/repl/do_txn_test.cpp
index 97174546e31..810e7401da3 100644
--- a/src/mongo/db/repl/do_txn_test.cpp
+++ b/src/mongo/db/repl/do_txn_test.cpp
@@ -53,7 +53,7 @@ namespace repl {
 namespace {
 
 boost::optional<OplogEntry> onAllTransactionCommit(OperationContext* opCtx) {
-    OplogInterfaceLocal oplogInterface(opCtx, NamespaceString::kRsOplogNamespace.ns());
+    OplogInterfaceLocal oplogInterface(opCtx);
     auto oplogIter = oplogInterface.makeIterator();
     auto opEntry = unittest::assertGet(oplogIter->next());
     return unittest::assertGet(OplogEntry::parse(opEntry.first));
diff --git a/src/mongo/db/repl/oplog_buffer_collection_test.cpp b/src/mongo/db/repl/oplog_buffer_collection_test.cpp
index 446081c7a6d..0d544104fc6 100644
--- a/src/mongo/db/repl/oplog_buffer_collection_test.cpp
+++ b/src/mongo/db/repl/oplog_buffer_collection_test.cpp
@@ -41,6 +41,7 @@
 #include "mongo/db/repl/replication_coordinator_mock.h"
 #include "mongo/db/repl/storage_interface.h"
 #include "mongo/db/repl/storage_interface_impl.h"
+#include "mongo/db/repl/sync_tail_test_fixture.h"
 #include "mongo/db/service_context_d_test_fixture.h"
 #include "mongo/stdx/memory.h"
 #include "mongo/unittest/barrier.h"
@@ -237,12 +238,12 @@ DEATH_TEST_F(OplogBufferCollectionTest,
 }
 
 /**
- * Check collection contents. OplogInterface returns documents in reverse natural order.
+ * Check collection contents.
  */
 void _assertDocumentsInCollectionEquals(OperationContext* opCtx,
                                         const NamespaceString& nss,
                                         const std::vector<BSONObj>& docs) {
-    std::vector<BSONObj> reversedTransformedDocs;
+    std::vector<BSONObj> transformedDocs;
     Timestamp ts;
     std::size_t sentinelCount = 0;
     for (const auto& doc : docs) {
@@ -250,20 +251,18 @@ void _assertDocumentsInCollectionEquals(OperationContext* opCtx,
         BSONObj newDoc;
         std::tie(newDoc, ts, sentinelCount) =
             OplogBufferCollection::addIdToDocument(doc, ts, sentinelCount);
-        reversedTransformedDocs.push_back(newDoc);
+        transformedDocs.push_back(newDoc);
         if (doc.isEmpty()) {
             ASSERT_EQUALS(previousTimestamp, ts);
             continue;
         }
         ASSERT_GT(ts, previousTimestamp);
     }
-    std::reverse(reversedTransformedDocs.begin(), reversedTransformedDocs.end());
-    OplogInterfaceLocal oplog(opCtx, nss.ns());
-    auto iter = oplog.makeIterator();
-    for (const auto& doc : reversedTransformedDocs) {
-        ASSERT_BSONOBJ_EQ(doc, unittest::assertGet(iter->next()).first);
+    CollectionReader reader(opCtx, nss);
+    for (const auto& doc : transformedDocs) {
+        ASSERT_BSONOBJ_EQ(doc, unittest::assertGet(reader.next()));
     }
-    ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, iter->next().getStatus());
+    ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, reader.next().getStatus());
 }
 
 TEST_F(OplogBufferCollectionTest, StartupWithExistingCollectionInitializesCorrectly) {
diff --git a/src/mongo/db/repl/oplog_interface_local.cpp b/src/mongo/db/repl/oplog_interface_local.cpp
index cc6c4ac6e20..b44baf7d1c8 100644
--- a/src/mongo/db/repl/oplog_interface_local.cpp
+++ b/src/mongo/db/repl/oplog_interface_local.cpp
@@ -45,7 +45,7 @@ namespace {
 
 class OplogIteratorLocal : public OplogInterface::Iterator {
 public:
-    OplogIteratorLocal(OperationContext* opCtx, const std::string& collectionName);
+    OplogIteratorLocal(OperationContext* opCtx);
 
     StatusWith<Value> next() override;
 
@@ -56,15 +56,16 @@ private:
     std::unique_ptr<PlanExecutor, PlanExecutor::Deleter> _exec;
 };
 
-OplogIteratorLocal::OplogIteratorLocal(OperationContext* opCtx, const std::string& collectionName)
-    : _dbLock(opCtx, nsToDatabase(collectionName), MODE_IS),
-      _collectionLock(opCtx, NamespaceString(collectionName), MODE_S),
-      _ctx(opCtx, collectionName),
-      _exec(InternalPlanner::collectionScan(opCtx,
-                                            collectionName,
-                                            _ctx.db()->getCollection(opCtx, collectionName),
-                                            PlanExecutor::NO_YIELD,
-                                            InternalPlanner::BACKWARD)) {}
+OplogIteratorLocal::OplogIteratorLocal(OperationContext* opCtx)
+    : _dbLock(opCtx, NamespaceString::kRsOplogNamespace.db(), MODE_IS),
+      _collectionLock(opCtx, NamespaceString::kRsOplogNamespace, MODE_S),
+      _ctx(opCtx, NamespaceString::kRsOplogNamespace.ns()),
+      _exec(InternalPlanner::collectionScan(
+          opCtx,
+          NamespaceString::kRsOplogNamespace.ns(),
+          _ctx.db()->getCollection(opCtx, NamespaceString::kRsOplogNamespace),
+          PlanExecutor::NO_YIELD,
+          InternalPlanner::BACKWARD)) {}
 
 StatusWith<OplogInterface::Iterator::Value> OplogIteratorLocal::next() {
     BSONObj obj;
@@ -84,21 +85,19 @@ StatusWith<OplogInterface::Iterator::Value> OplogIteratorLocal::next() {
 
 }  // namespace
 
-OplogInterfaceLocal::OplogInterfaceLocal(OperationContext* opCtx, const std::string& collectionName)
-    : _opCtx(opCtx), _collectionName(collectionName) {
+OplogInterfaceLocal::OplogInterfaceLocal(OperationContext* opCtx) : _opCtx(opCtx) {
     invariant(opCtx);
-    invariant(!collectionName.empty());
 }
 
 std::string OplogInterfaceLocal::toString() const {
     return str::stream() << "LocalOplogInterface: "
                             "operation context: "
-                         << _opCtx->getOpID() << "; collection: " << _collectionName;
+                         << _opCtx->getOpID()
+                         << "; collection: " << NamespaceString::kRsOplogNamespace;
 }
 
 std::unique_ptr<OplogInterface::Iterator> OplogInterfaceLocal::makeIterator() const {
-    return std::unique_ptr<OplogInterface::Iterator>(
-        new OplogIteratorLocal(_opCtx, _collectionName));
+    return std::unique_ptr<OplogInterface::Iterator>(new OplogIteratorLocal(_opCtx));
 }
 
 HostAndPort OplogInterfaceLocal::hostAndPort() const {
diff --git a/src/mongo/db/repl/oplog_interface_local.h b/src/mongo/db/repl/oplog_interface_local.h
index 16cd07b8b6e..a7b7134a36f 100644
--- a/src/mongo/db/repl/oplog_interface_local.h
+++ b/src/mongo/db/repl/oplog_interface_local.h
@@ -43,14 +43,13 @@ namespace repl {
 
 class OplogInterfaceLocal : public OplogInterface {
 public:
-    OplogInterfaceLocal(OperationContext* opCtx, const std::string& collectionName);
+    OplogInterfaceLocal(OperationContext* opCtx);
     std::string toString() const override;
     std::unique_ptr<OplogInterface::Iterator> makeIterator() const override;
     HostAndPort hostAndPort() const override;
 
 private:
     OperationContext* _opCtx;
-    std::string _collectionName;
 };
 
 }  // namespace repl
diff --git a/src/mongo/db/repl/oplog_test.cpp b/src/mongo/db/repl/oplog_test.cpp
index 76fd17eaa5c..ac154664492 100644
--- a/src/mongo/db/repl/oplog_test.cpp
+++ b/src/mongo/db/repl/oplog_test.cpp
@@ -80,7 +80,7 @@ void OplogTest::setUp() {
  * Assert that oplog only has a single entry and return that oplog entry.
  */
 OplogEntry _getSingleOplogEntry(OperationContext* opCtx) {
-    OplogInterfaceLocal oplogInterface(opCtx, NamespaceString::kRsOplogNamespace.ns());
+    OplogInterfaceLocal oplogInterface(opCtx);
     auto oplogIter = oplogInterface.makeIterator();
     auto opEntry = unittest::assertGet(oplogIter->next());
     ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, oplogIter->next().getStatus())
@@ -194,7 +194,7 @@ void _testConcurrentLogOp(const F& makeTaskFunction,
     // Read oplog entries from the oplog collection starting with the entry with the most recent
     // optime.
     auto opCtx = cc().makeOperationContext();
-    OplogInterfaceLocal oplogInterface(opCtx.get(), NamespaceString::kRsOplogNamespace.ns());
+    OplogInterfaceLocal oplogInterface(opCtx.get());
     auto oplogIter = oplogInterface.makeIterator();
     auto nextValue = oplogIter->next();
     while (nextValue.isOK()) {
diff --git a/src/mongo/db/repl/replication_recovery_test.cpp b/src/mongo/db/repl/replication_recovery_test.cpp
index 48729331783..b6009099e7a 100644
--- a/src/mongo/db/repl/replication_recovery_test.cpp
+++ b/src/mongo/db/repl/replication_recovery_test.cpp
@@ -42,6 +42,7 @@
 #include "mongo/db/repl/replication_coordinator_mock.h"
 #include "mongo/db/repl/replication_recovery.h"
 #include "mongo/db/repl/storage_interface_impl.h"
+#include "mongo/db/repl/sync_tail_test_fixture.h"
 #include "mongo/db/service_context_d_test_fixture.h"
 #include "mongo/db/session_catalog_mongod.h"
 #include "mongo/db/session_txn_record_gen.h"
@@ -335,14 +336,11 @@ void _setUpOplog(OperationContext* opCtx, StorageInterface* storage, std::vector
 void _assertDocumentsInCollectionEquals(OperationContext* opCtx,
                                         const NamespaceString& nss,
                                         const std::vector<BSONObj>& docs) {
-    std::vector<BSONObj> reversedDocs(docs);
-    std::reverse(reversedDocs.begin(), reversedDocs.end());
-    OplogInterfaceLocal oplog(opCtx, nss.ns());
-    auto iter = oplog.makeIterator();
-    for (const auto& doc : reversedDocs) {
-        ASSERT_BSONOBJ_EQ(doc, unittest::assertGet(iter->next()).first);
+    CollectionReader reader(opCtx, nss);
+    for (const auto& doc : docs) {
+        ASSERT_BSONOBJ_EQ(doc, unittest::assertGet(reader.next()));
     }
-    ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, iter->next().getStatus());
+    ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, reader.next().getStatus());
 }
 
 /**
diff --git a/src/mongo/db/repl/rollback_impl_test.cpp b/src/mongo/db/repl/rollback_impl_test.cpp
index 591b5f7a65e..042286025c3 100644
--- a/src/mongo/db/repl/rollback_impl_test.cpp
+++ b/src/mongo/db/repl/rollback_impl_test.cpp
@@ -283,8 +283,7 @@ private:
 void RollbackImplTest::setUp() {
     RollbackTest::setUp();
 
-    _localOplog = stdx::make_unique<OplogInterfaceLocal>(_opCtx.get(),
-                                                         NamespaceString::kRsOplogNamespace.ns());
+    _localOplog = stdx::make_unique<OplogInterfaceLocal>(_opCtx.get());
     _remoteOplog = stdx::make_unique<OplogInterfaceMock>();
     _listener = stdx::make_unique<Listener>(this);
     _rollback = stdx::make_unique<RollbackImplForTest>(_localOplog.get(),
@@ -405,7 +404,7 @@ void _assertDocsInOplog(OperationContext* opCtx, std::vector<int> timestamps) {
         return makeOp(ts);
     });
 
-    OplogInterfaceLocal oplog(opCtx, NamespaceString::kRsOplogNamespace.ns());
+    OplogInterfaceLocal oplog(opCtx);
     auto iter = oplog.makeIterator();
     for (auto reverseIt = expectedOplog.rbegin(); reverseIt != expectedOplog.rend(); reverseIt++) {
         auto expectedTime = unittest::assertGet(OpTime::parseFromOplogEntry(*reverseIt));
diff --git a/src/mongo/db/repl/storage_interface_impl_test.cpp b/src/mongo/db/repl/storage_interface_impl_test.cpp
index fe673000166..b2c58004a5c 100644
--- a/src/mongo/db/repl/storage_interface_impl_test.cpp
+++ b/src/mongo/db/repl/storage_interface_impl_test.cpp
@@ -48,9 +48,9 @@
 #include "mongo/db/namespace_string.h"
 #include "mongo/db/operation_context.h"
 #include "mongo/db/repl/oplog.h"
-#include "mongo/db/repl/oplog_interface_local.h"
 #include "mongo/db/repl/replication_coordinator_mock.h"
 #include "mongo/db/repl/storage_interface_impl.h"
+#include "mongo/db/repl/sync_tail_test_fixture.h"
 #include "mongo/db/service_context_d_test_fixture.h"
 #include "mongo/stdx/memory.h"
 #include "mongo/stdx/thread.h"
@@ -269,32 +269,26 @@ TEST_F(StorageInterfaceImplTest,
 }
 
 /**
- * Check collection contents. OplogInterface returns documents in reverse natural order.
+ * Check collection contents.
  */
 void _assertDocumentsInCollectionEquals(OperationContext* opCtx,
                                         const NamespaceString& nss,
                                         const std::vector<BSONObj>& docs) {
-    std::vector<BSONObj> reversedDocs(docs);
-    std::reverse(reversedDocs.begin(), reversedDocs.end());
-    OplogInterfaceLocal oplog(opCtx, nss.ns());
-    auto iter = oplog.makeIterator();
-    for (const auto& doc : reversedDocs) {
-        ASSERT_BSONOBJ_EQ(doc, unittest::assertGet(iter->next()).first);
+    CollectionReader reader(opCtx, nss);
+    for (const auto& doc : docs) {
+        ASSERT_BSONOBJ_EQ(doc, unittest::assertGet(reader.next()));
     }
-    ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, iter->next().getStatus());
+    ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, reader.next().getStatus());
 }
 
 void _assertDocumentsInCollectionEquals(OperationContext* opCtx,
                                         const NamespaceString& nss,
                                         const std::vector<TimestampedBSONObj>& docs) {
-    std::vector<TimestampedBSONObj> reversedDocs(docs);
-    std::reverse(reversedDocs.begin(), reversedDocs.end());
-    OplogInterfaceLocal oplog(opCtx, nss.ns());
-    auto iter = oplog.makeIterator();
-    for (const auto& doc : reversedDocs) {
-        ASSERT_BSONOBJ_EQ(doc.obj, unittest::assertGet(iter->next()).first);
+    CollectionReader reader(opCtx, nss);
+    for (const auto& doc : docs) {
+        ASSERT_BSONOBJ_EQ(doc.obj, unittest::assertGet(reader.next()));
     }
-    ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, iter->next().getStatus());
+    ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, reader.next().getStatus());
 }
 
 /**
@@ -456,12 +450,8 @@ TEST_F(StorageInterfaceImplTest,
     }
     ASSERT_OK(storage.insertDocuments(opCtx, nss, docs));
 
-    // Check collection contents. OplogInterface returns documents in reverse natural order.
-    OplogInterfaceLocal oplog(opCtx, nss.ns());
-    auto iter = oplog.makeIterator();
-    ASSERT_BSONOBJ_EQ(doc2.doc, unittest::assertGet(iter->next()).first);
-    ASSERT_BSONOBJ_EQ(doc1.doc, unittest::assertGet(iter->next()).first);
-    ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, iter->next().getStatus());
+    // Check collection contents.
+    _assertDocumentsInCollectionEquals(opCtx, nss, {doc1.doc, doc2.doc});
 }
 
 TEST_F(StorageInterfaceImplTest, InsertDocumentsSavesOperationsReturnsOpTimeOfLastOperation) {
@@ -477,12 +467,8 @@ TEST_F(StorageInterfaceImplTest, InsertDocumentsSavesOperationsReturnsOpTimeOfLa
     auto op2 = makeOplogEntry({Timestamp(Seconds(1), 0), 1LL});
     ASSERT_OK(storage.insertDocuments(opCtx, nss, transformInserts({op1, op2})));
 
-    // Check contents of oplog. OplogInterface iterates over oplog collection in reverse.
-    repl::OplogInterfaceLocal oplog(opCtx, nss.ns());
-    auto iter = oplog.makeIterator();
-    ASSERT_BSONOBJ_EQ(op2.obj, unittest::assertGet(iter->next()).first);
-    ASSERT_BSONOBJ_EQ(op1.obj, unittest::assertGet(iter->next()).first);
-    ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, iter->next().getStatus());
+    // Check contents of oplog.
+    _assertDocumentsInCollectionEquals(opCtx, nss, {op1.obj, op2.obj});
 }
 
 TEST_F(StorageInterfaceImplTest, InsertDocumentsSavesOperationsWhenCollSpecifiedWithUUID) {
@@ -501,12 +487,8 @@ TEST_F(StorageInterfaceImplTest, InsertDocumentsSavesOperationsWhenCollSpecified
     ASSERT_OK(storage.insertDocuments(
         opCtx, {nss.db().toString(), *options.uuid}, transformInserts({op1, op2})));
 
-    // Check contents of oplog. OplogInterface iterates over oplog collection in reverse.
-    repl::OplogInterfaceLocal oplog(opCtx, nss.ns());
-    auto iter = oplog.makeIterator();
-    ASSERT_BSONOBJ_EQ(op2.obj, unittest::assertGet(iter->next()).first);
-    ASSERT_BSONOBJ_EQ(op1.obj, unittest::assertGet(iter->next()).first);
-    ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, iter->next().getStatus());
+    // Check contents of oplog.
+    _assertDocumentsInCollectionEquals(opCtx, nss, {op1.obj, op2.obj});
 }
 
 TEST_F(StorageInterfaceImplTest,
@@ -1287,13 +1269,9 @@ TEST_F(StorageInterfaceImplTest,
                                               BoundInclusion::kIncludeStartKeyOnly,
                                               1U)));
 
-    // Check collection contents. OplogInterface returns documents in reverse natural order.
-    OplogInterfaceLocal oplog(opCtx, nss.ns());
-    auto iter = oplog.makeIterator();
-    ASSERT_BSONOBJ_EQ(BSON("_id" << 0), unittest::assertGet(iter->next()).first);
-    ASSERT_BSONOBJ_EQ(BSON("_id" << 2), unittest::assertGet(iter->next()).first);
-    ASSERT_BSONOBJ_EQ(BSON("_id" << 1), unittest::assertGet(iter->next()).first);
-    ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, iter->next().getStatus());
+    // Check collection contents.
+    _assertDocumentsInCollectionEquals(
+        opCtx, nss, {BSON("_id" << 1), BSON("_id" << 2), BSON("_id" << 0)});
 }
 
 TEST_F(StorageInterfaceImplTest,
diff --git a/src/mongo/db/repl/sync_tail_test.cpp b/src/mongo/db/repl/sync_tail_test.cpp
index ec850c4a921..c31d582be01 100644
--- a/src/mongo/db/repl/sync_tail_test.cpp
+++ b/src/mongo/db/repl/sync_tail_test.cpp
@@ -57,7 +57,6 @@
 #include "mongo/db/repl/idempotency_test_fixture.h"
 #include "mongo/db/repl/oplog.h"
 #include "mongo/db/repl/oplog_buffer_blocking_queue.h"
-#include "mongo/db/repl/oplog_interface_local.h"
 #include "mongo/db/repl/replication_coordinator.h"
 #include "mongo/db/repl/replication_coordinator_mock.h"
 #include "mongo/db/repl/replication_process.h"
@@ -1723,11 +1722,10 @@ TEST_F(SyncTailTest, MultiSyncApplySkipsDocumentOnNamespaceNotFoundDuringInitial
     ASSERT_OK(multiSyncApply(_opCtx.get(), &ops, &syncTail, &pathInfo));
     ASSERT_EQUALS(syncTail.numFetched, 0U);
 
-    OplogInterfaceLocal collectionReader(_opCtx.get(), nss.ns());
-    auto iter = collectionReader.makeIterator();
-    ASSERT_BSONOBJ_EQ(doc3, unittest::assertGet(iter->next()).first);
-    ASSERT_BSONOBJ_EQ(doc1, unittest::assertGet(iter->next()).first);
-    ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, iter->next().getStatus());
+    CollectionReader collectionReader(_opCtx.get(), nss);
+    ASSERT_BSONOBJ_EQ(doc1, unittest::assertGet(collectionReader.next()));
+    ASSERT_BSONOBJ_EQ(doc3, unittest::assertGet(collectionReader.next()));
+    ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, collectionReader.next().getStatus());
 }
 
 TEST_F(SyncTailTest, MultiSyncApplySkipsIndexCreationOnNamespaceNotFoundDuringInitialSync) {
@@ -1749,11 +1747,10 @@ TEST_F(SyncTailTest, MultiSyncApplySkipsIndexCreationOnNamespaceNotFoundDuringIn
     ASSERT_OK(multiSyncApply(_opCtx.get(), &ops, &syncTail, &pathInfo));
     ASSERT_EQUALS(syncTail.numFetched, 0U);
 
-    OplogInterfaceLocal collectionReader(_opCtx.get(), nss.ns());
-    auto iter = collectionReader.makeIterator();
-    ASSERT_BSONOBJ_EQ(doc3, unittest::assertGet(iter->next()).first);
-    ASSERT_BSONOBJ_EQ(doc1, unittest::assertGet(iter->next()).first);
-    ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, iter->next().getStatus());
+    CollectionReader collectionReader(_opCtx.get(), nss);
+    ASSERT_BSONOBJ_EQ(doc1, unittest::assertGet(collectionReader.next()));
+    ASSERT_BSONOBJ_EQ(doc3, unittest::assertGet(collectionReader.next()));
+    ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, collectionReader.next().getStatus());
 
     // 'badNss' collection should not be implicitly created while attempting to create an index.
     ASSERT_FALSE(AutoGetCollectionForReadCommand(_opCtx.get(), badNss).getCollection());
@@ -1773,11 +1770,10 @@ TEST_F(SyncTailTest, MultiSyncApplyFetchesMissingDocumentIfDocumentIsAvailableFr
 
     // The collection referenced by "ns" in the failed operation is automatically created to hold
     // the missing document fetched from the sync source. We verify the contents of the collection
-    // with the OplogInterfaceLocal class.
-    OplogInterfaceLocal collectionReader(_opCtx.get(), nss.ns());
-    auto iter = collectionReader.makeIterator();
-    ASSERT_BSONOBJ_EQ(updatedDocument, unittest::assertGet(iter->next()).first);
-    ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, iter->next().getStatus());
+    // with the CollectionReader class.
+    CollectionReader collectionReader(_opCtx.get(), nss);
+    ASSERT_BSONOBJ_EQ(updatedDocument, unittest::assertGet(collectionReader.next()));
+    ASSERT_EQUALS(ErrorCodes::CollectionIsEmpty, collectionReader.next().getStatus());
 }
 
 namespace {
diff --git a/src/mongo/db/repl/sync_tail_test_fixture.cpp b/src/mongo/db/repl/sync_tail_test_fixture.cpp
index 9e9b5ed6fab..9b8557a6a82 100644
--- a/src/mongo/db/repl/sync_tail_test_fixture.cpp
+++ b/src/mongo/db/repl/sync_tail_test_fixture.cpp
@@ -36,6 +36,7 @@
 #include "mongo/db/db_raii.h"
 #include "mongo/db/dbdirectclient.h"
 #include "mongo/db/op_observer_registry.h"
+#include "mongo/db/query/internal_plans.h"
 #include "mongo/db/repl/drop_pending_collection_reaper.h"
 #include "mongo/db/repl/replication_consistency_markers_mock.h"
 #include "mongo/db/repl/replication_coordinator_mock.h"
@@ -278,5 +279,27 @@ void checkTxnTable(OperationContext* opCtx,
     }
 }
 
+CollectionReader::CollectionReader(OperationContext* opCtx, const NamespaceString& nss)
+    : _collToScan(opCtx, nss),
+      _exec(InternalPlanner::collectionScan(opCtx,
+                                            nss.ns(),
+                                            _collToScan.getCollection(),
+                                            PlanExecutor::NO_YIELD,
+                                            InternalPlanner::FORWARD)) {}
+
+StatusWith<BSONObj> CollectionReader::next() {
+    BSONObj obj;
+
+    auto state = _exec->getNext(&obj, nullptr);
+    if (state == PlanExecutor::IS_EOF) {
+        return {ErrorCodes::CollectionIsEmpty,
+                str::stream() << "no more documents in " << _collToScan.getNss()};
+    }
+
+    // PlanExecutors that do not yield should only return ADVANCED or EOF.
+    invariant(state == PlanExecutor::ADVANCED);
+    return obj;
+}
+
 }  // namespace repl
 }  // namespace mongo
diff --git a/src/mongo/db/repl/sync_tail_test_fixture.h b/src/mongo/db/repl/sync_tail_test_fixture.h
index a47c1071891..e58d11b26dc 100644
--- a/src/mongo/db/repl/sync_tail_test_fixture.h
+++ b/src/mongo/db/repl/sync_tail_test_fixture.h
@@ -31,6 +31,7 @@
 
 #include "mongo/base/status.h"
 #include "mongo/db/concurrency/lock_manager_defs.h"
+#include "mongo/db/db_raii.h"
 #include "mongo/db/logical_session_id.h"
 #include "mongo/db/op_observer_noop.h"
 #include "mongo/db/repl/replication_consistency_markers.h"
@@ -149,6 +150,19 @@ protected:
     UUID kUuid{UUID::gen()};
 };
 
+// Utility class to allow easily scanning a collection.  Scans in forward order, returns
+// Status::CollectionIsEmpty when scan is exhausted.
+class CollectionReader {
+public:
+    CollectionReader(OperationContext* opCtx, const NamespaceString& nss);
+
+    StatusWith<BSONObj> next();
+
+private:
+    AutoGetCollectionForRead _collToScan;
+    std::unique_ptr<PlanExecutor, PlanExecutor::Deleter> _exec;
+};
+
 Status failedApplyCommand(OperationContext* opCtx,
                           const BSONObj& theOperation,
                           OplogApplication::Mode);