SERVER-28214 clean up TaskExecutorMock

6 files changed, 99 insertions, 105 deletions

diff --git a/src/mongo/db/repl/abstract_async_component_test.cpp b/src/mongo/db/repl/abstract_async_component_test.cpp
index 6c2e8cd95f6..b4b71b972dd 100644
--- a/src/mongo/db/repl/abstract_async_component_test.cpp
+++ b/src/mongo/db/repl/abstract_async_component_test.cpp
@@ -337,11 +337,10 @@ TEST_F(AbstractAsyncComponentTest,
 
 TEST_F(AbstractAsyncComponentTest,
        ScheduleWorkAndSaveHandlePassesThroughErrorFromTaskExecutorScheduleWork) {
-    TaskExecutorMock taskExecutorMock(&getExecutor(),
-                                      [](const executor::RemoteCommandRequest&) { return false; });
+    TaskExecutorMock taskExecutorMock(&getExecutor());
     MockAsyncComponent component(&taskExecutorMock);
 
-    taskExecutorMock.shouldFailScheduleWork = true;
+    taskExecutorMock.shouldFailScheduleWorkRequest = []() { return true; };
 
     auto callback = [](const executor::TaskExecutor::CallbackArgs&) {};
     executor::TaskExecutor::CallbackHandle handle;
@@ -381,11 +380,10 @@ TEST_F(AbstractAsyncComponentTest,
 
 TEST_F(AbstractAsyncComponentTest,
        ScheduleWorkAtAndSaveHandlePassesThroughErrorFromTaskExecutorScheduleWork) {
-    TaskExecutorMock taskExecutorMock(&getExecutor(),
-                                      [](const executor::RemoteCommandRequest&) { return false; });
+    TaskExecutorMock taskExecutorMock(&getExecutor());
     MockAsyncComponent component(&taskExecutorMock);
 
-    taskExecutorMock.shouldFailScheduleWorkAt = true;
+    taskExecutorMock.shouldFailScheduleWorkAtRequest = []() { return true; };
 
     auto when = getExecutor().now() + Seconds(1);
     auto callback = [](const executor::TaskExecutor::CallbackArgs&) {};
diff --git a/src/mongo/db/repl/abstract_oplog_fetcher_test.cpp b/src/mongo/db/repl/abstract_oplog_fetcher_test.cpp
index cfdd6aa9900..bd5cf9b7e27 100644
--- a/src/mongo/db/repl/abstract_oplog_fetcher_test.cpp
+++ b/src/mongo/db/repl/abstract_oplog_fetcher_test.cpp
@@ -124,9 +124,9 @@ TEST_F(AbstractOplogFetcherTest, ShuttingExecutorDownShouldPreventOplogFetcherFr
 TEST_F(AbstractOplogFetcherTest, StartupReturnsOperationFailedIfExecutorFailsToScheduleFetcher) {
     ShutdownState shutdownState;
 
-    TaskExecutorMock taskExecutorMock(
-        &getExecutor(), [this](const executor::RemoteCommandRequest& request) { return false; });
-    taskExecutorMock.shouldFailScheduleWork = true;
+    TaskExecutorMock taskExecutorMock(&getExecutor());
+    taskExecutorMock.shouldFailScheduleWorkRequest = []() { return true; };
+
     MockOplogFetcher oplogFetcher(
         &taskExecutorMock, lastFetched, source, nss, 0, stdx::ref(shutdownState));
 
@@ -136,8 +136,10 @@ TEST_F(AbstractOplogFetcherTest, StartupReturnsOperationFailedIfExecutorFailsToS
 TEST_F(AbstractOplogFetcherTest, OplogFetcherReturnsOperationFailedIfExecutorFailsToScheduleFind) {
     ShutdownState shutdownState;
 
-    TaskExecutorMock taskExecutorMock(
-        &getExecutor(), [this](const executor::RemoteCommandRequest& request) { return true; });
+    TaskExecutorMock taskExecutorMock(&getExecutor());
+    taskExecutorMock.shouldFailScheduleRemoteCommandRequest =
+        [](const executor::RemoteCommandRequest&) { return true; };
+
     MockOplogFetcher oplogFetcher(
         &taskExecutorMock, lastFetched, source, nss, 0, stdx::ref(shutdownState));
 
@@ -153,9 +155,9 @@ TEST_F(AbstractOplogFetcherTest, OplogFetcherReturnsOperationFailedIfExecutorFai
 TEST_F(AbstractOplogFetcherTest, ShuttingExecutorDownAfterStartupStopsTheOplogFetcher) {
     ShutdownState shutdownState;
 
-    TaskExecutorMock taskExecutorMock(
-        &getExecutor(), [this](const executor::RemoteCommandRequest& request) { return false; });
-    taskExecutorMock.shouldDeferScheduleWorkByOneSecond = true;
+    TaskExecutorMock taskExecutorMock(&getExecutor());
+    taskExecutorMock.shouldDeferScheduleWorkRequestByOneSecond = []() { return true; };
+
     MockOplogFetcher oplogFetcher(
         &taskExecutorMock, lastFetched, source, nss, 0, stdx::ref(shutdownState));
 
@@ -173,9 +175,9 @@ TEST_F(AbstractOplogFetcherTest, ShuttingExecutorDownAfterStartupStopsTheOplogFe
 TEST_F(AbstractOplogFetcherTest, OplogFetcherReturnsCallbackCanceledIfShutdownAfterStartup) {
     ShutdownState shutdownState;
 
-    TaskExecutorMock taskExecutorMock(
-        &getExecutor(), [this](const executor::RemoteCommandRequest& request) { return false; });
-    taskExecutorMock.shouldDeferScheduleWorkByOneSecond = true;
+    TaskExecutorMock taskExecutorMock(&getExecutor());
+    taskExecutorMock.shouldDeferScheduleWorkRequestByOneSecond = []() { return true; };
+
     MockOplogFetcher oplogFetcher(
         &taskExecutorMock, lastFetched, source, nss, 0, stdx::ref(shutdownState));
 
diff --git a/src/mongo/db/repl/initial_syncer_test.cpp b/src/mongo/db/repl/initial_syncer_test.cpp
index 5cf7160aad1..e36e2955557 100644
--- a/src/mongo/db/repl/initial_syncer_test.cpp
+++ b/src/mongo/db/repl/initial_syncer_test.cpp
@@ -280,11 +280,7 @@ protected:
 
         launchExecutorThread();
 
-        _shouldFailRequest = [](const executor::RemoteCommandRequest&) { return false; };
-        _executorProxy = stdx::make_unique<TaskExecutorMock>(
-            &getExecutor(), [this](const executor::RemoteCommandRequest& request) {
-                return _shouldFailRequest(request);
-            });
+        _executorProxy = stdx::make_unique<TaskExecutorMock>(&getExecutor());
 
         _myLastOpTime = OpTime({3, 0}, 1);
 
@@ -390,7 +386,6 @@ protected:
         }
     }
 
-    TaskExecutorMock::ShouldFailRequestFn _shouldFailRequest;
     std::unique_ptr<TaskExecutorMock> _executorProxy;
 
     InitialSyncerOptions _options;
@@ -745,7 +740,7 @@ TEST_F(InitialSyncerTest,
     auto opCtx = makeOpCtx();
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort());
-    _executorProxy->shouldFailScheduleWorkAt = true;
+    _executorProxy->shouldFailScheduleWorkAtRequest = []() { return true; };
     ASSERT_OK(initialSyncer->startup(opCtx.get(), maxAttempts));
 
     initialSyncer->join();
@@ -771,7 +766,7 @@ TEST_F(InitialSyncerTest,
 
     // Last choose sync source attempt should now be scheduled. Advance clock so we fail last
     // choose sync source attempt which cause the next initial sync attempt to be scheduled.
-    _executorProxy->shouldFailScheduleWorkAt = true;
+    _executorProxy->shouldFailScheduleWorkAtRequest = []() { return true; };
     advanceClock(net, _options.syncSourceRetryWait);
 
     initialSyncer->join();
@@ -886,10 +881,11 @@ TEST_F(InitialSyncerTest, InitialSyncerPassesThroughGetRollbackIdScheduleError)
     // replSetGetRBID is the first remote command to be scheduled by the initial syncer after
     // creating the oplog collection.
     executor::RemoteCommandRequest request;
-    _shouldFailRequest = [&request](const executor::RemoteCommandRequest& requestToSend) {
-        request = requestToSend;
-        return true;
-    };
+    _executorProxy->shouldFailScheduleRemoteCommandRequest =
+        [&request](const executor::RemoteCommandRequest& requestToSend) {
+            request = requestToSend;
+            return true;
+        };
 
     HostAndPort syncSource("localhost", 12345);
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(syncSource);
@@ -994,10 +990,11 @@ TEST_F(InitialSyncerTest, InitialSyncerPassesThroughLastOplogEntryFetcherSchedul
     // The last oplog entry fetcher is the first component that sends a find command so we reject
     // any find commands and save the request for inspection at the end of this test case.
     executor::RemoteCommandRequest request;
-    _shouldFailRequest = [&request](const executor::RemoteCommandRequest& requestToSend) {
-        request = requestToSend;
-        return "find" == requestToSend.cmdObj.firstElement().fieldNameStringData();
-    };
+    _executorProxy->shouldFailScheduleRemoteCommandRequest =
+        [&request](const executor::RemoteCommandRequest& requestToSend) {
+            request = requestToSend;
+            return "find" == requestToSend.cmdObj.firstElement().fieldNameStringData();
+        };
 
     HostAndPort syncSource("localhost", 12345);
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(syncSource);
@@ -1204,14 +1201,15 @@ TEST_F(InitialSyncerTest, InitialSyncerPassesThroughOplogFetcherScheduleError) {
 
     // Make the tailable oplog query fail. Allow all other requests to be scheduled.
     executor::RemoteCommandRequest request;
-    _shouldFailRequest = [&request](const executor::RemoteCommandRequest& requestToSend) {
-        if ("find" == requestToSend.cmdObj.firstElement().fieldNameStringData() &&
-            requestToSend.cmdObj.getBoolField("tailable")) {
-            request = requestToSend;
-            return true;
-        }
-        return false;
-    };
+    _executorProxy->shouldFailScheduleRemoteCommandRequest =
+        [&request](const executor::RemoteCommandRequest& requestToSend) {
+            if ("find" == requestToSend.cmdObj.firstElement().fieldNameStringData() &&
+                requestToSend.cmdObj.getBoolField("tailable")) {
+                request = requestToSend;
+                return true;
+            }
+            return false;
+        };
 
     HostAndPort syncSource("localhost", 12345);
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(syncSource);
@@ -1433,13 +1431,14 @@ TEST_F(InitialSyncerTest,
 
     // Make the listDatabases command fail. Allow all other requests to be scheduled.
     executor::RemoteCommandRequest request;
-    _shouldFailRequest = [&request](const executor::RemoteCommandRequest& requestToSend) {
-        if ("listDatabases" == requestToSend.cmdObj.firstElement().fieldNameStringData()) {
-            request = requestToSend;
-            return true;
-        }
-        return false;
-    };
+    _executorProxy->shouldFailScheduleRemoteCommandRequest =
+        [&request](const executor::RemoteCommandRequest& requestToSend) {
+            if ("listDatabases" == requestToSend.cmdObj.firstElement().fieldNameStringData()) {
+                request = requestToSend;
+                return true;
+            }
+            return false;
+        };
 
     HostAndPort syncSource("localhost", 12345);
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(syncSource);
@@ -1670,19 +1669,20 @@ TEST_F(InitialSyncerTest,
     // scheduled.
     executor::RemoteCommandRequest request;
     bool first = true;
-    _shouldFailRequest = [&first, &request](const executor::RemoteCommandRequest& requestToSend) {
-        if ("find" == requestToSend.cmdObj.firstElement().fieldNameStringData() &&
-            requestToSend.cmdObj.hasField("sort") &&
-            1 == requestToSend.cmdObj.getIntField("limit")) {
-            if (first) {
-                first = false;
-                return false;
+    _executorProxy->shouldFailScheduleRemoteCommandRequest =
+        [&first, &request](const executor::RemoteCommandRequest& requestToSend) {
+            if ("find" == requestToSend.cmdObj.firstElement().fieldNameStringData() &&
+                requestToSend.cmdObj.hasField("sort") &&
+                1 == requestToSend.cmdObj.getIntField("limit")) {
+                if (first) {
+                    first = false;
+                    return false;
+                }
+                request = requestToSend;
+                return true;
             }
-            request = requestToSend;
-            return true;
-        }
-        return false;
-    };
+            return false;
+        };
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
     ASSERT_OK(initialSyncer->startup(opCtx.get(), maxAttempts));
@@ -2094,17 +2094,18 @@ TEST_F(
     // Make the second replSetGetRBID command fail. Allow all other requests to be scheduled.
     executor::RemoteCommandRequest request;
     bool first = true;
-    _shouldFailRequest = [&first, &request](const executor::RemoteCommandRequest& requestToSend) {
-        if ("replSetGetRBID" == requestToSend.cmdObj.firstElement().fieldNameStringData()) {
-            if (first) {
-                first = false;
-                return false;
+    _executorProxy->shouldFailScheduleRemoteCommandRequest =
+        [&first, &request](const executor::RemoteCommandRequest& requestToSend) {
+            if ("replSetGetRBID" == requestToSend.cmdObj.firstElement().fieldNameStringData()) {
+                if (first) {
+                    first = false;
+                    return false;
+                }
+                request = requestToSend;
+                return true;
             }
-            request = requestToSend;
-            return true;
-        }
-        return false;
-    };
+            return false;
+        };
 
     _syncSourceSelector->setChooseNewSyncSourceResult_forTest(HostAndPort("localhost", 12345));
     ASSERT_OK(initialSyncer->startup(opCtx.get(), maxAttempts));
@@ -2490,7 +2491,7 @@ TEST_F(InitialSyncerTest, InitialSyncerPassesThroughGetNextApplierBatchScheduleE
         // Before processing scheduled last oplog entry fetcher response, set flag in
         // TaskExecutorMock so that InitialSyncer will fail to schedule
         // _getNextApplierBatchCallback().
-        _executorProxy->shouldFailScheduleWork = true;
+        _executorProxy->shouldFailScheduleWorkRequest = []() { return true; };
 
         // Second last oplog entry fetcher.
         processSuccessfulLastOplogEntryFetcherResponse({makeOplogEntry(2)});
@@ -2544,7 +2545,7 @@ TEST_F(InitialSyncerTest, InitialSyncerPassesThroughSecondGetNextApplierBatchSch
         // Before processing scheduled last oplog entry fetcher response, set flag in
         // TaskExecutorMock so that InitialSyncer will fail to schedule second
         // _getNextApplierBatchCallback() at (now + options.getApplierBatchCallbackRetryWait).
-        _executorProxy->shouldFailScheduleWorkAt = true;
+        _executorProxy->shouldFailScheduleWorkAtRequest = []() { return true; };
 
         // Second last oplog entry fetcher.
         processSuccessfulLastOplogEntryFetcherResponse({makeOplogEntry(2)});
@@ -2786,7 +2787,7 @@ TEST_F(InitialSyncerTest, InitialSyncerPassesThroughMultiApplierScheduleError) {
         assertRemoteCommandNameEquals("getMore", request);
 
         // Make MultiApplier::startup() fail.
-        _executorProxy->shouldFailScheduleWork = true;
+        _executorProxy->shouldFailScheduleWorkRequest = []() { return true; };
 
         // Advance clock until _getNextApplierBatchCallback() runs.
         auto when = net->now() + _options.getApplierBatchCallbackRetryWait;
diff --git a/src/mongo/db/repl/rollback_impl_test.cpp b/src/mongo/db/repl/rollback_impl_test.cpp
index 7bfbe47e255..7119785e8a4 100644
--- a/src/mongo/db/repl/rollback_impl_test.cpp
+++ b/src/mongo/db/repl/rollback_impl_test.cpp
@@ -59,7 +59,6 @@ private:
     void tearDown() override;
 
 protected:
-    TaskExecutorMock::ShouldFailRequestFn _shouldFailScheduleRemoteCommandRequest;
     std::unique_ptr<TaskExecutorMock> _taskExecutorMock;
     Rollback::OnCompletionFn _onCompletion;
     StatusWith<OpTime> _onCompletionResult = executor::TaskExecutorTest::getDetectableErrorStatus();
@@ -70,14 +69,7 @@ protected:
 
 void RollbackImplTest::setUp() {
     RollbackTest::setUp();
-    _shouldFailScheduleRemoteCommandRequest = [](const executor::RemoteCommandRequest& request) {
-        return false;
-    };
-    _taskExecutorMock = stdx::make_unique<TaskExecutorMock>(
-        &_threadPoolExecutorTest.getExecutor(),
-        [this](const executor::RemoteCommandRequest& request) {
-            return _shouldFailScheduleRemoteCommandRequest(request);
-        });
+    _taskExecutorMock = stdx::make_unique<TaskExecutorMock>(&_threadPoolExecutorTest.getExecutor());
     _localOplog = stdx::make_unique<OplogInterfaceMock>(kEmptyMockOperations);
     HostAndPort syncSource("localhost", 1234);
     _requiredRollbackId = 1;
@@ -105,7 +97,6 @@ void RollbackImplTest::tearDown() {
     _requiredRollbackId = -1;
     _localOplog = {};
     _taskExecutorMock = {};
-    _shouldFailScheduleRemoteCommandRequest = {};
     RollbackTest::tearDown();
 }
 
@@ -159,14 +150,14 @@ TEST_F(RollbackImplTest, InvalidConstruction) {
 
 TEST_F(RollbackImplTest,
        StartupReturnsOperationFailedIfMockExecutorFailsToScheduleRollbackTransitionCallback) {
-    _taskExecutorMock->shouldFailScheduleWork = true;
+    _taskExecutorMock->shouldFailScheduleWorkRequest = []() { return true; };
     ASSERT_EQUALS(ErrorCodes::OperationFailed, _rollback->startup());
 }
 
 TEST_F(
     RollbackImplTest,
     RollbackReturnsCallbackCanceledIfExecutorIsShutdownAfterSchedulingTransitionToRollbackCallback) {
-    _taskExecutorMock->shouldDeferScheduleWorkByOneSecond = true;
+    _taskExecutorMock->shouldDeferScheduleWorkRequestByOneSecond = []() { return true; };
     ASSERT_OK(_rollback->startup());
     _threadPoolExecutorTest.getExecutor().shutdown();
     _rollback->join();
@@ -176,7 +167,7 @@ TEST_F(
 TEST_F(
     RollbackImplTest,
     RollbackReturnsCallbackCanceledIfRollbackIsShutdownAfterSchedulingTransitionToRollbackCallback) {
-    _taskExecutorMock->shouldDeferScheduleWorkByOneSecond = true;
+    _taskExecutorMock->shouldDeferScheduleWorkRequestByOneSecond = []() { return true; };
     ASSERT_OK(_rollback->startup());
     _rollback->shutdown();
     _rollback->join();
@@ -184,7 +175,7 @@ TEST_F(
 }
 
 DEATH_TEST_F(RollbackImplTest, RollbackTerminatesIfCompletionCallbackThrowsException, "terminate") {
-    _taskExecutorMock->shouldDeferScheduleWorkByOneSecond = true;
+    _taskExecutorMock->shouldDeferScheduleWorkRequestByOneSecond = []() { return true; };
     ASSERT_OK(_rollback->startup());
     _onCompletion = [](const StatusWith<OpTime>&) noexcept {
         uassertStatusOK({ErrorCodes::InternalError,
diff --git a/src/mongo/db/repl/task_executor_mock.cpp b/src/mongo/db/repl/task_executor_mock.cpp
index 8d2578e3028..320fb12c77f 100644
--- a/src/mongo/db/repl/task_executor_mock.cpp
+++ b/src/mongo/db/repl/task_executor_mock.cpp
@@ -33,16 +33,15 @@
 namespace mongo {
 namespace repl {
 
-TaskExecutorMock::TaskExecutorMock(executor::TaskExecutor* executor,
-                                   ShouldFailRequestFn shouldFailRequest)
-    : unittest::TaskExecutorProxy(executor), _shouldFailRequest(shouldFailRequest) {}
+TaskExecutorMock::TaskExecutorMock(executor::TaskExecutor* executor)
+    : unittest::TaskExecutorProxy(executor) {}
 
 StatusWith<executor::TaskExecutor::CallbackHandle> TaskExecutorMock::scheduleWork(
     const CallbackFn& work) {
-    if (shouldFailScheduleWork) {
+    if (shouldFailScheduleWorkRequest()) {
         return Status(ErrorCodes::OperationFailed, "failed to schedule work");
     }
-    if (shouldDeferScheduleWorkByOneSecond) {
+    if (shouldDeferScheduleWorkRequestByOneSecond()) {
         auto when = now() + Seconds(1);
         return getExecutor()->scheduleWorkAt(when, work);
     }
@@ -51,7 +50,7 @@ StatusWith<executor::TaskExecutor::CallbackHandle> TaskExecutorMock::scheduleWor
 
 StatusWith<executor::TaskExecutor::CallbackHandle> TaskExecutorMock::scheduleWorkAt(
     Date_t when, const CallbackFn& work) {
-    if (shouldFailScheduleWorkAt) {
+    if (shouldFailScheduleWorkAtRequest()) {
         return Status(ErrorCodes::OperationFailed,
                       str::stream() << "failed to schedule work at " << when.toString());
     }
@@ -60,7 +59,7 @@ StatusWith<executor::TaskExecutor::CallbackHandle> TaskExecutorMock::scheduleWor
 
 StatusWith<executor::TaskExecutor::CallbackHandle> TaskExecutorMock::scheduleRemoteCommand(
     const executor::RemoteCommandRequest& request, const RemoteCommandCallbackFn& cb) {
-    if (_shouldFailRequest(request)) {
+    if (shouldFailScheduleRemoteCommandRequest(request)) {
         return Status(ErrorCodes::OperationFailed, "failed to schedule remote command");
     }
     return getExecutor()->scheduleRemoteCommand(request, cb);
diff --git a/src/mongo/db/repl/task_executor_mock.h b/src/mongo/db/repl/task_executor_mock.h
index 1406a80eeb7..eb02ad18eb6 100644
--- a/src/mongo/db/repl/task_executor_mock.h
+++ b/src/mongo/db/repl/task_executor_mock.h
@@ -39,9 +39,11 @@ namespace repl {
  */
 class TaskExecutorMock : public unittest::TaskExecutorProxy {
 public:
-    using ShouldFailRequestFn = stdx::function<bool(const executor::RemoteCommandRequest&)>;
+    using ShouldFailScheduleWorkRequestFn = stdx::function<bool()>;
+    using ShouldFailScheduleRemoteCommandRequestFn =
+        stdx::function<bool(const executor::RemoteCommandRequest&)>;
 
-    TaskExecutorMock(executor::TaskExecutor* executor, ShouldFailRequestFn shouldFailRequest);
+    explicit TaskExecutorMock(executor::TaskExecutor* executor);
 
     StatusWith<CallbackHandle> scheduleWork(const CallbackFn& work) override;
     StatusWith<CallbackHandle> scheduleWorkAt(Date_t when, const CallbackFn& work) override;
@@ -49,20 +51,21 @@ public:
                                                      const RemoteCommandCallbackFn& cb) override;
 
     // Override to make scheduleWork() fail during testing.
-    bool shouldFailScheduleWork = false;
+    ShouldFailScheduleWorkRequestFn shouldFailScheduleWorkRequest = []() { return false; };
 
     // Override to make scheduleWorkAt() fail during testing.
-    bool shouldFailScheduleWorkAt = false;
+    ShouldFailScheduleWorkRequestFn shouldFailScheduleWorkAtRequest = []() { return false; };
 
-    // Set to true to make scheduleWork() schedule task 1 second later instead of running
-    // immediately. This allows us to test cancellation handling in callbacks scheduled
+    // If the predicate returns true, scheduleWork() will schedule the task 1 second later instead
+    // of running immediately. This allows us to test cancellation handling in callbacks scheduled
     // using scheduleWork().
-    bool shouldDeferScheduleWorkByOneSecond = false;
+    ShouldFailScheduleWorkRequestFn shouldDeferScheduleWorkRequestByOneSecond = []() {
+        return false;
+    };
 
-private:
-    // This predicate is set at construction and is used to determine if scheduleRemoteCommand()
-    // should return an error during testing.
-    ShouldFailRequestFn _shouldFailRequest;
+    // Override to make scheduleRemoteCommand fail during testing.
+    ShouldFailScheduleRemoteCommandRequestFn shouldFailScheduleRemoteCommandRequest =
+        [](const executor::RemoteCommandRequest&) { return false; };
 };
 
 }  // namespace repl