SERVER-41053 Don't create ServiceContexts while doing updates

This commit also renames DocumentSourceMock::create to DocumentSourceMock::createForTest.

27 files changed, 287 insertions, 241 deletions

diff --git a/src/mongo/db/pipeline/document_source_add_fields_test.cpp b/src/mongo/db/pipeline/document_source_add_fields_test.cpp
index bad10fc0d47..c0b896d973a 100644
--- a/src/mongo/db/pipeline/document_source_add_fields_test.cpp
+++ b/src/mongo/db/pipeline/document_source_add_fields_test.cpp
@@ -59,7 +59,8 @@ using AddFieldsTest = AggregationContextFixture;
 TEST_F(AddFieldsTest, ShouldKeepUnspecifiedFieldsReplaceExistingFieldsAndAddNewFields) {
     auto addFields =
         DocumentSourceAddFields::create(BSON("e" << 2 << "b" << BSON("c" << 3)), getExpCtx());
-    auto mock = DocumentSourceMock::create(Document{{"a", 1}, {"b", Document{{"c", 1}}}, {"d", 1}});
+    auto mock =
+        DocumentSourceMock::createForTest(Document{{"a", 1}, {"b", Document{{"c", 1}}}, {"d", 1}});
     addFields->setSource(mock.get());
 
     auto next = addFields->getNext();
@@ -94,8 +95,8 @@ TEST_F(AddFieldsTest, ShouldErrorOnNonObjectSpec) {
 
 TEST_F(AddFieldsTest, ShouldBeAbleToProcessMultipleDocuments) {
     auto addFields = DocumentSourceAddFields::create(BSON("a" << 10), getExpCtx());
-    auto mock =
-        DocumentSourceMock::create({Document{{"a", 1}, {"b", 2}}, Document{{"c", 3}, {"d", 4}}});
+    auto mock = DocumentSourceMock::createForTest(
+        {Document{{"a", 1}, {"b", 2}}, Document{{"c", 3}, {"d", 4}}});
     addFields->setSource(mock.get());
 
     auto next = addFields->getNext();
@@ -139,10 +140,11 @@ TEST_F(AddFieldsTest, ShouldAddReferencedFieldsToDependencies) {
 
 TEST_F(AddFieldsTest, ShouldPropagatePauses) {
     auto addFields = DocumentSourceAddFields::create(BSON("a" << 10), getExpCtx());
-    auto mock = DocumentSourceMock::create({Document(),
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document(),
-                                            DocumentSource::GetNextResult::makePauseExecution()});
+    auto mock =
+        DocumentSourceMock::createForTest({Document(),
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document(),
+                                           DocumentSource::GetNextResult::makePauseExecution()});
     addFields->setSource(mock.get());
 
     ASSERT_TRUE(addFields->getNext().isAdvanced());
@@ -159,7 +161,7 @@ TEST_F(AddFieldsTest, AddFieldsWithRemoveSystemVariableDoesNotAddField) {
     auto addFields = DocumentSourceAddFields::create(BSON("fieldToAdd"
                                                           << "$$REMOVE"),
                                                      getExpCtx());
-    auto mock = DocumentSourceMock::create(Document{{"existingField", 1}});
+    auto mock = DocumentSourceMock::createForTest(Document{{"existingField", 1}});
     addFields->setSource(mock.get());
 
     auto next = addFields->getNext();
@@ -173,7 +175,7 @@ TEST_F(AddFieldsTest, AddFieldsWithRootSystemVariableAddsRootAsSubDoc) {
     auto addFields = DocumentSourceAddFields::create(BSON("b"
                                                           << "$$ROOT"),
                                                      getExpCtx());
-    auto mock = DocumentSourceMock::create(Document{{"a", 1}});
+    auto mock = DocumentSourceMock::createForTest(Document{{"a", 1}});
     addFields->setSource(mock.get());
 
     auto next = addFields->getNext();
@@ -187,7 +189,7 @@ TEST_F(AddFieldsTest, AddFieldsWithCurrentSystemVariableAddsRootAsSubDoc) {
     auto addFields = DocumentSourceAddFields::create(BSON("b"
                                                           << "$$CURRENT"),
                                                      getExpCtx());
-    auto mock = DocumentSourceMock::create(Document{{"a", 1}});
+    auto mock = DocumentSourceMock::createForTest(Document{{"a", 1}});
     addFields->setSource(mock.get());
 
     auto next = addFields->getNext();
@@ -214,7 +216,7 @@ BSONObj makeAddFieldsForNestedDocument(size_t depth) {
 TEST_F(AddFieldsTest, CanAddNestedDocumentExactlyAtDepthLimit) {
     auto addFields = DocumentSourceAddFields::create(
         makeAddFieldsForNestedDocument(BSONDepth::getMaxAllowableDepth()), getExpCtx());
-    auto mock = DocumentSourceMock::create(Document{{"_id", 1}});
+    auto mock = DocumentSourceMock::createForTest(Document{{"_id", 1}});
     addFields->setSource(mock.get());
 
     auto next = addFields->getNext();
diff --git a/src/mongo/db/pipeline/document_source_bucket_auto_test.cpp b/src/mongo/db/pipeline/document_source_bucket_auto_test.cpp
index 62d85e1389f..da86580ef02 100644
--- a/src/mongo/db/pipeline/document_source_bucket_auto_test.cpp
+++ b/src/mongo/db/pipeline/document_source_bucket_auto_test.cpp
@@ -72,7 +72,7 @@ public:
             mockInputs.emplace_back(std::move(input));
         }
 
-        auto source = DocumentSourceMock::create(std::move(mockInputs));
+        auto source = DocumentSourceMock::createForTest(std::move(mockInputs));
         bucketAutoStage->setSource(source.get());
 
         vector<Document> results;
@@ -317,13 +317,14 @@ TEST_F(BucketAutoTests, RespectsCanonicalTypeOrderingOfValues) {
 TEST_F(BucketAutoTests, ShouldPropagatePauses) {
     auto bucketAutoSpec = fromjson("{$bucketAuto : {groupBy : '$x', buckets : 2}}");
     auto bucketAutoStage = createBucketAuto(bucketAutoSpec);
-    auto source = DocumentSourceMock::create({Document{{"x", 1}},
-                                              DocumentSource::GetNextResult::makePauseExecution(),
-                                              Document{{"x", 2}},
-                                              Document{{"x", 3}},
-                                              DocumentSource::GetNextResult::makePauseExecution(),
-                                              Document{{"x", 4}},
-                                              DocumentSource::GetNextResult::makePauseExecution()});
+    auto source =
+        DocumentSourceMock::createForTest({Document{{"x", 1}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"x", 2}},
+                                           Document{{"x", 3}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"x", 4}},
+                                           DocumentSource::GetNextResult::makePauseExecution()});
     bucketAutoStage->setSource(source.get());
 
     // The $bucketAuto stage needs to consume all inputs before returning any output, so we should
@@ -362,10 +363,10 @@ TEST_F(BucketAutoTests, ShouldBeAbleToCorrectlySpillToDisk) {
         expCtx, groupByExpression, numBuckets, {}, nullptr, maxMemoryUsageBytes);
 
     string largeStr(maxMemoryUsageBytes, 'x');
-    auto mock = DocumentSourceMock::create({Document{{"a", 0}, {"largeStr", largeStr}},
-                                            Document{{"a", 1}, {"largeStr", largeStr}},
-                                            Document{{"a", 2}, {"largeStr", largeStr}},
-                                            Document{{"a", 3}, {"largeStr", largeStr}}});
+    auto mock = DocumentSourceMock::createForTest({Document{{"a", 0}, {"largeStr", largeStr}},
+                                                   Document{{"a", 1}, {"largeStr", largeStr}},
+                                                   Document{{"a", 2}, {"largeStr", largeStr}},
+                                                   Document{{"a", 3}, {"largeStr", largeStr}}});
     bucketAutoStage->setSource(mock.get());
 
     auto next = bucketAutoStage->getNext();
@@ -399,12 +400,13 @@ TEST_F(BucketAutoTests, ShouldBeAbleToPauseLoadingWhileSpilled) {
     auto sort = DocumentSourceSort::create(expCtx, BSON("_id" << -1), -1, maxMemoryUsageBytes);
 
     string largeStr(maxMemoryUsageBytes, 'x');
-    auto mock = DocumentSourceMock::create({Document{{"a", 0}, {"largeStr", largeStr}},
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document{{"a", 1}, {"largeStr", largeStr}},
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document{{"a", 2}, {"largeStr", largeStr}},
-                                            Document{{"a", 3}, {"largeStr", largeStr}}});
+    auto mock =
+        DocumentSourceMock::createForTest({Document{{"a", 0}, {"largeStr", largeStr}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"a", 1}, {"largeStr", largeStr}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"a", 2}, {"largeStr", largeStr}},
+                                           Document{{"a", 3}, {"largeStr", largeStr}}});
     bucketAutoStage->setSource(mock.get());
 
     // There were 2 pauses, so we should expect 2 paused results before any results can be
@@ -638,7 +640,7 @@ void assertCannotSpillToDisk(const boost::intrusive_ptr<ExpressionContext>& expC
         expCtx, groupByExpression, numBuckets, {}, nullptr, maxMemoryUsageBytes);
 
     string largeStr(maxMemoryUsageBytes, 'x');
-    auto mock = DocumentSourceMock::create(
+    auto mock = DocumentSourceMock::createForTest(
         {Document{{"a", 0}, {"largeStr", largeStr}}, Document{{"a", 1}, {"largeStr", largeStr}}});
     bucketAutoStage->setSource(mock.get());
 
@@ -674,10 +676,11 @@ TEST_F(BucketAutoTests, ShouldCorrectlyTrackMemoryUsageBetweenPauses) {
         expCtx, groupByExpression, numBuckets, {}, nullptr, maxMemoryUsageBytes);
 
     string largeStr(maxMemoryUsageBytes / 2, 'x');
-    auto mock = DocumentSourceMock::create({Document{{"a", 0}, {"largeStr", largeStr}},
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document{{"a", 1}, {"largeStr", largeStr}},
-                                            Document{{"a", 2}, {"largeStr", largeStr}}});
+    auto mock =
+        DocumentSourceMock::createForTest({Document{{"a", 0}, {"largeStr", largeStr}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"a", 1}, {"largeStr", largeStr}},
+                                           Document{{"a", 2}, {"largeStr", largeStr}}});
     bucketAutoStage->setSource(mock.get());
 
     // The first getNext() should pause.
diff --git a/src/mongo/db/pipeline/document_source_bucket_test.cpp b/src/mongo/db/pipeline/document_source_bucket_test.cpp
index c9f5c1b4d69..175d2316208 100644
--- a/src/mongo/db/pipeline/document_source_bucket_test.cpp
+++ b/src/mongo/db/pipeline/document_source_bucket_test.cpp
@@ -280,7 +280,7 @@ TEST_F(InvalidBucketSpec, SwitchFailsForBucketWhenNoDefaultSpecified) {
     ASSERT(sortStage);
 
     auto doc = Document{{"x", 4}};
-    auto source = DocumentSourceMock::create(doc);
+    auto source = DocumentSourceMock::createForTest(doc);
     groupStage->setSource(source.get());
     ASSERT_THROWS_CODE(groupStage->getNext(), AssertionException, 40066);
 }
diff --git a/src/mongo/db/pipeline/document_source_change_stream_test.cpp b/src/mongo/db/pipeline/document_source_change_stream_test.cpp
index 6f89c07e734..b6bdd785d5b 100644
--- a/src/mongo/db/pipeline/document_source_change_stream_test.cpp
+++ b/src/mongo/db/pipeline/document_source_change_stream_test.cpp
@@ -181,7 +181,7 @@ public:
         ASSERT_EQ(string(transform->getSourceName()), DSChangeStream::kStageName);
 
         // Create mock stage and insert at the front of the stages.
-        auto mock = DocumentSourceMock::create(D(entry));
+        auto mock = DocumentSourceMock::createForTest(D(entry));
         stages.insert(stages.begin(), mock);
 
         // Wire up the stages by setting the source stage.
diff --git a/src/mongo/db/pipeline/document_source_check_resume_token_test.cpp b/src/mongo/db/pipeline/document_source_check_resume_token_test.cpp
index b038d1dd418..230ad31c8f3 100644
--- a/src/mongo/db/pipeline/document_source_check_resume_token_test.cpp
+++ b/src/mongo/db/pipeline/document_source_check_resume_token_test.cpp
@@ -58,7 +58,7 @@ static constexpr StringData kTestNs = "test.ns"_sd;
 
 class CheckResumeTokenTest : public AggregationContextFixture {
 public:
-    CheckResumeTokenTest() : _mock(DocumentSourceMock::create()) {}
+    CheckResumeTokenTest() : _mock(DocumentSourceMock::createForTest()) {}
 
 protected:
     /**
@@ -486,7 +486,7 @@ public:
         const boost::intrusive_ptr<ExpressionContext>& expCtx, Pipeline* ownedPipeline) final {
         std::unique_ptr<Pipeline, PipelineDeleter> pipeline(ownedPipeline,
                                                             PipelineDeleter(expCtx->opCtx));
-        pipeline->addInitialSource(DocumentSourceMock::create(_mockResults));
+        pipeline->addInitialSource(DocumentSourceMock::createForTest(_mockResults));
         return pipeline;
     }
 
diff --git a/src/mongo/db/pipeline/document_source_exchange_test.cpp b/src/mongo/db/pipeline/document_source_exchange_test.cpp
index ab32b96a59e..4cc3cf60e8c 100644
--- a/src/mongo/db/pipeline/document_source_exchange_test.cpp
+++ b/src/mongo/db/pipeline/document_source_exchange_test.cpp
@@ -78,7 +78,7 @@ protected:
     }
 
     auto getMockSource(int cnt) {
-        auto source = DocumentSourceMock::create();
+        auto source = DocumentSourceMock::createForTest();
 
         for (int i = 0; i < cnt; ++i)
             source->queue.emplace_back(Document{{"a", i}, {"b", "aaaaaaaaaaaaaaaaaaaaaaaaaaa"_sd}});
@@ -96,7 +96,7 @@ protected:
     auto getRandomMockSource(size_t cnt, int64_t seed) {
         PseudoRandom prng(seed);
 
-        auto source = DocumentSourceMock::create();
+        auto source = DocumentSourceMock::createForTest();
 
         for (size_t i = 0; i < cnt; ++i)
             source->queue.emplace_back(Document{{"a", static_cast<int>(prng.nextInt32() % cnt)},
diff --git a/src/mongo/db/pipeline/document_source_facet_test.cpp b/src/mongo/db/pipeline/document_source_facet_test.cpp
index 8bd38a3b484..90ee6eb6628 100644
--- a/src/mongo/db/pipeline/document_source_facet_test.cpp
+++ b/src/mongo/db/pipeline/document_source_facet_test.cpp
@@ -284,7 +284,7 @@ TEST_F(DocumentSourceFacetTest, SingleFacetShouldReceiveAllDocuments) {
 
     deque<DocumentSource::GetNextResult> inputs = {
         Document{{"_id", 0}}, Document{{"_id", 1}}, Document{{"_id", 2}}};
-    auto mock = DocumentSourceMock::create(inputs);
+    auto mock = DocumentSourceMock::createForTest(inputs);
 
     auto dummy = DocumentSourcePassthrough::create();
 
@@ -313,7 +313,7 @@ TEST_F(DocumentSourceFacetTest, MultipleFacetsShouldSeeTheSameDocuments) {
 
     deque<DocumentSource::GetNextResult> inputs = {
         Document{{"_id", 0}}, Document{{"_id", 1}}, Document{{"_id", 2}}};
-    auto mock = DocumentSourceMock::create(inputs);
+    auto mock = DocumentSourceMock::createForTest(inputs);
 
     auto firstDummy = DocumentSourcePassthrough::create();
     auto firstPipeline = uassertStatusOK(Pipeline::createFacetPipeline({firstDummy}, ctx));
@@ -352,7 +352,7 @@ TEST_F(DocumentSourceFacetTest,
 
     deque<DocumentSource::GetNextResult> inputs = {
         Document{{"_id", 0}}, Document{{"_id", 1}}, Document{{"_id", 2}}, Document{{"_id", 3}}};
-    auto mock = DocumentSourceMock::create(inputs);
+    auto mock = DocumentSourceMock::createForTest(inputs);
 
     auto passthrough = DocumentSourcePassthrough::create();
     auto passthroughPipe = uassertStatusOK(Pipeline::createFacetPipeline({passthrough}, ctx));
@@ -390,7 +390,7 @@ TEST_F(DocumentSourceFacetTest, ShouldBeAbleToEvaluateMultipleStagesWithinOneSub
     auto ctx = getExpCtx();
 
     deque<DocumentSource::GetNextResult> inputs = {Document{{"_id", 0}}, Document{{"_id", 1}}};
-    auto mock = DocumentSourceMock::create(inputs);
+    auto mock = DocumentSourceMock::createForTest(inputs);
 
     auto firstDummy = DocumentSourcePassthrough::create();
     auto secondDummy = DocumentSourcePassthrough::create();
@@ -410,7 +410,7 @@ TEST_F(DocumentSourceFacetTest, ShouldBeAbleToEvaluateMultipleStagesWithinOneSub
 TEST_F(DocumentSourceFacetTest, ShouldPropagateDisposeThroughToSource) {
     auto ctx = getExpCtx();
 
-    auto mockSource = DocumentSourceMock::create();
+    auto mockSource = DocumentSourceMock::createForTest();
 
     auto firstDummy = DocumentSourcePassthrough::create();
     auto firstPipe = uassertStatusOK(Pipeline::createFacetPipeline({firstDummy}, ctx));
@@ -433,7 +433,8 @@ DEATH_TEST_F(DocumentSourceFacetTest,
              ShouldFailIfGivenPausedInput,
              "Invariant failure !input.isPaused()") {
     auto ctx = getExpCtx();
-    auto mock = DocumentSourceMock::create(DocumentSource::GetNextResult::makePauseExecution());
+    auto mock =
+        DocumentSourceMock::createForTest(DocumentSource::GetNextResult::makePauseExecution());
 
     auto firstDummy = DocumentSourcePassthrough::create();
     auto pipeline = uassertStatusOK(Pipeline::createFacetPipeline({firstDummy}, ctx));
diff --git a/src/mongo/db/pipeline/document_source_graph_lookup_test.cpp b/src/mongo/db/pipeline/document_source_graph_lookup_test.cpp
index 774e0ba802a..0e402da49a1 100644
--- a/src/mongo/db/pipeline/document_source_graph_lookup_test.cpp
+++ b/src/mongo/db/pipeline/document_source_graph_lookup_test.cpp
@@ -83,7 +83,7 @@ public:
         const boost::intrusive_ptr<ExpressionContext>& expCtx, Pipeline* ownedPipeline) final {
         std::unique_ptr<Pipeline, PipelineDeleter> pipeline(ownedPipeline,
                                                             PipelineDeleter(expCtx->opCtx));
-        pipeline->addInitialSource(DocumentSourceMock::create(_results));
+        pipeline->addInitialSource(DocumentSourceMock::createForTest(_results));
         return pipeline;
     }
 
@@ -95,7 +95,7 @@ TEST_F(DocumentSourceGraphLookUpTest,
        ShouldErrorWhenDoingInitialMatchIfDocumentInFromCollectionIsMissingId) {
     auto expCtx = getExpCtx();
     std::deque<DocumentSource::GetNextResult> inputs{Document{{"_id", 0}}};
-    auto inputMock = DocumentSourceMock::create(std::move(inputs));
+    auto inputMock = DocumentSourceMock::createForTest(std::move(inputs));
 
     std::deque<DocumentSource::GetNextResult> fromContents{Document{{"to", 0}}};
 
@@ -123,7 +123,7 @@ TEST_F(DocumentSourceGraphLookUpTest,
     auto expCtx = getExpCtx();
 
     std::deque<DocumentSource::GetNextResult> inputs{Document{{"_id", 0}}};
-    auto inputMock = DocumentSourceMock::create(std::move(inputs));
+    auto inputMock = DocumentSourceMock::createForTest(std::move(inputs));
 
     std::deque<DocumentSource::GetNextResult> fromContents{
         Document{{"_id", "a"_sd}, {"to", 0}, {"from", 1}}, Document{{"to", 1}}};
@@ -153,7 +153,7 @@ TEST_F(DocumentSourceGraphLookUpTest,
     auto expCtx = getExpCtx();
 
     std::deque<DocumentSource::GetNextResult> inputs{Document{{"_id", 0}}};
-    auto inputMock = DocumentSourceMock::create(std::move(inputs));
+    auto inputMock = DocumentSourceMock::createForTest(std::move(inputs));
 
     std::deque<DocumentSource::GetNextResult> fromContents{Document{{"to", 0}}};
 
@@ -192,7 +192,7 @@ TEST_F(DocumentSourceGraphLookUpTest,
     auto expCtx = getExpCtx();
 
     std::deque<DocumentSource::GetNextResult> inputs{Document{{"_id", 0}}};
-    auto inputMock = DocumentSourceMock::create(std::move(inputs));
+    auto inputMock = DocumentSourceMock::createForTest(std::move(inputs));
 
     Document to0from1{{"_id", "a"_sd}, {"to", 0}, {"from", 1}};
     Document to0from2{{"_id", "a"_sd}, {"to", 0}, {"from", 2}};
@@ -258,10 +258,10 @@ TEST_F(DocumentSourceGraphLookUpTest, ShouldPropagatePauses) {
     auto expCtx = getExpCtx();
 
     auto inputMock =
-        DocumentSourceMock::create({Document{{"startPoint", 0}},
-                                    DocumentSource::GetNextResult::makePauseExecution(),
-                                    Document{{"startPoint", 0}},
-                                    DocumentSource::GetNextResult::makePauseExecution()});
+        DocumentSourceMock::createForTest({Document{{"startPoint", 0}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"startPoint", 0}},
+                                           DocumentSource::GetNextResult::makePauseExecution()});
 
     std::deque<DocumentSource::GetNextResult> fromContents{
         Document{{"_id", "a"_sd}, {"to", 0}, {"from", 1}}, Document{{"_id", "b"_sd}, {"to", 1}}};
@@ -325,10 +325,10 @@ TEST_F(DocumentSourceGraphLookUpTest, ShouldPropagatePausesWhileUnwinding) {
 
     // Set up the $graphLookup stage
     auto inputMock =
-        DocumentSourceMock::create({Document{{"startPoint", 0}},
-                                    DocumentSource::GetNextResult::makePauseExecution(),
-                                    Document{{"startPoint", 0}},
-                                    DocumentSource::GetNextResult::makePauseExecution()});
+        DocumentSourceMock::createForTest({Document{{"startPoint", 0}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"startPoint", 0}},
+                                           DocumentSource::GetNextResult::makePauseExecution()});
 
     std::deque<DocumentSource::GetNextResult> fromContents{
         Document{{"_id", "a"_sd}, {"to", 0}, {"from", 1}}, Document{{"_id", "b"_sd}, {"to", 1}}};
@@ -453,7 +453,7 @@ TEST_F(DocumentSourceGraphLookUpTest, GraphLookupShouldReportFieldsModifiedByAbs
 TEST_F(DocumentSourceGraphLookUpTest, GraphLookupWithComparisonExpressionForStartWith) {
     auto expCtx = getExpCtx();
 
-    auto inputMock = DocumentSourceMock::create(Document({{"_id", 0}, {"a", 1}, {"b", 2}}));
+    auto inputMock = DocumentSourceMock::createForTest(Document({{"_id", 0}, {"a", 1}, {"b", 2}}));
 
     NamespaceString fromNs("test", "foreign");
     expCtx->setResolvedNamespaces(StringMap<ExpressionContext::ResolvedNamespace>{
@@ -497,7 +497,7 @@ TEST_F(DocumentSourceGraphLookUpTest, ShouldExpandArraysAtEndOfConnectFromField)
     auto expCtx = getExpCtx();
 
     std::deque<DocumentSource::GetNextResult> inputs{Document{{"_id", 0}, {"startVal", 0}}};
-    auto inputMock = DocumentSourceMock::create(std::move(inputs));
+    auto inputMock = DocumentSourceMock::createForTest(std::move(inputs));
 
     /* Make the following graph:
      *   ,> 1 .
@@ -565,7 +565,7 @@ TEST_F(DocumentSourceGraphLookUpTest, ShouldNotExpandArraysWithinArraysAtEndOfCo
 
     std::deque<DocumentSource::GetNextResult> inputs{
         Document{{"_id", 0}, {"startVal", makeTupleValue(0, 0)}}};
-    auto inputMock = DocumentSourceMock::create(std::move(inputs));
+    auto inputMock = DocumentSourceMock::createForTest(std::move(inputs));
 
     // Make the following graph:
     //
diff --git a/src/mongo/db/pipeline/document_source_group_test.cpp b/src/mongo/db/pipeline/document_source_group_test.cpp
index da25b97d397..8f0d7d3c7a2 100644
--- a/src/mongo/db/pipeline/document_source_group_test.cpp
+++ b/src/mongo/db/pipeline/document_source_group_test.cpp
@@ -78,13 +78,14 @@ TEST_F(DocumentSourceGroupTest, ShouldBeAbleToPauseLoading) {
                                          AccumulationStatement::getFactory("$sum")};
     auto group = DocumentSourceGroup::create(
         expCtx, ExpressionConstant::create(expCtx, Value(BSONNULL)), {countStatement});
-    auto mock = DocumentSourceMock::create({DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document(),
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document(),
-                                            Document(),
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document()});
+    auto mock =
+        DocumentSourceMock::createForTest({DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document(),
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document(),
+                                           Document(),
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document()});
     group->setSource(mock.get());
 
     // There were 3 pauses, so we should expect 3 paused results before any results can be returned.
@@ -116,11 +117,12 @@ TEST_F(DocumentSourceGroupTest, ShouldBeAbleToPauseLoadingWhileSpilled) {
         expCtx, groupByExpression, {pushStatement}, maxMemoryUsageBytes);
 
     string largeStr(maxMemoryUsageBytes, 'x');
-    auto mock = DocumentSourceMock::create({Document{{"_id", 0}, {"largeStr", largeStr}},
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document{{"_id", 1}, {"largeStr", largeStr}},
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document{{"_id", 2}, {"largeStr", largeStr}}});
+    auto mock =
+        DocumentSourceMock::createForTest({Document{{"_id", 0}, {"largeStr", largeStr}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"_id", 1}, {"largeStr", largeStr}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"_id", 2}, {"largeStr", largeStr}}});
     group->setSource(mock.get());
 
     // There were 2 pauses, so we should expect 2 paused results before any results can be returned.
@@ -155,8 +157,8 @@ TEST_F(DocumentSourceGroupTest, ShouldErrorIfNotAllowedToSpillToDiskAndResultSet
         expCtx, groupByExpression, {pushStatement}, maxMemoryUsageBytes);
 
     string largeStr(maxMemoryUsageBytes, 'x');
-    auto mock = DocumentSourceMock::create({Document{{"_id", 0}, {"largeStr", largeStr}},
-                                            Document{{"_id", 1}, {"largeStr", largeStr}}});
+    auto mock = DocumentSourceMock::createForTest({Document{{"_id", 0}, {"largeStr", largeStr}},
+                                                   Document{{"_id", 1}, {"largeStr", largeStr}}});
     group->setSource(mock.get());
 
     ASSERT_THROWS_CODE(group->getNext(), AssertionException, 16945);
@@ -177,10 +179,11 @@ TEST_F(DocumentSourceGroupTest, ShouldCorrectlyTrackMemoryUsageBetweenPauses) {
         expCtx, groupByExpression, {pushStatement}, maxMemoryUsageBytes);
 
     string largeStr(maxMemoryUsageBytes / 2, 'x');
-    auto mock = DocumentSourceMock::create({Document{{"_id", 0}, {"largeStr", largeStr}},
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document{{"_id", 1}, {"largeStr", largeStr}},
-                                            Document{{"_id", 2}, {"largeStr", largeStr}}});
+    auto mock =
+        DocumentSourceMock::createForTest({Document{{"_id", 0}, {"largeStr", largeStr}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"_id", 1}, {"largeStr", largeStr}},
+                                           Document{{"_id", 2}, {"largeStr", largeStr}}});
     group->setSource(mock.get());
 
     // The first getNext() should pause.
@@ -322,7 +325,7 @@ public:
     virtual ~ExpressionBase() {}
     void _doTest() final {
         createGroup(spec());
-        auto source = DocumentSourceMock::create(Document(doc()));
+        auto source = DocumentSourceMock::createForTest(Document(doc()));
         group()->setSource(source.get());
         // A group result is available.
         auto next = group()->getNext();
@@ -558,7 +561,7 @@ public:
     }
     void runSharded(bool sharded) {
         createGroup(groupSpec());
-        auto source = DocumentSourceMock::create(inputData());
+        auto source = DocumentSourceMock::createForTest(inputData());
         group()->setSource(source.get());
 
         intrusive_ptr<DocumentSource> sink = group();
@@ -779,10 +782,10 @@ class UndefinedAccumulatorValue : public CheckResultsBase {
 class RouterMerger : public CheckResultsBase {
 public:
     void _doTest() final {
-        auto source = DocumentSourceMock::create({"{_id:0,list:[1,2]}",
-                                                  "{_id:1,list:[3,4]}",
-                                                  "{_id:0,list:[10,20]}",
-                                                  "{_id:1,list:[30,40]}]}"});
+        auto source = DocumentSourceMock::createForTest({"{_id:0,list:[1,2]}",
+                                                         "{_id:1,list:[3,4]}",
+                                                         "{_id:0,list:[10,20]}",
+                                                         "{_id:1,list:[30,40]}]}"});
 
         // Create a group source.
         createGroup(BSON("_id"
diff --git a/src/mongo/db/pipeline/document_source_limit_test.cpp b/src/mongo/db/pipeline/document_source_limit_test.cpp
index 05e65cd7e7f..014cc563510 100644
--- a/src/mongo/db/pipeline/document_source_limit_test.cpp
+++ b/src/mongo/db/pipeline/document_source_limit_test.cpp
@@ -47,7 +47,7 @@ namespace {
 using DocumentSourceLimitTest = AggregationContextFixture;
 
 TEST_F(DocumentSourceLimitTest, ShouldDisposeSourceWhenLimitIsReached) {
-    auto source = DocumentSourceMock::create({"{a: 1}", "{a: 2}"});
+    auto source = DocumentSourceMock::createForTest({"{a: 1}", "{a: 2}"});
     auto limit = DocumentSourceLimit::create(getExpCtx(), 1);
     limit->setSource(source.get());
     // The limit's result is as expected.
@@ -61,7 +61,7 @@ TEST_F(DocumentSourceLimitTest, ShouldDisposeSourceWhenLimitIsReached) {
 }
 
 TEST_F(DocumentSourceLimitTest, ShouldNotBeAbleToLimitToZeroDocuments) {
-    auto source = DocumentSourceMock::create({"{a: 1}", "{a: 2}"});
+    auto source = DocumentSourceMock::createForTest({"{a: 1}", "{a: 2}"});
     ASSERT_THROWS_CODE(DocumentSourceLimit::create(getExpCtx(), 0), AssertionException, 15958);
 }
 
@@ -91,7 +91,7 @@ TEST_F(DocumentSourceLimitTest, TwoLimitStagesShouldCombineIntoOne) {
 }
 
 TEST_F(DocumentSourceLimitTest, DisposeShouldCascadeAllTheWayToSource) {
-    auto source = DocumentSourceMock::create({"{a: 1}", "{a: 1}"});
+    auto source = DocumentSourceMock::createForTest({"{a: 1}", "{a: 1}"});
 
     // Create a DocumentSourceMatch.
     BSONObj spec = BSON("$match" << BSON("a" << 1));
@@ -121,12 +121,13 @@ TEST_F(DocumentSourceLimitTest, ShouldNotIntroduceAnyDependencies) {
 
 TEST_F(DocumentSourceLimitTest, ShouldPropagatePauses) {
     auto limit = DocumentSourceLimit::create(getExpCtx(), 2);
-    auto mock = DocumentSourceMock::create({DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document(),
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document(),
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document()});
+    auto mock =
+        DocumentSourceMock::createForTest({DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document(),
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document(),
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document()});
     limit->setSource(mock.get());
 
     ASSERT_TRUE(limit->getNext().isPaused());
diff --git a/src/mongo/db/pipeline/document_source_lookup_change_post_image_test.cpp b/src/mongo/db/pipeline/document_source_lookup_change_post_image_test.cpp
index 32ce6ebce8f..bd88e955337 100644
--- a/src/mongo/db/pipeline/document_source_lookup_change_post_image_test.cpp
+++ b/src/mongo/db/pipeline/document_source_lookup_change_post_image_test.cpp
@@ -85,7 +85,7 @@ TEST_F(DocumentSourceLookupChangePostImageTest, ShouldErrorIfMissingDocumentKeyO
     auto lookupChangeStage = DocumentSourceLookupChangePostImage::create(expCtx);
 
     // Mock its input with a document without a "documentKey" field.
-    auto mockLocalSource = DocumentSourceMock::create(
+    auto mockLocalSource = DocumentSourceMock::createForTest(
         Document{{"_id", makeResumeToken(0)},
                  {"operationType", "update"_sd},
                  {"fullDocument", Document{{"_id", 0}}},
@@ -107,7 +107,7 @@ TEST_F(DocumentSourceLookupChangePostImageTest, ShouldErrorIfMissingOperationTyp
     auto lookupChangeStage = DocumentSourceLookupChangePostImage::create(expCtx);
 
     // Mock its input with a document without a "ns" field.
-    auto mockLocalSource = DocumentSourceMock::create(
+    auto mockLocalSource = DocumentSourceMock::createForTest(
         Document{{"_id", makeResumeToken(0)},
                  {"documentKey", Document{{"_id", 0}}},
                  {"fullDocument", Document{{"_id", 0}}},
@@ -129,7 +129,7 @@ TEST_F(DocumentSourceLookupChangePostImageTest, ShouldErrorIfMissingNamespace) {
     auto lookupChangeStage = DocumentSourceLookupChangePostImage::create(expCtx);
 
     // Mock its input with a document without a "ns" field.
-    auto mockLocalSource = DocumentSourceMock::create(Document{
+    auto mockLocalSource = DocumentSourceMock::createForTest(Document{
         {"_id", makeResumeToken(0)},
         {"documentKey", Document{{"_id", 0}}},
         {"operationType", "update"_sd},
@@ -152,10 +152,10 @@ TEST_F(DocumentSourceLookupChangePostImageTest, ShouldErrorIfNsFieldHasWrongType
 
     // Mock its input with a document without a "ns" field.
     auto mockLocalSource =
-        DocumentSourceMock::create(Document{{"_id", makeResumeToken(0)},
-                                            {"documentKey", Document{{"_id", 0}}},
-                                            {"operationType", "update"_sd},
-                                            {"ns", 4}});
+        DocumentSourceMock::createForTest(Document{{"_id", makeResumeToken(0)},
+                                                   {"documentKey", Document{{"_id", 0}}},
+                                                   {"operationType", "update"_sd},
+                                                   {"ns", 4}});
 
     lookupChangeStage->setSource(mockLocalSource.get());
 
@@ -173,7 +173,7 @@ TEST_F(DocumentSourceLookupChangePostImageTest, ShouldErrorIfNsFieldDoesNotMatch
     auto lookupChangeStage = DocumentSourceLookupChangePostImage::create(expCtx);
 
     // Mock its input with a document without a "ns" field.
-    auto mockLocalSource = DocumentSourceMock::create(
+    auto mockLocalSource = DocumentSourceMock::createForTest(
         Document{{"_id", makeResumeToken(0)},
                  {"documentKey", Document{{"_id", 0}}},
                  {"operationType", "update"_sd},
@@ -197,7 +197,7 @@ TEST_F(DocumentSourceLookupChangePostImageTest, ShouldErrorIfDatabaseMismatchOnC
     auto lookupChangeStage = DocumentSourceLookupChangePostImage::create(expCtx);
 
     // Mock its input with a document without a "ns" field.
-    auto mockLocalSource = DocumentSourceMock::create(
+    auto mockLocalSource = DocumentSourceMock::createForTest(
         Document{{"_id", makeResumeToken(0)},
                  {"documentKey", Document{{"_id", 0}}},
                  {"operationType", "update"_sd},
@@ -224,7 +224,7 @@ TEST_F(DocumentSourceLookupChangePostImageTest, ShouldPassIfDatabaseMatchesOnCol
     deque<DocumentSource::GetNextResult> mockForeignContents{Document{{"_id", 0}}};
     expCtx->mongoProcessInterface = stdx::make_unique<MockMongoInterface>(mockForeignContents);
 
-    auto mockLocalSource = DocumentSourceMock::create(
+    auto mockLocalSource = DocumentSourceMock::createForTest(
         Document{{"_id", makeResumeToken(0)},
                  {"documentKey", Document{{"_id", 0}}},
                  {"operationType", "update"_sd},
@@ -250,7 +250,7 @@ TEST_F(DocumentSourceLookupChangePostImageTest, ShouldErrorIfDocumentKeyIsNotUni
     auto lookupChangeStage = DocumentSourceLookupChangePostImage::create(expCtx);
 
     // Mock its input with an update document.
-    auto mockLocalSource = DocumentSourceMock::create(
+    auto mockLocalSource = DocumentSourceMock::createForTest(
         Document{{"_id", makeResumeToken(0)},
                  {"documentKey", Document{{"_id", 0}}},
                  {"operationType", "update"_sd},
@@ -275,7 +275,7 @@ TEST_F(DocumentSourceLookupChangePostImageTest, ShouldPropagatePauses) {
     auto lookupChangeStage = DocumentSourceLookupChangePostImage::create(expCtx);
 
     // Mock its input, pausing every other result.
-    auto mockLocalSource = DocumentSourceMock::create(
+    auto mockLocalSource = DocumentSourceMock::createForTest(
         {Document{{"_id", makeResumeToken(0)},
                   {"documentKey", Document{{"_id", 0}}},
                   {"operationType", "insert"_sd},
diff --git a/src/mongo/db/pipeline/document_source_lookup_test.cpp b/src/mongo/db/pipeline/document_source_lookup_test.cpp
index 6c7d8660b62..fbbf487c424 100644
--- a/src/mongo/db/pipeline/document_source_lookup_test.cpp
+++ b/src/mongo/db/pipeline/document_source_lookup_test.cpp
@@ -534,7 +534,7 @@ public:
             break;
         }
 
-        pipeline->addInitialSource(DocumentSourceMock::create(_mockResults));
+        pipeline->addInitialSource(DocumentSourceMock::createForTest(_mockResults));
         return pipeline;
     }
 
@@ -561,10 +561,10 @@ TEST_F(DocumentSourceLookUpTest, ShouldPropagatePauses) {
 
     // Mock its input, pausing every other result.
     auto mockLocalSource =
-        DocumentSourceMock::create({Document{{"foreignId", 0}},
-                                    DocumentSource::GetNextResult::makePauseExecution(),
-                                    Document{{"foreignId", 1}},
-                                    DocumentSource::GetNextResult::makePauseExecution()});
+        DocumentSourceMock::createForTest({Document{{"foreignId", 0}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"foreignId", 1}},
+                                           DocumentSource::GetNextResult::makePauseExecution()});
 
     lookup->setSource(mockLocalSource.get());
 
@@ -618,10 +618,10 @@ TEST_F(DocumentSourceLookUpTest, ShouldPropagatePausesWhileUnwinding) {
 
     // Mock its input, pausing every other result.
     auto mockLocalSource =
-        DocumentSourceMock::create({Document{{"foreignId", 0}},
-                                    DocumentSource::GetNextResult::makePauseExecution(),
-                                    Document{{"foreignId", 1}},
-                                    DocumentSource::GetNextResult::makePauseExecution()});
+        DocumentSourceMock::createForTest({Document{{"foreignId", 0}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"foreignId", 1}},
+                                           DocumentSource::GetNextResult::makePauseExecution()});
     lookup->setSource(mockLocalSource.get());
 
     // Mock out the foreign collection.
@@ -971,7 +971,7 @@ TEST_F(DocumentSourceLookUpTest,
     ASSERT(lookupStage);
 
     // Prepare the mocked local and foreign sources.
-    auto mockLocalSource = DocumentSourceMock::create(
+    auto mockLocalSource = DocumentSourceMock::createForTest(
         {Document{{"_id", 0}}, Document{{"_id", 1}}, Document{{"_id", 2}}});
 
     lookupStage->setSource(mockLocalSource.get());
@@ -1049,7 +1049,8 @@ TEST_F(DocumentSourceLookUpTest,
     ASSERT(lookupStage);
 
     // Prepare the mocked local and foreign sources.
-    auto mockLocalSource = DocumentSourceMock::create({Document{{"_id", 0}}, Document{{"_id", 1}}});
+    auto mockLocalSource =
+        DocumentSourceMock::createForTest({Document{{"_id", 0}}, Document{{"_id", 1}}});
 
     lookupStage->setSource(mockLocalSource.get());
 
diff --git a/src/mongo/db/pipeline/document_source_match_test.cpp b/src/mongo/db/pipeline/document_source_match_test.cpp
index 270e9515cc5..9449f9b55c2 100644
--- a/src/mongo/db/pipeline/document_source_match_test.cpp
+++ b/src/mongo/db/pipeline/document_source_match_test.cpp
@@ -477,13 +477,14 @@ TEST_F(DocumentSourceMatchTest, MultipleMatchStagesShouldCombineIntoOne) {
 
 TEST_F(DocumentSourceMatchTest, ShouldPropagatePauses) {
     auto match = DocumentSourceMatch::create(BSON("a" << 1), getExpCtx());
-    auto mock = DocumentSourceMock::create({DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document{{"a", 1}},
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document{{"a", 2}},
-                                            Document{{"a", 2}},
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document{{"a", 1}}});
+    auto mock =
+        DocumentSourceMock::createForTest({DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"a", 1}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"a", 2}},
+                                           Document{{"a", 2}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"a", 1}}});
     match->setSource(mock.get());
 
     ASSERT_TRUE(match->getNext().isPaused());
@@ -504,10 +505,10 @@ TEST_F(DocumentSourceMatchTest, ShouldCorrectlyJoinWithSubsequentMatch) {
 
     match->joinMatchWith(secondMatch);
 
-    const auto mock = DocumentSourceMock::create({Document{{"a", 1}, {"b", 1}},
-                                                  Document{{"a", 2}, {"b", 1}},
-                                                  Document{{"a", 1}, {"b", 2}},
-                                                  Document{{"a", 2}, {"b", 2}}});
+    const auto mock = DocumentSourceMock::createForTest({Document{{"a", 1}, {"b", 1}},
+                                                         Document{{"a", 2}, {"b", 1}},
+                                                         Document{{"a", 1}, {"b", 2}},
+                                                         Document{{"a", 2}, {"b", 2}}});
 
     match->setSource(mock.get());
 
@@ -565,7 +566,7 @@ TEST_F(DocumentSourceMatchTest, ShouldMatchCorrectlyAfterDescendingMatch) {
 
     const auto descendedMatch =
         DocumentSourceMatch::descendMatchOnPath(matchExpression.get(), "a", expCtx);
-    const auto mock = DocumentSourceMock::create(
+    const auto mock = DocumentSourceMock::createForTest(
         {Document{{"b", 1}, {"c", 1}, {"d", 1}},
          Document{{"b", 1}, {"a", Document{{"c", 1}}}, {"d", 1}},
          Document{{"a", Document{{"b", 1}}}, {"a", Document{{"c", 1}}}, {"d", 1}},
@@ -588,7 +589,7 @@ TEST_F(DocumentSourceMatchTest, ShouldCorrectlyEvaluateElemMatchPredicate) {
 
     const std::vector<Document> matchingVector = {Document{{"b", 0}}, Document{{"b", 1}}};
     const std::vector<Document> nonMatchingVector = {Document{{"b", 0}}, Document{{"b", 2}}};
-    const auto mock = DocumentSourceMock::create(
+    const auto mock = DocumentSourceMock::createForTest(
         {Document{{"a", matchingVector}}, Document{{"a", nonMatchingVector}}, Document{{"a", 1}}});
 
     match->setSource(mock.get());
@@ -608,7 +609,7 @@ TEST_F(DocumentSourceMatchTest, ShouldCorrectlyEvaluateJSONSchemaPredicate) {
     const auto match = DocumentSourceMatch::create(
         fromjson("{$jsonSchema: {properties: {a: {type: 'number'}}}}"), getExpCtx());
 
-    const auto mock = DocumentSourceMock::create(
+    const auto mock = DocumentSourceMock::createForTest(
         {Document{{"a", 1}}, Document{{"a", "str"_sd}}, Document{{"a", {Document{{0, 1}}}}}});
 
     match->setSource(mock.get());
diff --git a/src/mongo/db/pipeline/document_source_mock.cpp b/src/mongo/db/pipeline/document_source_mock.cpp
index 86aa733d53d..0f15b96a038 100644
--- a/src/mongo/db/pipeline/document_source_mock.cpp
+++ b/src/mongo/db/pipeline/document_source_mock.cpp
@@ -63,28 +63,28 @@ void DocumentSourceMock::doDispose() {
     isDisposed = true;
 }
 
-intrusive_ptr<DocumentSourceMock> DocumentSourceMock::create(Document doc) {
+intrusive_ptr<DocumentSourceMock> DocumentSourceMock::createForTest(Document doc) {
     return new DocumentSourceMock({std::move(doc)});
 }
 
-intrusive_ptr<DocumentSourceMock> DocumentSourceMock::create(deque<GetNextResult> results) {
+intrusive_ptr<DocumentSourceMock> DocumentSourceMock::createForTest(deque<GetNextResult> results) {
     return new DocumentSourceMock(std::move(results));
 }
 
-intrusive_ptr<DocumentSourceMock> DocumentSourceMock::create() {
+intrusive_ptr<DocumentSourceMock> DocumentSourceMock::createForTest() {
     return new DocumentSourceMock(deque<GetNextResult>());
 }
 
-intrusive_ptr<DocumentSourceMock> DocumentSourceMock::create(const GetNextResult& result) {
+intrusive_ptr<DocumentSourceMock> DocumentSourceMock::createForTest(const GetNextResult& result) {
     deque<GetNextResult> results = {result};
     return new DocumentSourceMock(std::move(results));
 }
 
-intrusive_ptr<DocumentSourceMock> DocumentSourceMock::create(const char* json) {
-    return create(Document(fromjson(json)));
+intrusive_ptr<DocumentSourceMock> DocumentSourceMock::createForTest(const char* json) {
+    return createForTest(Document(fromjson(json)));
 }
 
-intrusive_ptr<DocumentSourceMock> DocumentSourceMock::create(
+intrusive_ptr<DocumentSourceMock> DocumentSourceMock::createForTest(
     const std::initializer_list<const char*>& jsons) {
     deque<GetNextResult> results;
     for (auto&& json : jsons) {
@@ -93,6 +93,11 @@ intrusive_ptr<DocumentSourceMock> DocumentSourceMock::create(
     return new DocumentSourceMock(std::move(results));
 }
 
+boost::intrusive_ptr<DocumentSourceMock> DocumentSourceMock::create(
+    const boost::intrusive_ptr<ExpressionContext>& expCtx) {
+    return new DocumentSourceMock({}, expCtx);
+}
+
 DocumentSource::GetNextResult DocumentSourceMock::getNext() {
     invariant(!isDisposed);
     invariant(!isDetachedFromOpCtx);
diff --git a/src/mongo/db/pipeline/document_source_mock.h b/src/mongo/db/pipeline/document_source_mock.h
index 3fb65ba7c13..4eece861727 100644
--- a/src/mongo/db/pipeline/document_source_mock.h
+++ b/src/mongo/db/pipeline/document_source_mock.h
@@ -62,17 +62,25 @@ public:
         return constraints;
     }
 
-    static boost::intrusive_ptr<DocumentSourceMock> create();
+    // Constructors which create their own ExpressionContextForTest. Do _not_ use these outside of
+    // tests, as they will spin up ServiceContexts (TODO SERVER-41060).
+    static boost::intrusive_ptr<DocumentSourceMock> createForTest();
 
-    static boost::intrusive_ptr<DocumentSourceMock> create(Document doc);
+    static boost::intrusive_ptr<DocumentSourceMock> createForTest(Document doc);
 
-    static boost::intrusive_ptr<DocumentSourceMock> create(const GetNextResult& result);
-    static boost::intrusive_ptr<DocumentSourceMock> create(std::deque<GetNextResult> results);
+    static boost::intrusive_ptr<DocumentSourceMock> createForTest(const GetNextResult& result);
+    static boost::intrusive_ptr<DocumentSourceMock> createForTest(
+        std::deque<GetNextResult> results);
 
-    static boost::intrusive_ptr<DocumentSourceMock> create(const char* json);
-    static boost::intrusive_ptr<DocumentSourceMock> create(
+    static boost::intrusive_ptr<DocumentSourceMock> createForTest(const char* json);
+    static boost::intrusive_ptr<DocumentSourceMock> createForTest(
         const std::initializer_list<const char*>& jsons);
 
+    // Use these constructors outside of tests.
+    // TODO: SERVER-40539 this should no longer be necessary once there's a DocumentSourceQueue.
+    static boost::intrusive_ptr<DocumentSourceMock> create(
+        const boost::intrusive_ptr<ExpressionContext>& expCtx);
+
     void reattachToOperationContext(OperationContext* opCtx) {
         isDetachedFromOpCtx = false;
     }
diff --git a/src/mongo/db/pipeline/document_source_mock_test.cpp b/src/mongo/db/pipeline/document_source_mock_test.cpp
index 73c02f7dc25..c377796460e 100644
--- a/src/mongo/db/pipeline/document_source_mock_test.cpp
+++ b/src/mongo/db/pipeline/document_source_mock_test.cpp
@@ -32,6 +32,7 @@
 #include "mongo/db/pipeline/document.h"
 #include "mongo/db/pipeline/document_source_mock.h"
 #include "mongo/db/pipeline/document_value_test_util.h"
+#include "mongo/db/pipeline/expression_context_for_test.h"
 #include "mongo/unittest/unittest.h"
 
 namespace mongo {
@@ -39,22 +40,23 @@ namespace {
 
 TEST(DocumentSourceMockTest, OneDoc) {
     auto doc = Document{{"a", 1}};
-    auto source = DocumentSourceMock::create(doc);
+    auto source = DocumentSourceMock::createForTest(doc);
     ASSERT_DOCUMENT_EQ(source->getNext().getDocument(), doc);
     ASSERT(source->getNext().isEOF());
 }
 
 TEST(DocumentSourceMockTest, ShouldBeConstructableFromInitializerListOfDocuments) {
-    auto source = DocumentSourceMock::create({Document{{"a", 1}}, Document{{"a", 2}}});
+    auto source = DocumentSourceMock::createForTest({Document{{"a", 1}}, Document{{"a", 2}}});
     ASSERT_DOCUMENT_EQ(source->getNext().getDocument(), (Document{{"a", 1}}));
     ASSERT_DOCUMENT_EQ(source->getNext().getDocument(), (Document{{"a", 2}}));
     ASSERT(source->getNext().isEOF());
 }
 
 TEST(DocumentSourceMockTest, ShouldBeConstructableFromDequeOfResults) {
-    auto source = DocumentSourceMock::create({Document{{"a", 1}},
-                                              DocumentSource::GetNextResult::makePauseExecution(),
-                                              Document{{"a", 2}}});
+    auto source =
+        DocumentSourceMock::createForTest({Document{{"a", 1}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"a", 2}}});
     ASSERT_DOCUMENT_EQ(source->getNext().getDocument(), (Document{{"a", 1}}));
     ASSERT_TRUE(source->getNext().isPaused());
     ASSERT_DOCUMENT_EQ(source->getNext().getDocument(), (Document{{"a", 2}}));
@@ -62,20 +64,27 @@ TEST(DocumentSourceMockTest, ShouldBeConstructableFromDequeOfResults) {
 }
 
 TEST(DocumentSourceMockTest, StringJSON) {
-    auto source = DocumentSourceMock::create("{a : 1}");
+    auto source = DocumentSourceMock::createForTest("{a : 1}");
     ASSERT_DOCUMENT_EQ(source->getNext().getDocument(), (Document{{"a", 1}}));
     ASSERT(source->getNext().isEOF());
 }
 
 TEST(DocumentSourceMockTest, DequeStringJSONs) {
-    auto source = DocumentSourceMock::create({"{a: 1}", "{a: 2}"});
+    auto source = DocumentSourceMock::createForTest({"{a: 1}", "{a: 2}"});
     ASSERT_DOCUMENT_EQ(source->getNext().getDocument(), (Document{{"a", 1}}));
     ASSERT_DOCUMENT_EQ(source->getNext().getDocument(), (Document{{"a", 2}}));
     ASSERT(source->getNext().isEOF());
 }
 
 TEST(DocumentSourceMockTest, Empty) {
-    auto source = DocumentSourceMock::create();
+    auto source = DocumentSourceMock::createForTest();
+    ASSERT(source->getNext().isEOF());
+}
+
+TEST(DocumentSourceMockTest, NonTestConstructor) {
+    boost::intrusive_ptr<ExpressionContextForTest> expCtx(new ExpressionContextForTest());
+
+    auto source = DocumentSourceMock::create(expCtx);
     ASSERT(source->getNext().isEOF());
 }
 
diff --git a/src/mongo/db/pipeline/document_source_project_test.cpp b/src/mongo/db/pipeline/document_source_project_test.cpp
index a74293ebeaa..72820144d33 100644
--- a/src/mongo/db/pipeline/document_source_project_test.cpp
+++ b/src/mongo/db/pipeline/document_source_project_test.cpp
@@ -61,7 +61,7 @@ using ProjectStageTest = AggregationContextFixture;
 TEST_F(ProjectStageTest, InclusionProjectionShouldRemoveUnspecifiedFields) {
     auto project =
         DocumentSourceProject::create(BSON("a" << true << "c" << BSON("d" << true)), getExpCtx());
-    auto source = DocumentSourceMock::create("{_id: 0, a: 1, b: 1, c: {d: 1}}");
+    auto source = DocumentSourceMock::createForTest("{_id: 0, a: 1, b: 1, c: {d: 1}}");
     project->setSource(source.get());
     // The first result exists and is as expected.
     auto next = project->getNext();
@@ -99,7 +99,7 @@ TEST_F(ProjectStageTest, ShouldErrorOnNonObjectSpec) {
  */
 TEST_F(ProjectStageTest, InclusionShouldBeAbleToProcessMultipleDocuments) {
     auto project = DocumentSourceProject::create(BSON("a" << true), getExpCtx());
-    auto source = DocumentSourceMock::create({"{a: 1, b: 2}", "{a: 3, b: 4}"});
+    auto source = DocumentSourceMock::createForTest({"{a: 1, b: 2}", "{a: 3, b: 4}"});
     project->setSource(source.get());
     auto next = project->getNext();
     ASSERT(next.isAdvanced());
@@ -122,7 +122,7 @@ TEST_F(ProjectStageTest, InclusionShouldBeAbleToProcessMultipleDocuments) {
  */
 TEST_F(ProjectStageTest, ExclusionShouldBeAbleToProcessMultipleDocuments) {
     auto project = DocumentSourceProject::create(BSON("a" << false), getExpCtx());
-    auto source = DocumentSourceMock::create({"{a: 1, b: 2}", "{a: 3, b: 4}"});
+    auto source = DocumentSourceMock::createForTest({"{a: 1, b: 2}", "{a: 3, b: 4}"});
     project->setSource(source.get());
     auto next = project->getNext();
     ASSERT(next.isAdvanced());
@@ -141,12 +141,13 @@ TEST_F(ProjectStageTest, ExclusionShouldBeAbleToProcessMultipleDocuments) {
 
 TEST_F(ProjectStageTest, ShouldPropagatePauses) {
     auto project = DocumentSourceProject::create(BSON("a" << false), getExpCtx());
-    auto source = DocumentSourceMock::create({Document(),
-                                              DocumentSource::GetNextResult::makePauseExecution(),
-                                              Document(),
-                                              DocumentSource::GetNextResult::makePauseExecution(),
-                                              Document(),
-                                              DocumentSource::GetNextResult::makePauseExecution()});
+    auto source =
+        DocumentSourceMock::createForTest({Document(),
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document(),
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document(),
+                                           DocumentSource::GetNextResult::makePauseExecution()});
     project->setSource(source.get());
 
     ASSERT_TRUE(project->getNext().isAdvanced());
@@ -249,7 +250,7 @@ TEST_F(ProjectStageTest, ExclusionProjectionReportsExcludedPathsWithIdExclusion)
 TEST_F(ProjectStageTest, CanUseRemoveSystemVariableToConditionallyExcludeProjectedField) {
     auto project = DocumentSourceProject::create(
         fromjson("{a: 1, b: {$cond: [{$eq: ['$b', 4]}, '$$REMOVE', '$b']}}"), getExpCtx());
-    auto source = DocumentSourceMock::create({"{a: 2, b: 2}", "{a: 3, b: 4}"});
+    auto source = DocumentSourceMock::createForTest({"{a: 2, b: 2}", "{a: 3, b: 4}"});
     project->setSource(source.get());
     auto next = project->getNext();
     ASSERT(next.isAdvanced());
@@ -281,7 +282,7 @@ BSONObj makeProjectForNestedDocument(size_t depth) {
 TEST_F(ProjectStageTest, CanAddNestedDocumentExactlyAtDepthLimit) {
     auto project = DocumentSourceProject::create(
         makeProjectForNestedDocument(BSONDepth::getMaxAllowableDepth()), getExpCtx());
-    auto mock = DocumentSourceMock::create(Document{{"_id", 1}});
+    auto mock = DocumentSourceMock::createForTest(Document{{"_id", 1}});
     project->setSource(mock.get());
 
     auto next = project->getNext();
diff --git a/src/mongo/db/pipeline/document_source_redact_test.cpp b/src/mongo/db/pipeline/document_source_redact_test.cpp
index 123c8e82fbf..1c4ddf60f92 100644
--- a/src/mongo/db/pipeline/document_source_redact_test.cpp
+++ b/src/mongo/db/pipeline/document_source_redact_test.cpp
@@ -65,10 +65,11 @@ TEST_F(DocumentSourceRedactTest, ShouldPropagatePauses) {
     auto redactSpec = BSON("$redact"
                            << "$$KEEP");
     auto redact = DocumentSourceRedact::createFromBson(redactSpec.firstElement(), getExpCtx());
-    auto mock = DocumentSourceMock::create({Document{{"_id", 0}},
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document{{"_id", 1}},
-                                            DocumentSource::GetNextResult::makePauseExecution()});
+    auto mock =
+        DocumentSourceMock::createForTest({Document{{"_id", 0}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"_id", 1}},
+                                           DocumentSource::GetNextResult::makePauseExecution()});
     redact->setSource(mock.get());
 
     // The $redact is keeping everything, so we should see everything from the mock, then EOF.
diff --git a/src/mongo/db/pipeline/document_source_replace_root_test.cpp b/src/mongo/db/pipeline/document_source_replace_root_test.cpp
index 2616a37b46f..52f668bc630 100644
--- a/src/mongo/db/pipeline/document_source_replace_root_test.cpp
+++ b/src/mongo/db/pipeline/document_source_replace_root_test.cpp
@@ -70,7 +70,7 @@ TEST_F(ReplaceRootBasics, FieldPathAsNewRootPromotesSubdocument) {
     auto replaceRoot = createReplaceRoot(BSON("newRoot"
                                               << "$a"));
     Document subdoc = Document{{"b", 1}, {"c", "hello"_sd}, {"d", Document{{"e", 2}}}};
-    auto mock = DocumentSourceMock::create(Document{{"a", subdoc}});
+    auto mock = DocumentSourceMock::createForTest(Document{{"a", subdoc}});
     replaceRoot->setSource(mock.get());
 
     auto next = replaceRoot->getNext();
@@ -86,7 +86,7 @@ TEST_F(ReplaceRootBasics, DottedFieldPathAsNewRootPromotesSubdocument) {
                                               << "$a.b"));
     // source document: {a: {b: {c: 3}}}
     Document subdoc = Document{{"c", 3}};
-    auto mock = DocumentSourceMock::create(Document{{"a", Document{{"b", subdoc}}}});
+    auto mock = DocumentSourceMock::createForTest(Document{{"a", Document{{"b", subdoc}}}});
     replaceRoot->setSource(mock.get());
 
     auto next = replaceRoot->getNext();
@@ -102,7 +102,8 @@ TEST_F(ReplaceRootBasics, FieldPathAsNewRootPromotesSubdocumentInMultipleDocumen
                                               << "$a"));
     Document subdoc1 = Document{{"b", 1}, {"c", 2}};
     Document subdoc2 = Document{{"b", 3}, {"c", 4}};
-    auto mock = DocumentSourceMock::create({Document{{"a", subdoc1}}, Document{{"a", subdoc2}}});
+    auto mock =
+        DocumentSourceMock::createForTest({Document{{"a", subdoc1}}, Document{{"a", subdoc2}}});
     replaceRoot->setSource(mock.get());
 
     // Verify that the first document that comes out is the first document we put in.
@@ -121,7 +122,7 @@ TEST_F(ReplaceRootBasics, FieldPathAsNewRootPromotesSubdocumentInMultipleDocumen
 // object.
 TEST_F(ReplaceRootBasics, ExpressionObjectForNewRootReplacesRootWithThatObject) {
     auto replaceRoot = createReplaceRoot(BSON("newRoot" << BSON("b" << 1)));
-    auto mock = DocumentSourceMock::create(Document{{"a", 2}});
+    auto mock = DocumentSourceMock::createForTest(Document{{"a", 2}});
     replaceRoot->setSource(mock.get());
 
     auto next = replaceRoot->getNext();
@@ -131,7 +132,7 @@ TEST_F(ReplaceRootBasics, ExpressionObjectForNewRootReplacesRootWithThatObject)
 
     BSONObj newObject = BSON("a" << 1 << "b" << 2 << "arr" << BSON_ARRAY(3 << 4 << 5));
     replaceRoot = createReplaceRoot(BSON("newRoot" << newObject));
-    mock = DocumentSourceMock::create(Document{{"c", 2}});
+    mock = DocumentSourceMock::createForTest(Document{{"c", 2}});
     replaceRoot->setSource(mock.get());
 
     next = replaceRoot->getNext();
@@ -140,7 +141,7 @@ TEST_F(ReplaceRootBasics, ExpressionObjectForNewRootReplacesRootWithThatObject)
     assertExhausted(replaceRoot);
 
     replaceRoot = createReplaceRoot(BSON("newRoot" << BSON("a" << BSON("b" << 1))));
-    mock = DocumentSourceMock::create(Document{{"c", 2}});
+    mock = DocumentSourceMock::createForTest(Document{{"c", 2}});
     replaceRoot->setSource(mock.get());
 
     next = replaceRoot->getNext();
@@ -149,7 +150,7 @@ TEST_F(ReplaceRootBasics, ExpressionObjectForNewRootReplacesRootWithThatObject)
     assertExhausted(replaceRoot);
 
     replaceRoot = createReplaceRoot(BSON("newRoot" << BSON("a" << 2)));
-    mock = DocumentSourceMock::create(Document{{"b", 2}});
+    mock = DocumentSourceMock::createForTest(Document{{"b", 2}});
     replaceRoot->setSource(mock.get());
 
     next = replaceRoot->getNext();
@@ -165,7 +166,7 @@ TEST_F(ReplaceRootBasics, SystemVariableForNewRootReplacesRootWithThatObject) {
     auto replaceRoot = createReplaceRoot(BSON("newRoot"
                                               << "$$CURRENT"));
     Document inputDoc = Document{{"b", 2}};
-    auto mock = DocumentSourceMock::create({inputDoc});
+    auto mock = DocumentSourceMock::createForTest({inputDoc});
     replaceRoot->setSource(mock.get());
 
     auto next = replaceRoot->getNext();
@@ -175,7 +176,7 @@ TEST_F(ReplaceRootBasics, SystemVariableForNewRootReplacesRootWithThatObject) {
 
     replaceRoot = createReplaceRoot(BSON("newRoot"
                                          << "$$ROOT"));
-    mock = DocumentSourceMock::create({inputDoc});
+    mock = DocumentSourceMock::createForTest({inputDoc});
     replaceRoot->setSource(mock.get());
 
     next = replaceRoot->getNext();
@@ -187,12 +188,13 @@ TEST_F(ReplaceRootBasics, SystemVariableForNewRootReplacesRootWithThatObject) {
 TEST_F(ReplaceRootBasics, ShouldPropagatePauses) {
     auto replaceRoot = createReplaceRoot(BSON("newRoot"
                                               << "$$ROOT"));
-    auto mock = DocumentSourceMock::create({Document(),
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document(),
-                                            Document(),
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            DocumentSource::GetNextResult::makePauseExecution()});
+    auto mock =
+        DocumentSourceMock::createForTest({Document(),
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document(),
+                                           Document(),
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           DocumentSource::GetNextResult::makePauseExecution()});
     replaceRoot->setSource(mock.get());
 
     ASSERT_TRUE(replaceRoot->getNext().isAdvanced());
@@ -212,18 +214,18 @@ TEST_F(ReplaceRootBasics, ErrorsWhenNewRootDoesNotEvaluateToAnObject) {
                                               << "$a"));
 
     // A string is not an object.
-    auto mock = DocumentSourceMock::create(Document{{"a", "hello"_sd}});
+    auto mock = DocumentSourceMock::createForTest(Document{{"a", "hello"_sd}});
     replaceRoot->setSource(mock.get());
     ASSERT_THROWS_CODE(replaceRoot->getNext(), AssertionException, 40228);
 
     // An integer is not an object.
-    mock = DocumentSourceMock::create(Document{{"a", 5}});
+    mock = DocumentSourceMock::createForTest(Document{{"a", 5}});
     replaceRoot->setSource(mock.get());
     ASSERT_THROWS_CODE(replaceRoot->getNext(), AssertionException, 40228);
 
     // Literals are not objects.
     replaceRoot = createReplaceRoot(BSON("newRoot" << BSON("$literal" << 1)));
-    mock = DocumentSourceMock::create(Document());
+    mock = DocumentSourceMock::createForTest(Document());
     replaceRoot->setSource(mock.get());
     ASSERT_THROWS_CODE(replaceRoot->getNext(), AssertionException, 40228);
     assertExhausted(replaceRoot);
@@ -231,7 +233,7 @@ TEST_F(ReplaceRootBasics, ErrorsWhenNewRootDoesNotEvaluateToAnObject) {
     // Most operator expressions do not resolve to objects.
     replaceRoot = createReplaceRoot(BSON("newRoot" << BSON("$and"
                                                            << "$a")));
-    mock = DocumentSourceMock::create(Document{{"a", true}});
+    mock = DocumentSourceMock::createForTest(Document{{"a", true}});
     replaceRoot->setSource(mock.get());
     ASSERT_THROWS_CODE(replaceRoot->getNext(), AssertionException, 40228);
     assertExhausted(replaceRoot);
@@ -243,12 +245,12 @@ TEST_F(ReplaceRootBasics, ErrorsIfNewRootFieldPathDoesNotExist) {
     auto replaceRoot = createReplaceRoot(BSON("newRoot"
                                               << "$a"));
 
-    auto mock = DocumentSourceMock::create(Document());
+    auto mock = DocumentSourceMock::createForTest(Document());
     replaceRoot->setSource(mock.get());
     ASSERT_THROWS_CODE(replaceRoot->getNext(), AssertionException, 40228);
     assertExhausted(replaceRoot);
 
-    mock = DocumentSourceMock::create(Document{{"e", Document{{"b", Document{{"c", 3}}}}}});
+    mock = DocumentSourceMock::createForTest(Document{{"e", Document{{"b", Document{{"c", 3}}}}}});
     replaceRoot->setSource(mock.get());
     ASSERT_THROWS_CODE(replaceRoot->getNext(), AssertionException, 40228);
     assertExhausted(replaceRoot);
@@ -285,7 +287,7 @@ TEST_F(ReplaceRootBasics, ReplaceRootWithRemoveSystemVariableThrows) {
     auto replaceRoot = createReplaceRoot(BSON("newRoot"
                                               << "$$REMOVE"));
     Document inputDoc = Document{{"b", 2}};
-    auto mock = DocumentSourceMock::create({inputDoc});
+    auto mock = DocumentSourceMock::createForTest({inputDoc});
     replaceRoot->setSource(mock.get());
 
     ASSERT_THROWS_CODE(replaceRoot->getNext(), AssertionException, 40228);
diff --git a/src/mongo/db/pipeline/document_source_sample_test.cpp b/src/mongo/db/pipeline/document_source_sample_test.cpp
index 2fd4a120c22..f177edd6acc 100644
--- a/src/mongo/db/pipeline/document_source_sample_test.cpp
+++ b/src/mongo/db/pipeline/document_source_sample_test.cpp
@@ -54,7 +54,7 @@ using boost::intrusive_ptr;
 
 class SampleBasics : public AggregationContextFixture {
 public:
-    SampleBasics() : _mock(DocumentSourceMock::create()) {}
+    SampleBasics() : _mock(DocumentSourceMock::createForTest()) {}
 
 protected:
     virtual void createSample(long long size) {
diff --git a/src/mongo/db/pipeline/document_source_skip_test.cpp b/src/mongo/db/pipeline/document_source_skip_test.cpp
index 74781e96a05..a864ae23b22 100644
--- a/src/mongo/db/pipeline/document_source_skip_test.cpp
+++ b/src/mongo/db/pipeline/document_source_skip_test.cpp
@@ -44,12 +44,13 @@ using DocumentSourceSkipTest = AggregationContextFixture;
 
 TEST_F(DocumentSourceSkipTest, ShouldPropagatePauses) {
     auto skip = DocumentSourceSkip::create(getExpCtx(), 2);
-    auto mock = DocumentSourceMock::create({Document(),
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document(),
-                                            Document(),
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            DocumentSource::GetNextResult::makePauseExecution()});
+    auto mock =
+        DocumentSourceMock::createForTest({Document(),
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document(),
+                                           Document(),
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           DocumentSource::GetNextResult::makePauseExecution()});
     skip->setSource(mock.get());
 
     // Skip the first document.
diff --git a/src/mongo/db/pipeline/document_source_sort_test.cpp b/src/mongo/db/pipeline/document_source_sort_test.cpp
index 6937cee08b5..78936091362 100644
--- a/src/mongo/db/pipeline/document_source_sort_test.cpp
+++ b/src/mongo/db/pipeline/document_source_sort_test.cpp
@@ -189,7 +189,7 @@ public:
                       BSONObj sortSpec,
                       string expectedResultSetString) {
         createSort(sortSpec);
-        auto source = DocumentSourceMock::create(inputDocs);
+        auto source = DocumentSourceMock::createForTest(inputDocs);
         sort()->setSource(source.get());
 
         // Load the results from the DocumentSourceUnwind.
@@ -351,9 +351,10 @@ TEST_F(DocumentSourceSortExecutionTest, ExtractArrayValues) {
 
 TEST_F(DocumentSourceSortExecutionTest, ShouldPauseWhenAskedTo) {
     auto sort = DocumentSourceSort::create(getExpCtx(), BSON("a" << 1));
-    auto mock = DocumentSourceMock::create({DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document{{"a", 0}},
-                                            DocumentSource::GetNextResult::makePauseExecution()});
+    auto mock =
+        DocumentSourceMock::createForTest({DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"a", 0}},
+                                           DocumentSource::GetNextResult::makePauseExecution()});
     sort->setSource(mock.get());
 
     // Should propagate the first pause.
@@ -370,9 +371,10 @@ TEST_F(DocumentSourceSortExecutionTest, ShouldPauseWhenAskedTo) {
 
 TEST_F(DocumentSourceSortExecutionTest, ShouldResumePopulationBetweenPauses) {
     auto sort = DocumentSourceSort::create(getExpCtx(), BSON("a" << 1));
-    auto mock = DocumentSourceMock::create({Document{{"a", 1}},
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document{{"a", 0}}});
+    auto mock =
+        DocumentSourceMock::createForTest({Document{{"a", 1}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"a", 0}}});
     sort->setSource(mock.get());
 
     // Should load the first document, then propagate the pause.
@@ -404,11 +406,12 @@ TEST_F(DocumentSourceSortExecutionTest, ShouldBeAbleToPauseLoadingWhileSpilled)
     auto sort = DocumentSourceSort::create(expCtx, BSON("_id" << -1), -1, maxMemoryUsageBytes);
 
     string largeStr(maxMemoryUsageBytes, 'x');
-    auto mock = DocumentSourceMock::create({Document{{"_id", 0}, {"largeStr", largeStr}},
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document{{"_id", 1}, {"largeStr", largeStr}},
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document{{"_id", 2}, {"largeStr", largeStr}}});
+    auto mock =
+        DocumentSourceMock::createForTest({Document{{"_id", 0}, {"largeStr", largeStr}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"_id", 1}, {"largeStr", largeStr}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"_id", 2}, {"largeStr", largeStr}}});
     sort->setSource(mock.get());
 
     // There were 2 pauses, so we should expect 2 paused results before any results can be returned.
@@ -438,8 +441,8 @@ TEST_F(DocumentSourceSortExecutionTest,
     auto sort = DocumentSourceSort::create(expCtx, BSON("_id" << -1), -1, maxMemoryUsageBytes);
 
     string largeStr(maxMemoryUsageBytes, 'x');
-    auto mock = DocumentSourceMock::create({Document{{"_id", 0}, {"largeStr", largeStr}},
-                                            Document{{"_id", 1}, {"largeStr", largeStr}}});
+    auto mock = DocumentSourceMock::createForTest({Document{{"_id", 0}, {"largeStr", largeStr}},
+                                                   Document{{"_id", 1}, {"largeStr", largeStr}}});
     sort->setSource(mock.get());
 
     ASSERT_THROWS_CODE(sort->getNext(), AssertionException, 16819);
@@ -453,10 +456,11 @@ TEST_F(DocumentSourceSortExecutionTest, ShouldCorrectlyTrackMemoryUsageBetweenPa
     auto sort = DocumentSourceSort::create(expCtx, BSON("_id" << -1), -1, maxMemoryUsageBytes);
 
     string largeStr(maxMemoryUsageBytes / 2, 'x');
-    auto mock = DocumentSourceMock::create({Document{{"_id", 0}, {"largeStr", largeStr}},
-                                            DocumentSource::GetNextResult::makePauseExecution(),
-                                            Document{{"_id", 1}, {"largeStr", largeStr}},
-                                            Document{{"_id", 2}, {"largeStr", largeStr}}});
+    auto mock =
+        DocumentSourceMock::createForTest({Document{{"_id", 0}, {"largeStr", largeStr}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"_id", 1}, {"largeStr", largeStr}},
+                                           Document{{"_id", 2}, {"largeStr", largeStr}}});
     sort->setSource(mock.get());
 
     // The first getNext() should pause.
diff --git a/src/mongo/db/pipeline/document_source_unwind_test.cpp b/src/mongo/db/pipeline/document_source_unwind_test.cpp
index fb88d3fa28c..ec8bb3af24c 100644
--- a/src/mongo/db/pipeline/document_source_unwind_test.cpp
+++ b/src/mongo/db/pipeline/document_source_unwind_test.cpp
@@ -179,7 +179,7 @@ private:
      * '_unwind' must be initialized before calling this method.
      */
     void assertResultsMatch(BSONObj expectedResults) {
-        auto source = DocumentSourceMock::create(inputData());
+        auto source = DocumentSourceMock::createForTest(inputData());
         _unwind->setSource(source.get());
         // Load the results from the DocumentSourceUnwind.
         vector<Document> resultSet;
@@ -690,9 +690,9 @@ TEST_F(UnwindStageTest, ShouldPropagatePauses) {
     auto unwind = DocumentSourceUnwind::create(
         getExpCtx(), "array", includeNullIfEmptyOrMissing, includeArrayIndex);
     auto source =
-        DocumentSourceMock::create({Document{{"array", vector<Value>{Value(1), Value(2)}}},
-                                    DocumentSource::GetNextResult::makePauseExecution(),
-                                    Document{{"array", vector<Value>{Value(1), Value(2)}}}});
+        DocumentSourceMock::createForTest({Document{{"array", vector<Value>{Value(1), Value(2)}}},
+                                           DocumentSource::GetNextResult::makePauseExecution(),
+                                           Document{{"array", vector<Value>{Value(1), Value(2)}}}});
 
     unwind->setSource(source.get());
 
diff --git a/src/mongo/db/pipeline/pipeline_test.cpp b/src/mongo/db/pipeline/pipeline_test.cpp
index adbf542e2e3..a386fc5bfb8 100644
--- a/src/mongo/db/pipeline/pipeline_test.cpp
+++ b/src/mongo/db/pipeline/pipeline_test.cpp
@@ -2863,7 +2863,8 @@ TEST_F(PipelineDependenciesTest, ShouldNotRequireTextScoreIfAvailableButDefinite
 namespace {
 TEST(PipelineRenameTracking, ReportsIdentityMapWhenEmpty) {
     boost::intrusive_ptr<ExpressionContext> expCtx(new ExpressionContextForTest());
-    auto pipeline = unittest::assertGet(Pipeline::create({DocumentSourceMock::create()}, expCtx));
+    auto pipeline =
+        unittest::assertGet(Pipeline::create({DocumentSourceMock::createForTest()}, expCtx));
     auto renames = pipeline->renamedPaths({"a", "b", "c.d"});
     ASSERT(static_cast<bool>(renames));
     auto nameMap = *renames;
@@ -2891,8 +2892,8 @@ public:
 TEST(PipelineRenameTracking, ReportsIdentityWhenNoStageModifiesAnything) {
     boost::intrusive_ptr<ExpressionContext> expCtx(new ExpressionContextForTest());
     {
-        auto pipeline = unittest::assertGet(
-            Pipeline::create({DocumentSourceMock::create(), NoModifications::create()}, expCtx));
+        auto pipeline = unittest::assertGet(Pipeline::create(
+            {DocumentSourceMock::createForTest(), NoModifications::create()}, expCtx));
         auto renames = pipeline->renamedPaths({"a", "b", "c.d"});
         ASSERT(static_cast<bool>(renames));
         auto nameMap = *renames;
@@ -2902,7 +2903,7 @@ TEST(PipelineRenameTracking, ReportsIdentityWhenNoStageModifiesAnything) {
         ASSERT_EQ(nameMap["c.d"], "c.d");
     }
     {
-        auto pipeline = unittest::assertGet(Pipeline::create({DocumentSourceMock::create(),
+        auto pipeline = unittest::assertGet(Pipeline::create({DocumentSourceMock::createForTest(),
                                                               NoModifications::create(),
                                                               NoModifications::create(),
                                                               NoModifications::create()},
@@ -2934,7 +2935,7 @@ public:
 
 TEST(PipelineRenameTracking, DoesNotReportRenamesIfAStageDoesNotSupportTrackingThem) {
     boost::intrusive_ptr<ExpressionContext> expCtx(new ExpressionContextForTest());
-    auto pipeline = unittest::assertGet(Pipeline::create({DocumentSourceMock::create(),
+    auto pipeline = unittest::assertGet(Pipeline::create({DocumentSourceMock::createForTest(),
                                                           NoModifications::create(),
                                                           NotSupported::create(),
                                                           NoModifications::create()},
@@ -2958,7 +2959,7 @@ public:
 TEST(PipelineRenameTracking, ReportsNewNamesWhenSingleStageRenames) {
     boost::intrusive_ptr<ExpressionContext> expCtx(new ExpressionContextForTest());
     auto pipeline = unittest::assertGet(
-        Pipeline::create({DocumentSourceMock::create(), RenamesAToB::create()}, expCtx));
+        Pipeline::create({DocumentSourceMock::createForTest(), RenamesAToB::create()}, expCtx));
     {
         auto renames = pipeline->renamedPaths({"b"});
         ASSERT(static_cast<bool>(renames));
@@ -2989,7 +2990,7 @@ TEST(PipelineRenameTracking, ReportsNewNamesWhenSingleStageRenames) {
 TEST(PipelineRenameTracking, ReportsIdentityMapWhenGivenEmptyIteratorRange) {
     boost::intrusive_ptr<ExpressionContext> expCtx(new ExpressionContextForTest());
     auto pipeline = unittest::assertGet(
-        Pipeline::create({DocumentSourceMock::create(), RenamesAToB::create()}, expCtx));
+        Pipeline::create({DocumentSourceMock::createForTest(), RenamesAToB::create()}, expCtx));
     {
         auto renames = Pipeline::renamedPaths(
             pipeline->getSources().rbegin(), pipeline->getSources().rbegin(), {"b"});
@@ -3023,7 +3024,8 @@ public:
 TEST(PipelineRenameTracking, ReportsNewNameAcrossMultipleRenames) {
     boost::intrusive_ptr<ExpressionContext> expCtx(new ExpressionContextForTest());
     auto pipeline = unittest::assertGet(Pipeline::create(
-        {DocumentSourceMock::create(), RenamesAToB::create(), RenamesBToC::create()}, expCtx));
+        {DocumentSourceMock::createForTest(), RenamesAToB::create(), RenamesBToC::create()},
+        expCtx));
     auto renames = pipeline->renamedPaths({"c"});
     ASSERT(static_cast<bool>(renames));
     auto nameMap = *renames;
@@ -3045,7 +3047,8 @@ public:
 TEST(PipelineRenameTracking, CanHandleBackAndForthRename) {
     boost::intrusive_ptr<ExpressionContext> expCtx(new ExpressionContextForTest());
     auto pipeline = unittest::assertGet(Pipeline::create(
-        {DocumentSourceMock::create(), RenamesAToB::create(), RenamesBToA::create()}, expCtx));
+        {DocumentSourceMock::createForTest(), RenamesAToB::create(), RenamesBToA::create()},
+        expCtx));
     auto renames = pipeline->renamedPaths({"a"});
     ASSERT(static_cast<bool>(renames));
     auto nameMap = *renames;
@@ -3056,7 +3059,7 @@ TEST(PipelineRenameTracking, CanHandleBackAndForthRename) {
 TEST(InvolvedNamespacesTest, NoInvolvedNamespacesForMatchSortProject) {
     boost::intrusive_ptr<ExpressionContext> expCtx(new ExpressionContextForTest());
     auto pipeline = unittest::assertGet(
-        Pipeline::create({DocumentSourceMock::create(),
+        Pipeline::create({DocumentSourceMock::createForTest(),
                           DocumentSourceMatch::create(BSON("x" << 1), expCtx),
                           DocumentSourceSort::create(expCtx, BSON("y" << -1)),
                           DocumentSourceProject::create(BSON("x" << 1 << "y" << 1), expCtx)},
@@ -3073,7 +3076,7 @@ TEST(InvolvedNamespacesTest, IncludesLookupNamespace) {
     auto lookupSpec =
         fromjson("{$lookup: {from: 'foo', as: 'x', localField: 'foo_id', foreignField: '_id'}}");
     auto pipeline = unittest::assertGet(
-        Pipeline::create({DocumentSourceMock::create(),
+        Pipeline::create({DocumentSourceMock::createForTest(),
                           DocumentSourceLookUp::createFromBson(lookupSpec.firstElement(), expCtx)},
                          expCtx));
 
@@ -3096,7 +3099,7 @@ TEST(InvolvedNamespacesTest, IncludesGraphLookupNamespace) {
         "  startWith: '$start'"
         "}}");
     auto pipeline = unittest::assertGet(Pipeline::create(
-        {DocumentSourceMock::create(),
+        {DocumentSourceMock::createForTest(),
          DocumentSourceGraphLookUp::createFromBson(graphLookupSpec.firstElement(), expCtx)},
         expCtx));
 
@@ -3120,7 +3123,7 @@ TEST(InvolvedNamespacesTest, IncludesLookupSubpipelineNamespaces) {
         "  pipeline: [{$lookup: {from: 'foo_inner', as: 'y', pipeline: []}}]"
         "}}");
     auto pipeline = unittest::assertGet(
-        Pipeline::create({DocumentSourceMock::create(),
+        Pipeline::create({DocumentSourceMock::createForTest(),
                           DocumentSourceLookUp::createFromBson(lookupSpec.firstElement(), expCtx)},
                          expCtx));
 
@@ -3151,7 +3154,7 @@ TEST(InvolvedNamespacesTest, IncludesGraphLookupSubPipeline) {
         "  startWith: '$start'"
         "}}");
     auto pipeline = unittest::assertGet(Pipeline::create(
-        {DocumentSourceMock::create(),
+        {DocumentSourceMock::createForTest(),
          DocumentSourceGraphLookUp::createFromBson(graphLookupSpec.firstElement(), expCtx)},
         expCtx));
 
@@ -3194,7 +3197,7 @@ TEST(InvolvedNamespacesTest, IncludesAllCollectionsWhenResolvingViews) {
         "  ]"
         "}}");
     auto pipeline = unittest::assertGet(
-        Pipeline::create({DocumentSourceMock::create(),
+        Pipeline::create({DocumentSourceMock::createForTest(),
                           DocumentSourceFacet::createFromBson(facetSpec.firstElement(), expCtx)},
                          expCtx));
 
diff --git a/src/mongo/db/pipeline/stub_mongo_process_interface_lookup_single_document.cpp b/src/mongo/db/pipeline/stub_mongo_process_interface_lookup_single_document.cpp
index 6af0f29d207..cb4abf32cb6 100644
--- a/src/mongo/db/pipeline/stub_mongo_process_interface_lookup_single_document.cpp
+++ b/src/mongo/db/pipeline/stub_mongo_process_interface_lookup_single_document.cpp
@@ -60,7 +60,7 @@ StubMongoProcessInterfaceLookupSingleDocument::attachCursorSourceToPipeline(
     const boost::intrusive_ptr<ExpressionContext>& expCtx, Pipeline* ownedPipeline) {
     std::unique_ptr<Pipeline, PipelineDeleter> pipeline(ownedPipeline,
                                                         PipelineDeleter(expCtx->opCtx));
-    pipeline->addInitialSource(DocumentSourceMock::create(_mockResults));
+    pipeline->addInitialSource(DocumentSourceMock::createForTest(_mockResults));
     return pipeline;
 }
 
diff --git a/src/mongo/db/pipeline/tee_buffer_test.cpp b/src/mongo/db/pipeline/tee_buffer_test.cpp
index c0e03cec4b8..a83f79e8e74 100644
--- a/src/mongo/db/pipeline/tee_buffer_test.cpp
+++ b/src/mongo/db/pipeline/tee_buffer_test.cpp
@@ -50,7 +50,7 @@ TEST(TeeBufferTest, ShouldRequirePositiveBatchSize) {
 }
 
 TEST(TeeBufferTest, ShouldBeExhaustedIfInputIsExhausted) {
-    auto mock = DocumentSourceMock::create();
+    auto mock = DocumentSourceMock::createForTest();
     auto teeBuffer = TeeBuffer::create(1);
     teeBuffer->setSource(mock.get());
 
@@ -61,7 +61,7 @@ TEST(TeeBufferTest, ShouldBeExhaustedIfInputIsExhausted) {
 
 TEST(TeeBufferTest, ShouldProvideAllResultsWithoutPauseIfTheyFitInOneBatch) {
     std::deque<DocumentSource::GetNextResult> inputs{Document{{"a", 1}}, Document{{"a", 2}}};
-    auto mock = DocumentSourceMock::create(inputs);
+    auto mock = DocumentSourceMock::createForTest(inputs);
     auto teeBuffer = TeeBuffer::create(1);
     teeBuffer->setSource(mock.get());
 
@@ -79,7 +79,7 @@ TEST(TeeBufferTest, ShouldProvideAllResultsWithoutPauseIfTheyFitInOneBatch) {
 
 TEST(TeeBufferTest, ShouldProvideAllResultsWithoutPauseIfOnlyOneConsumer) {
     std::deque<DocumentSource::GetNextResult> inputs{Document{{"a", 1}}, Document{{"a", 2}}};
-    auto mock = DocumentSourceMock::create(inputs);
+    auto mock = DocumentSourceMock::createForTest(inputs);
 
     const size_t bufferBytes = 1;  // Both docs won't fit in a single batch.
     auto teeBuffer = TeeBuffer::create(1, bufferBytes);
@@ -99,7 +99,7 @@ TEST(TeeBufferTest, ShouldProvideAllResultsWithoutPauseIfOnlyOneConsumer) {
 
 TEST(TeeBufferTest, ShouldTellConsumerToPauseIfItFinishesBatchBeforeOtherConsumers) {
     std::deque<DocumentSource::GetNextResult> inputs{Document{{"a", 1}}, Document{{"a", 2}}};
-    auto mock = DocumentSourceMock::create(inputs);
+    auto mock = DocumentSourceMock::createForTest(inputs);
 
     const size_t nConsumers = 2;
     const size_t bufferBytes = 1;  // Both docs won't fit in a single batch.
@@ -142,7 +142,7 @@ TEST(TeeBufferTest, ShouldTellConsumerToPauseIfItFinishesBatchBeforeOtherConsume
 
 TEST(TeeBufferTest, ShouldAllowOtherConsumersToAdvanceOnceTrailingConsumerIsDisposed) {
     std::deque<DocumentSource::GetNextResult> inputs{Document{{"a", 1}}, Document{{"a", 2}}};
-    auto mock = DocumentSourceMock::create(inputs);
+    auto mock = DocumentSourceMock::createForTest(inputs);
 
     const size_t nConsumers = 2;
     const size_t bufferBytes = 1;  // Both docs won't fit in a single batch.
diff --git a/src/mongo/db/update/pipeline_executor.cpp b/src/mongo/db/update/pipeline_executor.cpp
index f2e66da44b9..c058e8fb43f 100644
--- a/src/mongo/db/update/pipeline_executor.cpp
+++ b/src/mongo/db/update/pipeline_executor.cpp
@@ -71,7 +71,7 @@ PipelineExecutor::PipelineExecutor(const boost::intrusive_ptr<ExpressionContext>
         invariant(!stageConstraints.isIndependentOfAnyCollection);
     }
 
-    _pipeline->addInitialSource(DocumentSourceMock::create());
+    _pipeline->addInitialSource(DocumentSourceMock::create(expCtx));
 }
 
 UpdateExecutor::ApplyResult PipelineExecutor::applyUpdate(ApplyParams applyParams) const {