SERVER-46199 Make the RoutingTableHistory movable

7 files changed, 194 insertions, 165 deletions

diff --git a/src/mongo/db/s/collection_metadata_filtering_test.cpp b/src/mongo/db/s/collection_metadata_filtering_test.cpp
index 0aa4438b5a8..ddeb8f1c7ba 100644
--- a/src/mongo/db/s/collection_metadata_filtering_test.cpp
+++ b/src/mongo/db/s/collection_metadata_filtering_test.cpp
@@ -103,7 +103,10 @@ protected:
                 return std::vector<ChunkType>{chunk1, chunk2, chunk3, chunk4};
             }());
 
-        ChunkManager cm(ShardId("0"), DatabaseVersion(UUID::gen(), 1), rt, boost::none);
+        ChunkManager cm(ShardId("0"),
+                        DatabaseVersion(UUID::gen(), 1),
+                        makeStandaloneRoutingTableHistory(std::move(rt)),
+                        boost::none);
         ASSERT_EQ(4, cm.numChunks());
 
         {
diff --git a/src/mongo/db/s/collection_metadata_test.cpp b/src/mongo/db/s/collection_metadata_test.cpp
index c26be5b2795..0c343a5ed37 100644
--- a/src/mongo/db/s/collection_metadata_test.cpp
+++ b/src/mongo/db/s/collection_metadata_test.cpp
@@ -29,13 +29,12 @@
 
 #include "mongo/platform/basic.h"
 
-#include <memory>
-
 #include "mongo/base/status.h"
 #include "mongo/db/range_arithmetic.h"
 #include "mongo/db/s/collection_metadata.h"
 #include "mongo/s/catalog/type_chunk.h"
 #include "mongo/s/chunk_version.h"
+#include "mongo/s/sharding_test_fixture_common.h"
 #include "mongo/unittest/unittest.h"
 
 namespace mongo {
@@ -43,7 +42,7 @@ namespace {
 
 using unittest::assertGet;
 
-std::unique_ptr<CollectionMetadata> makeCollectionMetadataImpl(
+CollectionMetadata makeCollectionMetadataImpl(
     const KeyPattern& shardKeyPattern,
     const std::vector<std::pair<BSONObj, BSONObj>>& thisShardsChunks,
     bool staleChunkManager) {
@@ -73,17 +72,27 @@ std::unique_ptr<CollectionMetadata> makeCollectionMetadataImpl(
         version.incMajor();
         nextMinKey = myNextChunk.second;
     }
+
     if (SimpleBSONObjComparator::kInstance.evaluate(nextMinKey < shardKeyPattern.globalMax())) {
         allChunks.emplace_back(
             kNss, ChunkRange{nextMinKey, shardKeyPattern.globalMax()}, version, kOtherShard);
         allChunks.back().setHistory({ChunkHistory(kRouting, kOtherShard)});
     }
 
-    UUID uuid(UUID::gen());
-    auto rt = RoutingTableHistory::makeNew(
-        kNss, uuid, shardKeyPattern, nullptr, false, epoch, boost::none, allChunks);
-    return std::make_unique<CollectionMetadata>(
-        ChunkManager(kThisShard, DatabaseVersion(UUID::gen(), 1), rt, kChunkManager), kThisShard);
+    return CollectionMetadata(
+        ChunkManager(kThisShard,
+                     DatabaseVersion(UUID::gen(), 1),
+                     ShardingTestFixtureCommon::makeStandaloneRoutingTableHistory(
+                         RoutingTableHistory::makeNew(kNss,
+                                                      UUID::gen(),
+                                                      shardKeyPattern,
+                                                      nullptr,
+                                                      false,
+                                                      epoch,
+                                                      boost::none,
+                                                      allChunks)),
+                     kChunkManager),
+        kThisShard);
 }
 
 struct ConstructedRangeMap : public RangeMap {
@@ -93,38 +102,38 @@ struct ConstructedRangeMap : public RangeMap {
 
 class NoChunkFixture : public unittest::Test {
 protected:
-    std::unique_ptr<CollectionMetadata> makeCollectionMetadata() const {
+    CollectionMetadata makeCollectionMetadata() const {
         return makeCollectionMetadataImpl(KeyPattern(BSON("a" << 1)), {}, false);
     }
 };
 
 TEST_F(NoChunkFixture, KeyBelongsToMe) {
-    ASSERT(!makeCollectionMetadata()->keyBelongsToMe(BSON("a" << MINKEY)));
-    ASSERT(!makeCollectionMetadata()->keyBelongsToMe(BSON("a" << 10)));
-    ASSERT(!makeCollectionMetadata()->keyBelongsToMe(BSON("a" << MINKEY)));
+    ASSERT(!makeCollectionMetadata().keyBelongsToMe(BSON("a" << MINKEY)));
+    ASSERT(!makeCollectionMetadata().keyBelongsToMe(BSON("a" << 10)));
+    ASSERT(!makeCollectionMetadata().keyBelongsToMe(BSON("a" << MINKEY)));
 
-    ASSERT(!makeCollectionMetadata()->keyBelongsToMe(BSONObj()));
+    ASSERT(!makeCollectionMetadata().keyBelongsToMe(BSONObj()));
 }
 
 TEST_F(NoChunkFixture, IsValidKey) {
-    ASSERT(makeCollectionMetadata()->isValidKey(BSON("a"
+    ASSERT(makeCollectionMetadata().isValidKey(BSON("a"
+                                                    << "abcde")));
+    ASSERT(makeCollectionMetadata().isValidKey(BSON("a" << 3)));
+    ASSERT(!makeCollectionMetadata().isValidKey(BSON("a"
+                                                     << "abcde"
+                                                     << "b" << 1)));
+    ASSERT(!makeCollectionMetadata().isValidKey(BSON("c"
                                                      << "abcde")));
-    ASSERT(makeCollectionMetadata()->isValidKey(BSON("a" << 3)));
-    ASSERT(!makeCollectionMetadata()->isValidKey(BSON("a"
-                                                      << "abcde"
-                                                      << "b" << 1)));
-    ASSERT(!makeCollectionMetadata()->isValidKey(BSON("c"
-                                                      << "abcde")));
 }
 
 TEST_F(NoChunkFixture, GetNextChunk) {
     ChunkType nextChunk;
     ASSERT(
-        !makeCollectionMetadata()->getNextChunk(makeCollectionMetadata()->getMinKey(), &nextChunk));
+        !makeCollectionMetadata().getNextChunk(makeCollectionMetadata().getMinKey(), &nextChunk));
 }
 
 TEST_F(NoChunkFixture, RangeOverlapsChunk) {
-    ASSERT(!makeCollectionMetadata()->rangeOverlapsChunk(
+    ASSERT(!makeCollectionMetadata().rangeOverlapsChunk(
         ChunkRange{BSON("a" << 100), BSON("a" << 200)}));
 }
 
@@ -132,15 +141,15 @@ TEST_F(NoChunkFixture, OrphanedDataRangeBegin) {
     auto metadata(makeCollectionMetadata());
 
     ConstructedRangeMap pending;
-    BSONObj lookupKey = metadata->getMinKey();
-    auto keyRange = metadata->getNextOrphanRange(pending, lookupKey);
+    BSONObj lookupKey = metadata.getMinKey();
+    auto keyRange = metadata.getNextOrphanRange(pending, lookupKey);
     ASSERT(keyRange);
 
-    ASSERT(keyRange->getMin().woCompare(metadata->getMinKey()) == 0);
-    ASSERT(keyRange->getMax().woCompare(metadata->getMaxKey()) == 0);
+    ASSERT(keyRange->getMin().woCompare(metadata.getMinKey()) == 0);
+    ASSERT(keyRange->getMax().woCompare(metadata.getMaxKey()) == 0);
 
     // Make sure we don't have any more ranges
-    ASSERT(!metadata->getNextOrphanRange(pending, keyRange->getMax()));
+    ASSERT(!metadata.getNextOrphanRange(pending, keyRange->getMax()));
 }
 
 TEST_F(NoChunkFixture, OrphanedDataRangeMiddle) {
@@ -148,21 +157,21 @@ TEST_F(NoChunkFixture, OrphanedDataRangeMiddle) {
 
     ConstructedRangeMap pending;
     BSONObj lookupKey = BSON("a" << 20);
-    auto keyRange = metadata->getNextOrphanRange(pending, lookupKey);
+    auto keyRange = metadata.getNextOrphanRange(pending, lookupKey);
     ASSERT(keyRange);
 
-    ASSERT(keyRange->getMin().woCompare(metadata->getMinKey()) == 0);
-    ASSERT(keyRange->getMax().woCompare(metadata->getMaxKey()) == 0);
+    ASSERT(keyRange->getMin().woCompare(metadata.getMinKey()) == 0);
+    ASSERT(keyRange->getMax().woCompare(metadata.getMaxKey()) == 0);
 
     // Make sure we don't have any more ranges
-    ASSERT(!metadata->getNextOrphanRange(pending, keyRange->getMax()));
+    ASSERT(!metadata.getNextOrphanRange(pending, keyRange->getMax()));
 }
 
 TEST_F(NoChunkFixture, OrphanedDataRangeEnd) {
     auto metadata(makeCollectionMetadata());
 
     ConstructedRangeMap pending;
-    ASSERT(!metadata->getNextOrphanRange(pending, metadata->getMaxKey()));
+    ASSERT(!metadata.getNextOrphanRange(pending, metadata.getMaxKey()));
 }
 
 /**
@@ -171,31 +180,30 @@ TEST_F(NoChunkFixture, OrphanedDataRangeEnd) {
  */
 class SingleChunkFixture : public unittest::Test {
 protected:
-    std::unique_ptr<CollectionMetadata> makeCollectionMetadata() const {
+    CollectionMetadata makeCollectionMetadata() const {
         return makeCollectionMetadataImpl(
             KeyPattern(BSON("a" << 1)), {std::make_pair(BSON("a" << 10), BSON("a" << 20))}, false);
     }
 };
 
 TEST_F(SingleChunkFixture, KeyBelongsToMe) {
-    ASSERT(makeCollectionMetadata()->keyBelongsToMe(BSON("a" << 10)));
-    ASSERT(makeCollectionMetadata()->keyBelongsToMe(BSON("a" << 15)));
-    ASSERT(makeCollectionMetadata()->keyBelongsToMe(BSON("a" << 19)));
-
-    ASSERT(!makeCollectionMetadata()->keyBelongsToMe(BSON("a" << 0)));
-    ASSERT(!makeCollectionMetadata()->keyBelongsToMe(BSON("a" << 9)));
-    ASSERT(!makeCollectionMetadata()->keyBelongsToMe(BSON("a" << 20)));
-    ASSERT(!makeCollectionMetadata()->keyBelongsToMe(BSON("a" << 1234)));
-    ASSERT(!makeCollectionMetadata()->keyBelongsToMe(BSON("a" << MINKEY)));
-    ASSERT(!makeCollectionMetadata()->keyBelongsToMe(BSON("a" << MAXKEY)));
-
-    ASSERT(!makeCollectionMetadata()->keyBelongsToMe(BSONObj()));
+    ASSERT(makeCollectionMetadata().keyBelongsToMe(BSON("a" << 10)));
+    ASSERT(makeCollectionMetadata().keyBelongsToMe(BSON("a" << 15)));
+    ASSERT(makeCollectionMetadata().keyBelongsToMe(BSON("a" << 19)));
+
+    ASSERT(!makeCollectionMetadata().keyBelongsToMe(BSON("a" << 0)));
+    ASSERT(!makeCollectionMetadata().keyBelongsToMe(BSON("a" << 9)));
+    ASSERT(!makeCollectionMetadata().keyBelongsToMe(BSON("a" << 20)));
+    ASSERT(!makeCollectionMetadata().keyBelongsToMe(BSON("a" << 1234)));
+    ASSERT(!makeCollectionMetadata().keyBelongsToMe(BSON("a" << MINKEY)));
+    ASSERT(!makeCollectionMetadata().keyBelongsToMe(BSON("a" << MAXKEY)));
+
+    ASSERT(!makeCollectionMetadata().keyBelongsToMe(BSONObj()));
 }
 
 TEST_F(SingleChunkFixture, GetNextChunk) {
     ChunkType nextChunk;
-    ASSERT(
-        makeCollectionMetadata()->getNextChunk(makeCollectionMetadata()->getMinKey(), &nextChunk));
+    ASSERT(makeCollectionMetadata().getNextChunk(makeCollectionMetadata().getMinKey(), &nextChunk));
     ASSERT_EQUALS(0, nextChunk.getMin().woCompare(BSON("a" << 10)));
     ASSERT_EQUALS(0, nextChunk.getMax().woCompare(BSON("a" << 20)));
 }
@@ -203,37 +211,37 @@ TEST_F(SingleChunkFixture, GetNextChunk) {
 TEST_F(SingleChunkFixture, GetNextChunkShouldFindNothing) {
     ChunkType nextChunk;
     ASSERT(
-        !makeCollectionMetadata()->getNextChunk(makeCollectionMetadata()->getMaxKey(), &nextChunk));
+        !makeCollectionMetadata().getNextChunk(makeCollectionMetadata().getMaxKey(), &nextChunk));
 }
 
 TEST_F(SingleChunkFixture, RangeOverlapsChunk) {
-    ASSERT(!makeCollectionMetadata()->rangeOverlapsChunk(
-        ChunkRange{BSON("a" << 20), BSON("a" << 30)}));
-    ASSERT(!makeCollectionMetadata()->rangeOverlapsChunk(
+    ASSERT(
+        !makeCollectionMetadata().rangeOverlapsChunk(ChunkRange{BSON("a" << 20), BSON("a" << 30)}));
+    ASSERT(!makeCollectionMetadata().rangeOverlapsChunk(
         ChunkRange{BSON("a" << 100), BSON("a" << 200)}));
     ASSERT(
-        !makeCollectionMetadata()->rangeOverlapsChunk(ChunkRange{BSON("a" << 0), BSON("a" << 10)}));
+        !makeCollectionMetadata().rangeOverlapsChunk(ChunkRange{BSON("a" << 0), BSON("a" << 10)}));
     ASSERT(
-        makeCollectionMetadata()->rangeOverlapsChunk(ChunkRange{BSON("a" << 11), BSON("a" << 19)}));
+        makeCollectionMetadata().rangeOverlapsChunk(ChunkRange{BSON("a" << 11), BSON("a" << 19)}));
     ASSERT(
-        makeCollectionMetadata()->rangeOverlapsChunk(ChunkRange{BSON("a" << 19), BSON("a" << 20)}));
+        makeCollectionMetadata().rangeOverlapsChunk(ChunkRange{BSON("a" << 19), BSON("a" << 20)}));
 }
 
 TEST_F(SingleChunkFixture, ChunkOrphanedDataRanges) {
     ConstructedRangeMap pending;
-    auto keyRange = makeCollectionMetadata()->getNextOrphanRange(
-        pending, makeCollectionMetadata()->getMinKey());
+    auto keyRange =
+        makeCollectionMetadata().getNextOrphanRange(pending, makeCollectionMetadata().getMinKey());
     ASSERT(keyRange);
 
-    ASSERT(keyRange->getMin().woCompare(makeCollectionMetadata()->getMinKey()) == 0);
+    ASSERT(keyRange->getMin().woCompare(makeCollectionMetadata().getMinKey()) == 0);
     ASSERT(keyRange->getMax().woCompare(BSON("a" << 10)) == 0);
 
-    keyRange = makeCollectionMetadata()->getNextOrphanRange(pending, keyRange->getMax());
+    keyRange = makeCollectionMetadata().getNextOrphanRange(pending, keyRange->getMax());
     ASSERT(keyRange);
     ASSERT(keyRange->getMin().woCompare(BSON("a" << 20)) == 0);
-    ASSERT(keyRange->getMax().woCompare(makeCollectionMetadata()->getMaxKey()) == 0);
+    ASSERT(keyRange->getMax().woCompare(makeCollectionMetadata().getMaxKey()) == 0);
 
-    ASSERT(!makeCollectionMetadata()->getNextOrphanRange(pending, keyRange->getMax()));
+    ASSERT(!makeCollectionMetadata().getNextOrphanRange(pending, keyRange->getMax()));
 }
 
 /**
@@ -242,7 +250,7 @@ TEST_F(SingleChunkFixture, ChunkOrphanedDataRanges) {
  */
 class SingleChunkMinMaxCompoundKeyFixture : public unittest::Test {
 protected:
-    std::unique_ptr<CollectionMetadata> makeCollectionMetadata() const {
+    CollectionMetadata makeCollectionMetadata() const {
         const KeyPattern shardKeyPattern(BSON("a" << 1 << "b" << 1));
         return makeCollectionMetadataImpl(
             shardKeyPattern,
@@ -252,13 +260,13 @@ protected:
 };
 
 TEST_F(SingleChunkMinMaxCompoundKeyFixture, KeyBelongsToMe) {
-    ASSERT(makeCollectionMetadata()->keyBelongsToMe(BSON("a" << MINKEY << "b" << MINKEY)));
-    ASSERT(makeCollectionMetadata()->keyBelongsToMe(BSON("a" << MINKEY << "b" << 10)));
-    ASSERT(makeCollectionMetadata()->keyBelongsToMe(BSON("a" << 10 << "b" << 20)));
+    ASSERT(makeCollectionMetadata().keyBelongsToMe(BSON("a" << MINKEY << "b" << MINKEY)));
+    ASSERT(makeCollectionMetadata().keyBelongsToMe(BSON("a" << MINKEY << "b" << 10)));
+    ASSERT(makeCollectionMetadata().keyBelongsToMe(BSON("a" << 10 << "b" << 20)));
 
-    ASSERT(!makeCollectionMetadata()->keyBelongsToMe(BSON("a" << MAXKEY << "b" << MAXKEY)));
+    ASSERT(!makeCollectionMetadata().keyBelongsToMe(BSON("a" << MAXKEY << "b" << MAXKEY)));
 
-    ASSERT(!makeCollectionMetadata()->keyBelongsToMe(BSONObj()));
+    ASSERT(!makeCollectionMetadata().keyBelongsToMe(BSONObj()));
 }
 
 /**
@@ -267,7 +275,7 @@ TEST_F(SingleChunkMinMaxCompoundKeyFixture, KeyBelongsToMe) {
  */
 class TwoChunksWithGapCompoundKeyFixture : public unittest::Test {
 protected:
-    std::unique_ptr<CollectionMetadata> makeCollectionMetadata() const {
+    CollectionMetadata makeCollectionMetadata() const {
         return makeCollectionMetadataImpl(
             KeyPattern(BSON("a" << 1 << "b" << 1)),
             {std::make_pair(BSON("a" << 10 << "b" << 0), BSON("a" << 20 << "b" << 0)),
@@ -279,23 +287,23 @@ protected:
 TEST_F(TwoChunksWithGapCompoundKeyFixture, ChunkGapOrphanedDataRanges) {
     ConstructedRangeMap pending;
 
-    auto keyRange = makeCollectionMetadata()->getNextOrphanRange(
-        pending, makeCollectionMetadata()->getMinKey());
+    auto keyRange =
+        makeCollectionMetadata().getNextOrphanRange(pending, makeCollectionMetadata().getMinKey());
     ASSERT(keyRange);
-    ASSERT(keyRange->getMin().woCompare(makeCollectionMetadata()->getMinKey()) == 0);
+    ASSERT(keyRange->getMin().woCompare(makeCollectionMetadata().getMinKey()) == 0);
     ASSERT(keyRange->getMax().woCompare(BSON("a" << 10 << "b" << 0)) == 0);
 
-    keyRange = makeCollectionMetadata()->getNextOrphanRange(pending, keyRange->getMax());
+    keyRange = makeCollectionMetadata().getNextOrphanRange(pending, keyRange->getMax());
     ASSERT(keyRange);
     ASSERT(keyRange->getMin().woCompare(BSON("a" << 20 << "b" << 0)) == 0);
     ASSERT(keyRange->getMax().woCompare(BSON("a" << 30 << "b" << 0)) == 0);
 
-    keyRange = makeCollectionMetadata()->getNextOrphanRange(pending, keyRange->getMax());
+    keyRange = makeCollectionMetadata().getNextOrphanRange(pending, keyRange->getMax());
     ASSERT(keyRange);
     ASSERT(keyRange->getMin().woCompare(BSON("a" << 40 << "b" << 0)) == 0);
-    ASSERT(keyRange->getMax().woCompare(makeCollectionMetadata()->getMaxKey()) == 0);
+    ASSERT(keyRange->getMax().woCompare(makeCollectionMetadata().getMaxKey()) == 0);
 
-    ASSERT(!makeCollectionMetadata()->getNextOrphanRange(pending, keyRange->getMax()));
+    ASSERT(!makeCollectionMetadata().getNextOrphanRange(pending, keyRange->getMax()));
 }
 
 /**
@@ -304,8 +312,7 @@ TEST_F(TwoChunksWithGapCompoundKeyFixture, ChunkGapOrphanedDataRanges) {
  */
 class ThreeChunkWithRangeGapFixture : public unittest::Test {
 protected:
-    std::unique_ptr<CollectionMetadata> makeCollectionMetadata() const {
-
+    CollectionMetadata makeCollectionMetadata() const {
         return makeCollectionMetadataImpl(KeyPattern(BSON("a" << 1)),
                                           {std::make_pair(BSON("a" << MINKEY), BSON("a" << 10)),
                                            std::make_pair(BSON("a" << 10), BSON("a" << 20)),
@@ -319,52 +326,51 @@ TEST_F(ThreeChunkWithRangeGapFixture, GetNextChunkMatch) {
 
     ChunkType chunk;
 
-    ASSERT(metadata->getNextChunk(BSON("a" << MINKEY), &chunk));
-    ASSERT_BSONOBJ_EQ(metadata->getMinKey(), chunk.getMin());
+    ASSERT(metadata.getNextChunk(BSON("a" << MINKEY), &chunk));
+    ASSERT_BSONOBJ_EQ(metadata.getMinKey(), chunk.getMin());
     ASSERT_BSONOBJ_EQ(BSON("a" << MINKEY), chunk.getMin());
     ASSERT_BSONOBJ_EQ(BSON("a" << 10), chunk.getMax());
 
-    ASSERT(metadata->getNextChunk(BSON("a" << 10), &chunk));
+    ASSERT(metadata.getNextChunk(BSON("a" << 10), &chunk));
     ASSERT_BSONOBJ_EQ(BSON("a" << 10), chunk.getMin());
     ASSERT_BSONOBJ_EQ(BSON("a" << 20), chunk.getMax());
 
-    ASSERT(metadata->getNextChunk(BSON("a" << 30), &chunk));
+    ASSERT(metadata.getNextChunk(BSON("a" << 30), &chunk));
     ASSERT_BSONOBJ_EQ(BSON("a" << 30), chunk.getMin());
-    ASSERT_BSONOBJ_EQ(metadata->getMaxKey(), chunk.getMax());
+    ASSERT_BSONOBJ_EQ(metadata.getMaxKey(), chunk.getMax());
     ASSERT_BSONOBJ_EQ(BSON("a" << MAXKEY), chunk.getMax());
 }
 
 TEST_F(ThreeChunkWithRangeGapFixture, KeyBelongsToMe) {
-    ASSERT(makeCollectionMetadata()->keyBelongsToMe(BSON("a" << 5)));
-    ASSERT(makeCollectionMetadata()->keyBelongsToMe(BSON("a" << 10)));
-    ASSERT(makeCollectionMetadata()->keyBelongsToMe(BSON("a" << 30)));
-    ASSERT(makeCollectionMetadata()->keyBelongsToMe(BSON("a" << 40)));
+    ASSERT(makeCollectionMetadata().keyBelongsToMe(BSON("a" << 5)));
+    ASSERT(makeCollectionMetadata().keyBelongsToMe(BSON("a" << 10)));
+    ASSERT(makeCollectionMetadata().keyBelongsToMe(BSON("a" << 30)));
+    ASSERT(makeCollectionMetadata().keyBelongsToMe(BSON("a" << 40)));
 
-    ASSERT(!makeCollectionMetadata()->keyBelongsToMe(BSON("a" << 20)));
-    ASSERT(!makeCollectionMetadata()->keyBelongsToMe(BSON("a" << 25)));
-    ASSERT(!makeCollectionMetadata()->keyBelongsToMe(BSON("a" << MAXKEY)));
+    ASSERT(!makeCollectionMetadata().keyBelongsToMe(BSON("a" << 20)));
+    ASSERT(!makeCollectionMetadata().keyBelongsToMe(BSON("a" << 25)));
+    ASSERT(!makeCollectionMetadata().keyBelongsToMe(BSON("a" << MAXKEY)));
 
-    ASSERT(!makeCollectionMetadata()->keyBelongsToMe(BSONObj()));
+    ASSERT(!makeCollectionMetadata().keyBelongsToMe(BSONObj()));
 }
 
 TEST_F(ThreeChunkWithRangeGapFixture, GetNextChunkFromBeginning) {
     ChunkType nextChunk;
-    ASSERT(
-        makeCollectionMetadata()->getNextChunk(makeCollectionMetadata()->getMinKey(), &nextChunk));
+    ASSERT(makeCollectionMetadata().getNextChunk(makeCollectionMetadata().getMinKey(), &nextChunk));
     ASSERT_EQUALS(0, nextChunk.getMin().woCompare(BSON("a" << MINKEY)));
     ASSERT_EQUALS(0, nextChunk.getMax().woCompare(BSON("a" << 10)));
 }
 
 TEST_F(ThreeChunkWithRangeGapFixture, GetNextChunkFromMiddle) {
     ChunkType nextChunk;
-    ASSERT(makeCollectionMetadata()->getNextChunk(BSON("a" << 20), &nextChunk));
+    ASSERT(makeCollectionMetadata().getNextChunk(BSON("a" << 20), &nextChunk));
     ASSERT_EQUALS(0, nextChunk.getMin().woCompare(BSON("a" << 30)));
     ASSERT_EQUALS(0, nextChunk.getMax().woCompare(BSON("a" << MAXKEY)));
 }
 
 TEST_F(ThreeChunkWithRangeGapFixture, GetNextChunkFromLast) {
     ChunkType nextChunk;
-    ASSERT(makeCollectionMetadata()->getNextChunk(BSON("a" << 30), &nextChunk));
+    ASSERT(makeCollectionMetadata().getNextChunk(BSON("a" << 30), &nextChunk));
     ASSERT_EQUALS(0, nextChunk.getMin().woCompare(BSON("a" << 30)));
     ASSERT_EQUALS(0, nextChunk.getMax().woCompare(BSON("a" << MAXKEY)));
 }
@@ -375,18 +381,18 @@ TEST_F(ThreeChunkWithRangeGapFixture, GetNextChunkFromLast) {
  */
 class StaleChunkFixture : public unittest::Test {
 protected:
-    std::unique_ptr<CollectionMetadata> makeCollectionMetadata() const {
+    CollectionMetadata makeCollectionMetadata() const {
         return makeCollectionMetadataImpl(
             KeyPattern(BSON("a" << 1)), {std::make_pair(BSON("a" << 10), BSON("a" << 20))}, true);
     }
 };
 
 TEST_F(StaleChunkFixture, KeyBelongsToMe) {
-    ASSERT_THROWS_CODE(makeCollectionMetadata()->keyBelongsToMe(BSON("a" << 10)),
+    ASSERT_THROWS_CODE(makeCollectionMetadata().keyBelongsToMe(BSON("a" << 10)),
                        AssertionException,
                        ErrorCodes::StaleChunkHistory);
 
-    ASSERT_THROWS_CODE(makeCollectionMetadata()->keyBelongsToMe(BSON("a" << 0)),
+    ASSERT_THROWS_CODE(makeCollectionMetadata().keyBelongsToMe(BSON("a" << 0)),
                        AssertionException,
                        ErrorCodes::StaleChunkHistory);
 }
diff --git a/src/mongo/db/s/collection_sharding_runtime_test.cpp b/src/mongo/db/s/collection_sharding_runtime_test.cpp
index 0ea329db1b9..952924bf6f9 100644
--- a/src/mongo/db/s/collection_sharding_runtime_test.cpp
+++ b/src/mongo/db/s/collection_sharding_runtime_test.cpp
@@ -45,34 +45,39 @@ const NamespaceString kTestNss("TestDB", "TestColl");
 const std::string kShardKey = "_id";
 const BSONObj kShardKeyPattern = BSON(kShardKey << 1);
 
-using CollectionShardingRuntimeTest = ShardServerTestFixture;
-
-CollectionMetadata makeShardedMetadata(OperationContext* opCtx, UUID uuid = UUID::gen()) {
-    const OID epoch = OID::gen();
-    auto range = ChunkRange(BSON(kShardKey << MINKEY), BSON(kShardKey << MAXKEY));
-    auto chunk = ChunkType(kTestNss, std::move(range), ChunkVersion(1, 0, epoch), ShardId("other"));
-    ChunkManager cm(ShardId("0"),
-                    DatabaseVersion(UUID::gen(), 1),
-                    RoutingTableHistory::makeNew(kTestNss,
-                                                 uuid,
-                                                 kShardKeyPattern,
-                                                 nullptr,
-                                                 false,
-                                                 epoch,
-                                                 boost::none,
-                                                 {std::move(chunk)}),
-                    boost::none);
-
-    if (!OperationShardingState::isOperationVersioned(opCtx)) {
-        const auto version = cm.getVersion(ShardId("0"));
-        BSONObjBuilder builder;
-        version.appendToCommand(&builder);
-
-        auto& oss = OperationShardingState::get(opCtx);
-        oss.initializeClientRoutingVersionsFromCommand(kTestNss, builder.obj());
+class CollectionShardingRuntimeTest : public ShardServerTestFixture {
+protected:
+    static CollectionMetadata makeShardedMetadata(OperationContext* opCtx,
+                                                  UUID uuid = UUID::gen()) {
+        const OID epoch = OID::gen();
+        auto range = ChunkRange(BSON(kShardKey << MINKEY), BSON(kShardKey << MAXKEY));
+        auto chunk =
+            ChunkType(kTestNss, std::move(range), ChunkVersion(1, 0, epoch), ShardId("other"));
+        ChunkManager cm(
+            ShardId("0"),
+            DatabaseVersion(UUID::gen(), 1),
+            makeStandaloneRoutingTableHistory(RoutingTableHistory::makeNew(kTestNss,
+                                                                           uuid,
+                                                                           kShardKeyPattern,
+                                                                           nullptr,
+                                                                           false,
+                                                                           epoch,
+                                                                           boost::none,
+                                                                           {std::move(chunk)})),
+            boost::none);
+
+        if (!OperationShardingState::isOperationVersioned(opCtx)) {
+            const auto version = cm.getVersion(ShardId("0"));
+            BSONObjBuilder builder;
+            version.appendToCommand(&builder);
+
+            auto& oss = OperationShardingState::get(opCtx);
+            oss.initializeClientRoutingVersionsFromCommand(kTestNss, builder.obj());
+        }
+
+        return CollectionMetadata(std::move(cm), ShardId("0"));
     }
-    return CollectionMetadata(std::move(cm), ShardId("0"));
-}
+};
 
 TEST_F(CollectionShardingRuntimeTest,
        GetCollectionDescriptionThrowsStaleConfigBeforeSetFilteringMetadataIsCalledAndNoOSSSet) {
@@ -175,7 +180,7 @@ TEST_F(CollectionShardingRuntimeTest,
 /**
  * Fixture for when range deletion functionality is required in CollectionShardingRuntime tests.
  */
-class CollectionShardingRuntimeWithRangeDeleterTest : public ShardServerTestFixture {
+class CollectionShardingRuntimeWithRangeDeleterTest : public CollectionShardingRuntimeTest {
 public:
     void setUp() override {
         ShardServerTestFixture::setUp();
diff --git a/src/mongo/db/s/metadata_manager_test.cpp b/src/mongo/db/s/metadata_manager_test.cpp
index ea40d8dcb61..71995b20b72 100644
--- a/src/mongo/db/s/metadata_manager_test.cpp
+++ b/src/mongo/db/s/metadata_manager_test.cpp
@@ -88,8 +88,11 @@ protected:
             boost::none,
             {ChunkType{kNss, range, ChunkVersion(1, 0, epoch), kOtherShard}});
 
-        return CollectionMetadata(
-            ChunkManager(kThisShard, DatabaseVersion(UUID::gen(), 1), rt, boost::none), kThisShard);
+        return CollectionMetadata(ChunkManager(kThisShard,
+                                               DatabaseVersion(UUID::gen(), 1),
+                                               makeStandaloneRoutingTableHistory(std::move(rt)),
+                                               boost::none),
+                                  kThisShard);
     }
 
     /**
@@ -131,7 +134,10 @@ protected:
 
         auto rt = cm->getRoutingTableHistory_ForTest().makeUpdated(boost::none, splitChunks);
 
-        return CollectionMetadata(ChunkManager(cm->dbPrimary(), cm->dbVersion(), rt, boost::none),
+        return CollectionMetadata(ChunkManager(cm->dbPrimary(),
+                                               cm->dbVersion(),
+                                               makeStandaloneRoutingTableHistory(std::move(rt)),
+                                               boost::none),
                                   kThisShard);
     }
 
@@ -153,7 +159,10 @@ protected:
         auto rt = cm->getRoutingTableHistory_ForTest().makeUpdated(
             boost::none, {ChunkType(kNss, ChunkRange(minKey, maxKey), chunkVersion, kOtherShard)});
 
-        return CollectionMetadata(ChunkManager(cm->dbPrimary(), cm->dbVersion(), rt, boost::none),
+        return CollectionMetadata(ChunkManager(cm->dbPrimary(),
+                                               cm->dbVersion(),
+                                               makeStandaloneRoutingTableHistory(std::move(rt)),
+                                               boost::none),
                                   kThisShard);
     }
 
diff --git a/src/mongo/db/s/migration_chunk_cloner_source_legacy_test.cpp b/src/mongo/db/s/migration_chunk_cloner_source_legacy_test.cpp
index 82426d039a1..3d87d74f94b 100644
--- a/src/mongo/db/s/migration_chunk_cloner_source_legacy_test.cpp
+++ b/src/mongo/db/s/migration_chunk_cloner_source_legacy_test.cpp
@@ -165,11 +165,12 @@ protected:
             CollectionShardingRuntime::get(operationContext(), kNss)
                 ->setFilteringMetadata(
                     operationContext(),
-                    CollectionMetadata(ChunkManager(ShardId("dummyShardId"),
-                                                    DatabaseVersion(UUID::gen(), 1),
-                                                    rt,
-                                                    boost::none),
-                                       ShardId("dummyShardId")));
+                    CollectionMetadata(
+                        ChunkManager(ShardId("dummyShardId"),
+                                     DatabaseVersion(UUID::gen(), 1),
+                                     makeStandaloneRoutingTableHistory(std::move(rt)),
+                                     boost::none),
+                        ShardId("dummyShardId")));
         }();
 
         _client->createIndex(kNss.ns(), kShardKeyPattern);
diff --git a/src/mongo/db/s/op_observer_sharding_test.cpp b/src/mongo/db/s/op_observer_sharding_test.cpp
index fd32555ba66..f1c78c2d9e9 100644
--- a/src/mongo/db/s/op_observer_sharding_test.cpp
+++ b/src/mongo/db/s/op_observer_sharding_test.cpp
@@ -53,31 +53,35 @@ void setCollectionFilteringMetadata(OperationContext* opCtx, CollectionMetadata
     oss.initializeClientRoutingVersionsFromCommand(kTestNss, builder.obj());
 }
 
-/**
- * Constructs a CollectionMetadata suitable for refreshing a CollectionShardingState. The only
- * salient detail is the argument `keyPattern` which, defining the shard key, selects the fields
- * that DeleteState's constructor will extract from its `doc` argument into its member
- * DeleteState::documentKey.
- */
-CollectionMetadata makeAMetadata(BSONObj const& keyPattern) {
-    const OID epoch = OID::gen();
-    auto range = ChunkRange(BSON("key" << MINKEY), BSON("key" << MAXKEY));
-    auto chunk = ChunkType(kTestNss, std::move(range), ChunkVersion(1, 0, epoch), ShardId("other"));
-    auto rt = RoutingTableHistory::makeNew(kTestNss,
-                                           UUID::gen(),
-                                           KeyPattern(keyPattern),
-                                           nullptr,
-                                           false,
-                                           epoch,
-                                           boost::none,
-                                           {std::move(chunk)});
-
-    return CollectionMetadata(
-        ChunkManager(ShardId("this"), DatabaseVersion(UUID::gen(), 1), rt, Timestamp(100, 0)),
-        ShardId("this"));
-}
-
-class DeleteStateTest : public ShardServerTestFixture {};
+class DeleteStateTest : public ShardServerTestFixture {
+protected:
+    /**
+     * Constructs a CollectionMetadata suitable for refreshing a CollectionShardingState. The only
+     * salient detail is the argument `keyPattern` which, defining the shard key, selects the fields
+     * that DeleteState's constructor will extract from its `doc` argument into its member
+     * DeleteState::documentKey.
+     */
+    static CollectionMetadata makeAMetadata(BSONObj const& keyPattern) {
+        const OID epoch = OID::gen();
+        auto range = ChunkRange(BSON("key" << MINKEY), BSON("key" << MAXKEY));
+        auto chunk =
+            ChunkType(kTestNss, std::move(range), ChunkVersion(1, 0, epoch), ShardId("other"));
+        auto rt = RoutingTableHistory::makeNew(kTestNss,
+                                               UUID::gen(),
+                                               KeyPattern(keyPattern),
+                                               nullptr,
+                                               false,
+                                               epoch,
+                                               boost::none,
+                                               {std::move(chunk)});
+
+        return CollectionMetadata(ChunkManager(ShardId("this"),
+                                               DatabaseVersion(UUID::gen(), 1),
+                                               makeStandaloneRoutingTableHistory(std::move(rt)),
+                                               Timestamp(100, 0)),
+                                  ShardId("this"));
+    }
+};
 
 TEST_F(DeleteStateTest, MakeDeleteStateUnsharded) {
     setCollectionFilteringMetadata(operationContext(), CollectionMetadata());
diff --git a/src/mongo/db/s/range_deletion_util_test.cpp b/src/mongo/db/s/range_deletion_util_test.cpp
index d9874802768..b2de302ab59 100644
--- a/src/mongo/db/s/range_deletion_util_test.cpp
+++ b/src/mongo/db/s/range_deletion_util_test.cpp
@@ -105,12 +105,13 @@ public:
         AutoGetDb autoDb(operationContext(), kNss.db(), MODE_IX);
         Lock::CollectionLock collLock(operationContext(), kNss, MODE_IX);
         CollectionShardingRuntime::get(operationContext(), kNss)
-            ->setFilteringMetadata(operationContext(),
-                                   CollectionMetadata(ChunkManager(ShardId("dummyShardId"),
-                                                                   DatabaseVersion(UUID::gen(), 1),
-                                                                   rt,
-                                                                   boost::none),
-                                                      ShardId("dummyShardId")));
+            ->setFilteringMetadata(
+                operationContext(),
+                CollectionMetadata(ChunkManager(ShardId("dummyShardId"),
+                                                DatabaseVersion(UUID::gen(), 1),
+                                                makeStandaloneRoutingTableHistory(std::move(rt)),
+                                                boost::none),
+                                   ShardId("dummyShardId")));
     }
 
     UUID uuid() const {