summaryrefslogtreecommitdiff
path: root/src/mongo/client/server_discovery_monitor_test.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/mongo/client/server_discovery_monitor_test.cpp')
-rw-r--r--src/mongo/client/server_discovery_monitor_test.cpp252
1 files changed, 127 insertions, 125 deletions
diff --git a/src/mongo/client/server_discovery_monitor_test.cpp b/src/mongo/client/server_discovery_monitor_test.cpp
index 98dc5d0d007..8747ccfc96d 100644
--- a/src/mongo/client/server_discovery_monitor_test.cpp
+++ b/src/mongo/client/server_discovery_monitor_test.cpp
@@ -120,53 +120,53 @@ protected:
}
/**
- * Sets up a SingleServerDiscoveryMonitor that starts sending "hello" to the server.
+ * Sets up a SingleServerDiscoveryMonitor that starts sending isMasters to the server.
*/
std::shared_ptr<SingleServerDiscoveryMonitor> initSingleServerDiscoveryMonitor(
const sdam::SdamConfiguration& sdamConfiguration,
const HostAndPort& hostAndPort,
MockReplicaSet* replSet) {
- auto ssHelloMonitor = std::make_shared<SingleServerDiscoveryMonitor>(replSet->getURI(),
- hostAndPort,
- boost::none,
- sdamConfiguration,
- _eventsPublisher,
- _executor,
- _stats);
- ssHelloMonitor->init();
-
- // Ensure that the clock has not advanced since setUp() and _startDate is representative of
- // when the first "hello" request was sent.
+ auto ssIsMasterMonitor = std::make_shared<SingleServerDiscoveryMonitor>(replSet->getURI(),
+ hostAndPort,
+ boost::none,
+ sdamConfiguration,
+ _eventsPublisher,
+ _executor,
+ _stats);
+ ssIsMasterMonitor->init();
+
+ // Ensure that the clock has not advanced since setUp() and _startDate is representative
+ // of when the first isMaster request was sent.
ASSERT_EQ(getStartDate(), getNet()->now());
- return ssHelloMonitor;
+ return ssIsMasterMonitor;
}
std::shared_ptr<ServerDiscoveryMonitor> initServerDiscoveryMonitor(
const MongoURI& setUri,
const sdam::SdamConfiguration& sdamConfiguration,
const sdam::TopologyDescriptionPtr topologyDescription) {
- auto serverHelloMonitor = std::make_shared<ServerDiscoveryMonitor>(
+ auto serverIsMasterMonitor = std::make_shared<ServerDiscoveryMonitor>(
setUri, sdamConfiguration, _eventsPublisher, topologyDescription, _stats, _executor);
// Ensure that the clock has not advanced since setUp() and _startDate is representative
- // of when the first "hello" request was sent.
+ // of when the first isMaster request was sent.
ASSERT_EQ(getStartDate(), getNet()->now());
- return serverHelloMonitor;
+ return serverIsMasterMonitor;
}
/**
- * Checks that an "hello" request has been sent to some server and schedules a response. If
- * assertHostCheck is true, asserts that the "hello" was sent to the server at hostAndPort.
+ * Checks that an isMaster request has been sent to some server and schedules a response. If
+ * assertHostCheck is true, asserts that the isMaster was sent to the server at hostAndPort.
*/
- void processHelloRequest(MockReplicaSet* replSet,
- boost::optional<HostAndPort> hostAndPort = boost::none) {
+ void processIsMasterRequest(MockReplicaSet* replSet,
+ boost::optional<HostAndPort> hostAndPort = boost::none) {
ASSERT(hasReadyRequests());
InNetworkGuard guard(_net);
_net->runReadyNetworkOperations();
auto noi = _net->getNextReadyRequest();
auto request = noi->getRequest();
- executor::TaskExecutorTest::assertRemoteCommandNameEquals("hello", request);
+ executor::TaskExecutorTest::assertRemoteCommandNameEquals("isMaster", request);
auto requestHost = request.target.toString();
if (hostAndPort) {
ASSERT_EQ(request.target, hostAndPort);
@@ -201,55 +201,55 @@ protected:
}
/**
- * Checks that exactly one successful "hello" occurs within a time interval of
+ * Checks that exactly one successful isMaster occurs within a time interval of
* heartbeatFrequency.
*/
- void checkSingleHello(Milliseconds heartbeatFrequency,
- const HostAndPort& hostAndPort,
- MockReplicaSet* replSet) {
+ void checkSingleIsMaster(Milliseconds heartbeatFrequency,
+ const HostAndPort& hostAndPort,
+ MockReplicaSet* replSet) {
auto deadline = elapsed() + heartbeatFrequency;
- processHelloRequest(replSet, hostAndPort);
+ processIsMasterRequest(replSet, hostAndPort);
- while (elapsed() < deadline && !_topologyListener->hasHelloResponse(hostAndPort)) {
+ while (elapsed() < deadline && !_topologyListener->hasIsMasterResponse(hostAndPort)) {
advanceTime(Milliseconds(1));
}
- validateHelloResponse(hostAndPort, deadline);
+ validateIsMasterResponse(hostAndPort, deadline);
checkNoActivityBefore(deadline, hostAndPort);
}
- void validateHelloResponse(const HostAndPort& hostAndPort, Milliseconds deadline) {
- ASSERT_TRUE(_topologyListener->hasHelloResponse(hostAndPort));
+ void validateIsMasterResponse(const HostAndPort& hostAndPort, Milliseconds deadline) {
+ ASSERT_TRUE(_topologyListener->hasIsMasterResponse(hostAndPort));
ASSERT_LT(elapsed(), deadline);
- auto helloResponse = _topologyListener->getHelloResponse(hostAndPort);
+ auto isMasterResponse = _topologyListener->getIsMasterResponse(hostAndPort);
- // There should only be one "hello" response queued up.
- ASSERT_EQ(helloResponse.size(), 1);
- ASSERT(helloResponse[0].isOK());
+ // There should only be one isMaster response queued up.
+ ASSERT_EQ(isMasterResponse.size(), 1);
+ ASSERT(isMasterResponse[0].isOK());
}
/**
- * Confirms no more "hello" requests are sent between elapsed() and deadline. Confirms no more
- * "hello" responses are received between elapsed() and deadline when hostAndPort is specified.
+ * Confirms no more isMaster requests are sent between elapsed() and deadline. Confirms no more
+ * isMaster responses are received between elapsed() and deadline when hostAndPort is specified.
*/
void checkNoActivityBefore(Milliseconds deadline,
boost::optional<HostAndPort> hostAndPort = boost::none) {
while (elapsed() < deadline) {
ASSERT_FALSE(hasReadyRequests());
if (hostAndPort) {
- ASSERT_FALSE(_topologyListener->hasHelloResponse(hostAndPort.get()));
+ ASSERT_FALSE(_topologyListener->hasIsMasterResponse(hostAndPort.get()));
}
advanceTime(Milliseconds(1));
}
}
/**
- * Waits up to timeoutMS for the next "hello" request to go out. Causes the test to fail if
- * timeoutMS time passes and no request is ready.
+ * Waits up to timeoutMS for the next isMaster request to go out.
+ * Causes the test to fail if timeoutMS time passes and no request is ready.
*
- * NOTE: The time between each "hello" request is the heartbeatFrequency compounded by response
+ * NOTE: The time between each isMaster request is the heartbeatFrequency compounded by response
* time.
*/
- void waitForNextHello(Milliseconds timeoutMS) {
+ void waitForNextIsMaster(Milliseconds timeoutMS) {
auto deadline = elapsed() + timeoutMS;
while (!hasReadyRequests() && elapsed() < deadline) {
advanceTime(Milliseconds(1));
@@ -272,7 +272,7 @@ private:
};
/**
- * Checks that a SingleServerDiscoveryMonitor sends "hello" requests at least heartbeatFrequency
+ * Checks that a SingleServerDiscoveryMonitor sends isMaster requests at least heartbeatFrequency
* apart.
*/
TEST_F(ServerDiscoveryMonitorTestFixture, heartbeatFrequencyCheck) {
@@ -281,28 +281,28 @@ TEST_F(ServerDiscoveryMonitorTestFixture, heartbeatFrequencyCheck) {
auto hostAndPort = HostAndPort(replSet->getSecondaries()[0]);
const auto config = SdamConfiguration(std::vector<HostAndPort>{hostAndPort});
- auto ssHelloMonitor = initSingleServerDiscoveryMonitor(config, hostAndPort, replSet.get());
- ssHelloMonitor->disableExpeditedChecking();
+ auto ssIsMasterMonitor = initSingleServerDiscoveryMonitor(config, hostAndPort, replSet.get());
+ ssIsMasterMonitor->disableExpeditedChecking();
- // A "hello" command fails if it takes as long or longer than timeoutMS.
+ // An isMaster command fails if it takes as long or longer than timeoutMS.
auto timeoutMS = config.getConnectionTimeout();
auto heartbeatFrequency = config.getHeartBeatFrequency();
- checkSingleHello(heartbeatFrequency, hostAndPort, replSet.get());
- waitForNextHello(timeoutMS);
+ checkSingleIsMaster(heartbeatFrequency, hostAndPort, replSet.get());
+ waitForNextIsMaster(timeoutMS);
- checkSingleHello(heartbeatFrequency, hostAndPort, replSet.get());
- waitForNextHello(timeoutMS);
+ checkSingleIsMaster(heartbeatFrequency, hostAndPort, replSet.get());
+ waitForNextIsMaster(timeoutMS);
- checkSingleHello(heartbeatFrequency, hostAndPort, replSet.get());
- waitForNextHello(timeoutMS);
+ checkSingleIsMaster(heartbeatFrequency, hostAndPort, replSet.get());
+ waitForNextIsMaster(timeoutMS);
- checkSingleHello(heartbeatFrequency, hostAndPort, replSet.get());
- waitForNextHello(timeoutMS);
+ checkSingleIsMaster(heartbeatFrequency, hostAndPort, replSet.get());
+ waitForNextIsMaster(timeoutMS);
}
/**
- * Confirms that a SingleServerDiscoveryMonitor reports to the TopologyListener when a "hello"
+ * Confirms that a SingleServerDiscoveryMonitor reports to the TopologyListener when an isMaster
* command generates an error.
*/
TEST_F(ServerDiscoveryMonitorTestFixture, singleServerDiscoveryMonitorReportsFailure) {
@@ -317,23 +317,23 @@ TEST_F(ServerDiscoveryMonitorTestFixture, singleServerDiscoveryMonitorReportsFai
}
const auto config = SdamConfiguration(std::vector<HostAndPort>{hostAndPort});
- auto ssHelloMonitor = initSingleServerDiscoveryMonitor(config, hostAndPort, replSet.get());
- ssHelloMonitor->disableExpeditedChecking();
+ auto ssIsMasterMonitor = initSingleServerDiscoveryMonitor(config, hostAndPort, replSet.get());
+ ssIsMasterMonitor->disableExpeditedChecking();
- processHelloRequest(replSet.get(), hostAndPort);
+ processIsMasterRequest(replSet.get(), hostAndPort);
auto topologyListener = getTopologyListener();
auto timeoutMS = config.getConnectionTimeout();
- while (elapsed() < timeoutMS && !topologyListener->hasHelloResponse(hostAndPort)) {
- // Advance time in small increments to ensure we stop before another "hello" is sent.
+ while (elapsed() < timeoutMS && !topologyListener->hasIsMasterResponse(hostAndPort)) {
+ // Advance time in small increments to ensure we stop before another isMaster is sent.
advanceTime(Milliseconds(1));
}
- ASSERT_TRUE(topologyListener->hasHelloResponse(hostAndPort));
- auto response = topologyListener->getHelloResponse(hostAndPort);
+ ASSERT_TRUE(topologyListener->hasIsMasterResponse(hostAndPort));
+ auto response = topologyListener->getIsMasterResponse(hostAndPort);
ASSERT_EQ(response.size(), 1);
ASSERT_EQ(response[0], ErrorCodes::HostUnreachable);
}
-TEST_F(ServerDiscoveryMonitorTestFixture, ServerHelloMonitorOnTopologyDescriptionChangeAddHost) {
+TEST_F(ServerDiscoveryMonitorTestFixture, serverIsMasterMonitorOnTopologyDescriptionChangeAddHost) {
auto replSet = std::make_unique<MockReplicaSet>(
"test", 2, /* hasPrimary = */ false, /* dollarPrefixHosts = */ false);
@@ -345,11 +345,11 @@ TEST_F(ServerDiscoveryMonitorTestFixture, ServerHelloMonitorOnTopologyDescriptio
auto sdamConfig0 = sdam::SdamConfiguration(host0Vec);
auto topologyDescription0 = std::make_shared<sdam::TopologyDescription>(sdamConfig0);
auto uri = replSet->getURI();
- auto helloMonitor = initServerDiscoveryMonitor(uri, sdamConfig0, topologyDescription0);
- helloMonitor->disableExpeditedChecking();
+ auto isMasterMonitor = initServerDiscoveryMonitor(uri, sdamConfig0, topologyDescription0);
+ isMasterMonitor->disableExpeditedChecking();
auto host1Delay = Milliseconds(100);
- checkSingleHello(host1Delay, host0, replSet.get());
+ checkSingleIsMaster(host1Delay, host0, replSet.get());
ASSERT_FALSE(hasReadyRequests());
// Start monitoring host1.
@@ -358,20 +358,21 @@ TEST_F(ServerDiscoveryMonitorTestFixture, ServerHelloMonitorOnTopologyDescriptio
auto sdamConfigAllHosts = sdam::SdamConfiguration(allHostsVec);
auto topologyDescriptionAllHosts =
std::make_shared<sdam::TopologyDescription>(sdamConfigAllHosts);
- helloMonitor->onTopologyDescriptionChangedEvent(topologyDescription0,
- topologyDescriptionAllHosts);
+ isMasterMonitor->onTopologyDescriptionChangedEvent(topologyDescription0,
+ topologyDescriptionAllHosts);
// Ensure expedited checking is disabled for the SingleServerDiscoveryMonitor corresponding to
// host1 as well.
- helloMonitor->disableExpeditedChecking();
+ isMasterMonitor->disableExpeditedChecking();
// Confirm host0 and host1 are monitored.
auto heartbeatFrequency = sdamConfigAllHosts.getHeartBeatFrequency();
- checkSingleHello(heartbeatFrequency - host1Delay, host1, replSet.get());
- waitForNextHello(sdamConfigAllHosts.getConnectionTimeout());
- checkSingleHello(host1Delay, host0, replSet.get());
+ checkSingleIsMaster(heartbeatFrequency - host1Delay, host1, replSet.get());
+ waitForNextIsMaster(sdamConfigAllHosts.getConnectionTimeout());
+ checkSingleIsMaster(host1Delay, host0, replSet.get());
}
-TEST_F(ServerDiscoveryMonitorTestFixture, ServerHelloMonitorOnTopologyDescriptionChangeRemoveHost) {
+TEST_F(ServerDiscoveryMonitorTestFixture,
+ serverIsMasterMonitorOnTopologyDescriptionChangeRemoveHost) {
auto replSet = std::make_unique<MockReplicaSet>(
"test", 2, /* hasPrimary = */ false, /* dollarPrefixHosts = */ false);
@@ -385,45 +386,45 @@ TEST_F(ServerDiscoveryMonitorTestFixture, ServerHelloMonitorOnTopologyDescriptio
auto topologyDescriptionAllHosts =
std::make_shared<sdam::TopologyDescription>(sdamConfigAllHosts);
auto uri = replSet->getURI();
- auto helloMonitor =
+ auto isMasterMonitor =
initServerDiscoveryMonitor(uri, sdamConfigAllHosts, topologyDescriptionAllHosts);
- helloMonitor->disableExpeditedChecking();
+ isMasterMonitor->disableExpeditedChecking();
// Confirm that both hosts are monitored.
auto heartbeatFrequency = sdamConfigAllHosts.getHeartBeatFrequency();
while (hasReadyRequests()) {
- processHelloRequest(replSet.get());
+ processIsMasterRequest(replSet.get());
}
auto deadline = elapsed() + heartbeatFrequency;
auto topologyListener = getTopologyListener();
auto hasResponses = [&]() {
- return topologyListener->hasHelloResponse(host0) &&
- topologyListener->hasHelloResponse(host1);
+ return topologyListener->hasIsMasterResponse(host0) &&
+ topologyListener->hasIsMasterResponse(host1);
};
while (elapsed() < heartbeatFrequency && !hasResponses()) {
advanceTime(Milliseconds(1));
}
- validateHelloResponse(host0, deadline);
- validateHelloResponse(host1, deadline);
+ validateIsMasterResponse(host0, deadline);
+ validateIsMasterResponse(host1, deadline);
// Remove host1 from the TopologyDescription to stop monitoring it.
std::vector<HostAndPort> host0Vec{host0};
auto sdamConfig0 = sdam::SdamConfiguration(host0Vec);
auto topologyDescription0 = std::make_shared<sdam::TopologyDescription>(sdamConfig0);
- helloMonitor->onTopologyDescriptionChangedEvent(topologyDescriptionAllHosts,
- topologyDescription0);
+ isMasterMonitor->onTopologyDescriptionChangedEvent(topologyDescriptionAllHosts,
+ topologyDescription0);
checkNoActivityBefore(deadline);
- waitForNextHello(sdamConfig0.getConnectionTimeout());
+ waitForNextIsMaster(sdamConfig0.getConnectionTimeout());
- checkSingleHello(heartbeatFrequency, host0, replSet.get());
- waitForNextHello(sdamConfig0.getConnectionTimeout());
+ checkSingleIsMaster(heartbeatFrequency, host0, replSet.get());
+ waitForNextIsMaster(sdamConfig0.getConnectionTimeout());
- // Confirm the next "hello" request is sent to host0 and not host1.
- checkSingleHello(heartbeatFrequency, host0, replSet.get());
+ // Confirm the next isMaster request is sent to host0 and not host1.
+ checkSingleIsMaster(heartbeatFrequency, host0, replSet.get());
}
-TEST_F(ServerDiscoveryMonitorTestFixture, ServerHelloMonitorShutdownStopsHelloRequests) {
+TEST_F(ServerDiscoveryMonitorTestFixture, serverIsMasterMonitorShutdownStopsIsMasterRequests) {
auto replSet = std::make_unique<MockReplicaSet>(
"test", 1, /* hasPrimary = */ false, /* dollarPrefixHosts = */ false);
@@ -431,13 +432,13 @@ TEST_F(ServerDiscoveryMonitorTestFixture, ServerHelloMonitorShutdownStopsHelloRe
auto sdamConfig = sdam::SdamConfiguration(hostVec);
auto topologyDescription = std::make_shared<sdam::TopologyDescription>(sdamConfig);
auto uri = replSet->getURI();
- auto helloMonitor = initServerDiscoveryMonitor(uri, sdamConfig, topologyDescription);
- helloMonitor->disableExpeditedChecking();
+ auto isMasterMonitor = initServerDiscoveryMonitor(uri, sdamConfig, topologyDescription);
+ isMasterMonitor->disableExpeditedChecking();
auto heartbeatFrequency = sdamConfig.getHeartBeatFrequency();
- checkSingleHello(heartbeatFrequency - Milliseconds(200), hostVec[0], replSet.get());
+ checkSingleIsMaster(heartbeatFrequency - Milliseconds(200), hostVec[0], replSet.get());
- helloMonitor->shutdown();
+ isMasterMonitor->shutdown();
// After the ServerDiscoveryMonitor shuts down, the TopologyListener may have responses until
// heartbeatFrequency has passed, but none of them should indicate Status::OK.
@@ -447,26 +448,27 @@ TEST_F(ServerDiscoveryMonitorTestFixture, ServerHelloMonitorShutdownStopsHelloRe
// Drain any requests already scheduled.
while (elapsed() < deadline) {
while (hasReadyRequests()) {
- processHelloRequest(replSet.get(), hostVec[0]);
+ processIsMasterRequest(replSet.get(), hostVec[0]);
}
- if (topologyListener->hasHelloResponse(hostVec[0])) {
- auto helloResponses = topologyListener->getHelloResponse(hostVec[0]);
- for (auto& response : helloResponses) {
+ if (topologyListener->hasIsMasterResponse(hostVec[0])) {
+ auto isMasterResponses = topologyListener->getIsMasterResponse(hostVec[0]);
+ for (auto& response : isMasterResponses) {
ASSERT_FALSE(response.isOK());
}
}
advanceTime(Milliseconds(1));
}
- ASSERT_FALSE(topologyListener->hasHelloResponse(hostVec[0]));
+ ASSERT_FALSE(topologyListener->hasIsMasterResponse(hostVec[0]));
}
/**
* Tests that the ServerDiscoveryMonitor waits until SdamConfiguration::kMinHeartbeatFrequency has
- * passed since the last "hello" was received if requestImmediateCheck() is called before enough
+ * passed since the last isMaster was received if requestImmediateCheck() is called before enough
* time has passed.
*/
-TEST_F(ServerDiscoveryMonitorTestFixture, ServerHelloMonitorRequestImmediateCheckWaitMinHeartbeat) {
+TEST_F(ServerDiscoveryMonitorTestFixture,
+ serverIsMasterMonitorRequestImmediateCheckWaitMinHeartbeat) {
auto replSet = std::make_unique<MockReplicaSet>(
"test", 1, /* hasPrimary = */ false, /* dollarPrefixHosts = */ false);
@@ -476,41 +478,41 @@ TEST_F(ServerDiscoveryMonitorTestFixture, ServerHelloMonitorRequestImmediateChec
auto sdamConfig0 = sdam::SdamConfiguration(hostVec);
auto topologyDescription0 = std::make_shared<sdam::TopologyDescription>(sdamConfig0);
auto uri = replSet->getURI();
- auto helloMonitor = initServerDiscoveryMonitor(uri, sdamConfig0, topologyDescription0);
+ auto isMasterMonitor = initServerDiscoveryMonitor(uri, sdamConfig0, topologyDescription0);
// Ensure the server is not in expedited mode *before* requestImmediateCheck().
- helloMonitor->disableExpeditedChecking();
+ isMasterMonitor->disableExpeditedChecking();
- // Check that there is only one "hello" request at time t=0 up until
- // timeAdvanceFromFirstHello.
+ // Check that there is only one isMaster request at time t=0 up until
+ // timeAdvanceFromFirstIsMaster.
auto minHeartbeatFrequency = SdamConfiguration::kMinHeartbeatFrequency;
- auto timeAdvanceFromFirstHello = Milliseconds(10);
- ASSERT_LT(timeAdvanceFromFirstHello, minHeartbeatFrequency);
- checkSingleHello(timeAdvanceFromFirstHello, hostVec[0], replSet.get());
+ auto timeAdvanceFromFirstIsMaster = Milliseconds(10);
+ ASSERT_LT(timeAdvanceFromFirstIsMaster, minHeartbeatFrequency);
+ checkSingleIsMaster(timeAdvanceFromFirstIsMaster, hostVec[0], replSet.get());
- // It's been less than SdamConfiguration::kMinHeartbeatFrequency since the last "hello" was
- // received. The next "hello" should be sent SdamConfiguration::kMinHeartbeatFrequency since
- // the last "hello" was recieved rather than immediately.
+ // It's been less than SdamConfiguration::kMinHeartbeatFrequency since the last isMaster was
+ // received. The next isMaster should be sent SdamConfiguration::kMinHeartbeatFrequency since
+ // the last isMaster was recieved rather than immediately.
auto timeRequestImmediateSent = elapsed();
- helloMonitor->requestImmediateCheck();
- waitForNextHello(minHeartbeatFrequency);
+ isMasterMonitor->requestImmediateCheck();
+ waitForNextIsMaster(minHeartbeatFrequency);
- auto timeHelloSent = elapsed();
- ASSERT_LT(timeRequestImmediateSent, timeHelloSent);
- ASSERT_LT(timeHelloSent, timeRequestImmediateSent + minHeartbeatFrequency);
- checkSingleHello(minHeartbeatFrequency, hostVec[0], replSet.get());
+ auto timeIsMasterSent = elapsed();
+ ASSERT_LT(timeRequestImmediateSent, timeIsMasterSent);
+ ASSERT_LT(timeIsMasterSent, timeRequestImmediateSent + minHeartbeatFrequency);
+ checkSingleIsMaster(minHeartbeatFrequency, hostVec[0], replSet.get());
// Confirm expedited requests continue since there is no primary.
- waitForNextHello(sdamConfig0.getConnectionTimeout());
- checkSingleHello(minHeartbeatFrequency, hostVec[0], replSet.get());
+ waitForNextIsMaster(sdamConfig0.getConnectionTimeout());
+ checkSingleIsMaster(minHeartbeatFrequency, hostVec[0], replSet.get());
}
/**
* Tests that if more than SdamConfiguration::kMinHeartbeatFrequency has passed since the last
- * "hello" response was received, the ServerDiscoveryMonitor sends an "hello" immediately after
+ * isMaster response was received, the ServerDiscoveryMonitor sends an isMaster immediately after
* requestImmediateCheck() is called.
*/
-TEST_F(ServerDiscoveryMonitorTestFixture, ServerHelloMonitorRequestImmediateCheckNoWait) {
+TEST_F(ServerDiscoveryMonitorTestFixture, serverIsMasterMonitorRequestImmediateCheckNoWait) {
auto replSet = std::make_unique<MockReplicaSet>(
"test", 1, /* hasPrimary = */ false, /* dollarPrefixHosts = */ false);
@@ -520,23 +522,23 @@ TEST_F(ServerDiscoveryMonitorTestFixture, ServerHelloMonitorRequestImmediateChec
auto sdamConfig0 = sdam::SdamConfiguration(hostVec);
auto topologyDescription0 = std::make_shared<sdam::TopologyDescription>(sdamConfig0);
auto uri = replSet->getURI();
- auto helloMonitor = initServerDiscoveryMonitor(uri, sdamConfig0, topologyDescription0);
+ auto isMasterMonitor = initServerDiscoveryMonitor(uri, sdamConfig0, topologyDescription0);
// Ensure the server is not in expedited mode *before* requestImmediateCheck().
- helloMonitor->disableExpeditedChecking();
+ isMasterMonitor->disableExpeditedChecking();
// No less than SdamConfiguration::kMinHeartbeatFrequency must pass before
// requestImmediateCheck() is called in order to ensure the server reschedules for an immediate
// check.
auto minHeartbeatFrequency = SdamConfiguration::kMinHeartbeatFrequency;
- checkSingleHello(minHeartbeatFrequency + Milliseconds(10), hostVec[0], replSet.get());
+ checkSingleIsMaster(minHeartbeatFrequency + Milliseconds(10), hostVec[0], replSet.get());
- helloMonitor->requestImmediateCheck();
- checkSingleHello(minHeartbeatFrequency, hostVec[0], replSet.get());
+ isMasterMonitor->requestImmediateCheck();
+ checkSingleIsMaster(minHeartbeatFrequency, hostVec[0], replSet.get());
// Confirm expedited requests continue since there is no primary.
- waitForNextHello(sdamConfig0.getConnectionTimeout());
- checkSingleHello(minHeartbeatFrequency, hostVec[0], replSet.get());
+ waitForNextIsMaster(sdamConfig0.getConnectionTimeout());
+ checkSingleIsMaster(minHeartbeatFrequency, hostVec[0], replSet.get());
}
} // namespace
generated by cgit v1.2.3 (git 2.39.1) at 2026-09-11 10:59:45 +0000