summaryrefslogtreecommitdiffstats
path: root/storage/src
diff options
context:
space:
mode:
authorTor Brede Vekterli <vekterli@verizonmedia.com>2019-03-27 16:27:24 +0000
committerTor Brede Vekterli <vekterli@verizonmedia.com>2019-03-27 16:27:24 +0000
commitb7299fc7442f678bc2d7e8c82a6aeb18f76dc253 (patch)
tree4fda988470742c3f812c913bfc46f4ccdfb28eb8 /storage/src
parent5e33bb54604989bb2cef605572f7750d45eb630a (diff)
Convert BucketDBUpdaterTest from CppUnit to GTest
Diffstat (limited to 'storage/src')
-rw-r--r--storage/src/tests/CMakeLists.txt1
-rw-r--r--storage/src/tests/distributor/CMakeLists.txt14
-rw-r--r--storage/src/tests/distributor/bucketdbupdatertest.cpp1478
3 files changed, 597 insertions, 896 deletions
diff --git a/storage/src/tests/CMakeLists.txt b/storage/src/tests/CMakeLists.txt
index c4436161f28..1894a3fe6a8 100644
--- a/storage/src/tests/CMakeLists.txt
+++ b/storage/src/tests/CMakeLists.txt
@@ -7,6 +7,7 @@ vespa_add_executable(storage_gtest_runner_app TEST
gtest_runner.cpp
DEPENDS
storage_testbucketmover
+ storage_gtestdistributor
)
vespa_add_test(
diff --git a/storage/src/tests/distributor/CMakeLists.txt b/storage/src/tests/distributor/CMakeLists.txt
index f58fd37f622..1e9dca3f7f1 100644
--- a/storage/src/tests/distributor/CMakeLists.txt
+++ b/storage/src/tests/distributor/CMakeLists.txt
@@ -4,7 +4,6 @@ vespa_add_library(storage_testdistributor TEST
blockingoperationstartertest.cpp
bucketdatabasetest.cpp
bucketdbmetricupdatertest.cpp
- bucketdbupdatertest.cpp
bucketgctimecalculatortest.cpp
bucketstateoperationtest.cpp
distributor_host_info_reporter_test.cpp
@@ -46,3 +45,16 @@ vespa_add_library(storage_testdistributor TEST
storage_testcommon
storage_testhostreporter
)
+
+vespa_add_library(storage_gtestdistributor TEST
+ SOURCES
+ bucketdbupdatertest.cpp
+ # Fixture etc. dupes with non-gtest runner :
+ distributortestutil.cpp
+ messagesenderstub.cpp
+ DEPENDS
+ storage_distributor
+ storage_testcommon
+ storage_testhostreporter
+ gtest
+)
diff --git a/storage/src/tests/distributor/bucketdbupdatertest.cpp b/storage/src/tests/distributor/bucketdbupdatertest.cpp
index 9795f5db5dc..2beae2ac43b 100644
--- a/storage/src/tests/distributor/bucketdbupdatertest.cpp
+++ b/storage/src/tests/distributor/bucketdbupdatertest.cpp
@@ -1,7 +1,5 @@
// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-#include <vespa/vdstestlib/cppunit/macros.h>
-#include <iomanip>
#include <vespa/storageapi/message/persistence.h>
#include <vespa/storage/distributor/bucketdbupdater.h>
#include <vespa/storage/distributor/distributormetricsset.h>
@@ -19,6 +17,9 @@
#include <vespa/storage/distributor/distributor_bucket_space.h>
#include <vespa/vespalib/text/stringtokenizer.h>
#include <sstream>
+#include <iomanip>
+
+#include <gtest/gtest.h>
using namespace storage::api;
using namespace storage::lib;
@@ -29,6 +30,8 @@ using document::FixedBucketSpaces;
using document::BucketId;
using document::Bucket;
+using namespace ::testing;
+
namespace storage::distributor {
namespace {
@@ -54,145 +57,12 @@ getRequestBucketInfoStrings(uint32_t count)
}
-class BucketDBUpdaterTest : public CppUnit::TestFixture,
+class BucketDBUpdaterTest : public Test,
public DistributorTestUtil
{
- CPPUNIT_TEST_SUITE(BucketDBUpdaterTest);
- CPPUNIT_TEST(testNormalUsage); // Make sure that bucketdbupdater sends requests to nodes, send responses back for 3 nodes, check that bucketdb is in correct state
- CPPUNIT_TEST(testDistributorChange);
- CPPUNIT_TEST(testDistributorChangeWithGrouping);
- CPPUNIT_TEST(testNormalUsageInitializing); // Check that we send request bucket info when storage node is initializing, and send another when it's up.
- CPPUNIT_TEST(testFailedRequestBucketInfo);
- CPPUNIT_TEST(testBitChange); // Check what happens when distribution bits change
- CPPUNIT_TEST(testNodeDown);
- CPPUNIT_TEST(testStorageNodeInMaintenanceClearsBucketsForNode);
- CPPUNIT_TEST(testNodeDownCopiesGetInSync);
- CPPUNIT_TEST(testDownWhileInit);
- CPPUNIT_TEST(testInitializingWhileRecheck);
- CPPUNIT_TEST(testRecheckNode);
- CPPUNIT_TEST(testRecheckNodeWithFailure);
- CPPUNIT_TEST(testNotifyBucketChange);
- CPPUNIT_TEST(testNotifyBucketChangeFromNodeDown);
- CPPUNIT_TEST(testNotifyChangeWithPendingStateQueuesBucketInfoRequests);
- CPPUNIT_TEST(testMergeReply);
- CPPUNIT_TEST(testMergeReplyNodeDown);
- CPPUNIT_TEST(testMergeReplyNodeDownAfterRequestSent);
- CPPUNIT_TEST(testFlush);
- CPPUNIT_TEST(testPendingClusterStateSendMessages);
- CPPUNIT_TEST(testPendingClusterStateReceive);
- CPPUNIT_TEST(testPendingClusterStateMerge);
- CPPUNIT_TEST(testPendingClusterStateMergeReplicaChanged);
- CPPUNIT_TEST(testPendingClusterStateWithGroupDown);
- CPPUNIT_TEST(testPendingClusterStateWithGroupDownAndNoHandover);
- CPPUNIT_TEST(testNoDbResurrectionForBucketNotOwnedInCurrentState);
- CPPUNIT_TEST(testNoDbResurrectionForBucketNotOwnedInPendingState);
- CPPUNIT_TEST(testClusterStateAlwaysSendsFullFetchWhenDistributionChangePending);
- CPPUNIT_TEST(testChangedDistributionConfigTriggersRecoveryMode);
- CPPUNIT_TEST(testNewlyAddedBucketsHaveCurrentTimeAsGcTimestamp);
- CPPUNIT_TEST(testNewerMutationsNotOverwrittenByEarlierBucketFetch);
- CPPUNIT_TEST(preemptedDistrChangeCarriesNodeSetOverToNextStateFetch);
- CPPUNIT_TEST(preemptedStorChangeCarriesNodeSetOverToNextStateFetch);
- CPPUNIT_TEST(preemptedStorageNodeDownMustBeReFetched);
- CPPUNIT_TEST(outdatedNodeSetClearedAfterSuccessfulStateCompletion);
- CPPUNIT_TEST(doNotSendToPreemptedNodeNowInDownState);
- CPPUNIT_TEST(doNotSendToPreemptedNodeNotPartOfNewState);
- CPPUNIT_TEST_DISABLED(clusterConfigDownsizeOnlySendsToAvailableNodes);
- CPPUNIT_TEST(changedDiskSetTriggersReFetch);
- CPPUNIT_TEST(nodeMissingFromConfigIsTreatedAsNeedingOwnershipTransfer);
- CPPUNIT_TEST(changed_distributor_set_implies_ownership_transfer);
- CPPUNIT_TEST(unchanged_distributor_set_implies_no_ownership_transfer);
- CPPUNIT_TEST(changed_distribution_config_implies_ownership_transfer);
- CPPUNIT_TEST(transition_time_tracked_for_single_state_change);
- CPPUNIT_TEST(transition_time_reset_across_non_preempting_state_changes);
- CPPUNIT_TEST(transition_time_tracked_for_distribution_config_change);
- CPPUNIT_TEST(transition_time_tracked_across_preempted_transitions);
- CPPUNIT_TEST(batch_update_of_existing_diverging_replicas_does_not_mark_any_as_trusted);
- CPPUNIT_TEST(batch_add_of_new_diverging_replicas_does_not_mark_any_as_trusted);
- CPPUNIT_TEST(batch_add_with_single_resulting_replica_implicitly_marks_as_trusted);
- CPPUNIT_TEST(identity_update_of_single_replica_does_not_clear_trusted);
- CPPUNIT_TEST(identity_update_of_diverging_untrusted_replicas_does_not_mark_any_as_trusted);
- CPPUNIT_TEST(adding_diverging_replica_to_existing_trusted_does_not_remove_trusted);
- CPPUNIT_TEST(batch_update_from_distributor_change_does_not_mark_diverging_replicas_as_trusted);
- CPPUNIT_TEST(global_distribution_hash_falls_back_to_legacy_format_upon_request_rejection);
- CPPUNIT_TEST(non_owned_buckets_moved_to_read_only_db_on_ownership_change);
- CPPUNIT_TEST(buckets_no_longer_available_are_not_moved_to_read_only_database);
- CPPUNIT_TEST(non_owned_buckets_purged_when_read_only_support_is_config_disabled);
- CPPUNIT_TEST(deferred_activated_state_does_not_enable_state_until_activation_received);
- CPPUNIT_TEST(read_only_db_cleared_once_pending_state_is_activated);
- CPPUNIT_TEST(read_only_db_is_populated_even_when_self_is_marked_down);
- CPPUNIT_TEST(activate_cluster_state_request_with_mismatching_version_returns_actual_version);
- CPPUNIT_TEST(activate_cluster_state_request_without_pending_transition_passes_message_through);
- CPPUNIT_TEST_SUITE_END();
-
public:
BucketDBUpdaterTest();
-protected:
- void testNormalUsage();
- void testDistributorChange();
- void testDistributorChangeWithGrouping();
- void testNormalUsageInitializing();
- void testFailedRequestBucketInfo();
- void testBitChange();
- void testNodeDown();
- void testStorageNodeInMaintenanceClearsBucketsForNode();
- void testNodeDownCopiesGetInSync();
- void testDownWhileInit();
- void testInitializingWhileRecheck();
- void testRecheckNode();
- void testRecheckNodeWithFailure();
- void testNotifyBucketChange();
- void testNotifyBucketChangeFromNodeDown();
- void testNotifyChangeWithPendingStateQueuesBucketInfoRequests();
- void testMergeReply();
- void testMergeReplyNodeDown();
- void testMergeReplyNodeDownAfterRequestSent();
- void testFlush();
- void testPendingClusterStateSendMessages();
- void testPendingClusterStateReceive();
- void testPendingClusterStateMerge();
- void testPendingClusterStateMergeReplicaChanged();
- void testPendingClusterStateWithGroupDown();
- void testPendingClusterStateWithGroupDownAndNoHandover();
- void testNoDbResurrectionForBucketNotOwnedInCurrentState();
- void testNoDbResurrectionForBucketNotOwnedInPendingState();
- void testClusterStateAlwaysSendsFullFetchWhenDistributionChangePending();
- void testChangedDistributionConfigTriggersRecoveryMode();
- void testNewlyAddedBucketsHaveCurrentTimeAsGcTimestamp();
- void testNewerMutationsNotOverwrittenByEarlierBucketFetch();
- void preemptedDistrChangeCarriesNodeSetOverToNextStateFetch();
- void preemptedStorChangeCarriesNodeSetOverToNextStateFetch();
- void preemptedStorageNodeDownMustBeReFetched();
- void outdatedNodeSetClearedAfterSuccessfulStateCompletion();
- void doNotSendToPreemptedNodeNowInDownState();
- void doNotSendToPreemptedNodeNotPartOfNewState();
- void clusterConfigDownsizeOnlySendsToAvailableNodes();
- void changedDiskSetTriggersReFetch();
- void nodeMissingFromConfigIsTreatedAsNeedingOwnershipTransfer();
- void changed_distributor_set_implies_ownership_transfer();
- void unchanged_distributor_set_implies_no_ownership_transfer();
- void changed_distribution_config_implies_ownership_transfer();
- void transition_time_tracked_for_single_state_change();
- void transition_time_reset_across_non_preempting_state_changes();
- void transition_time_tracked_for_distribution_config_change();
- void transition_time_tracked_across_preempted_transitions();
- void batch_update_of_existing_diverging_replicas_does_not_mark_any_as_trusted();
- void batch_add_of_new_diverging_replicas_does_not_mark_any_as_trusted();
- void batch_add_with_single_resulting_replica_implicitly_marks_as_trusted();
- void identity_update_of_single_replica_does_not_clear_trusted();
- void identity_update_of_diverging_untrusted_replicas_does_not_mark_any_as_trusted();
- void adding_diverging_replica_to_existing_trusted_does_not_remove_trusted();
- void batch_update_from_distributor_change_does_not_mark_diverging_replicas_as_trusted();
- void global_distribution_hash_falls_back_to_legacy_format_upon_request_rejection();
- void non_owned_buckets_moved_to_read_only_db_on_ownership_change();
- void buckets_no_longer_available_are_not_moved_to_read_only_database();
- void non_owned_buckets_purged_when_read_only_support_is_config_disabled();
- void deferred_activated_state_does_not_enable_state_until_activation_received();
- void read_only_db_cleared_once_pending_state_is_activated();
- void read_only_db_is_populated_even_when_self_is_marked_down();
- void activate_cluster_state_request_with_mismatching_version_returns_actual_version();
- void activate_cluster_state_request_without_pending_transition_passes_message_through();
-
auto &defaultDistributorBucketSpace() { return getBucketSpaceRepo().get(makeBucketSpace()); }
bool bucketExistsThatHasNode(int bucketCount, uint16_t node) const;
@@ -250,14 +120,14 @@ protected:
public:
using OutdatedNodesMap = dbtransition::OutdatedNodesMap;
- void setUp() override {
+ void SetUp() override {
createLinks();
_bucketSpaces = getBucketSpaces();
// Disable deferred activation by default (at least for now) to avoid breaking the entire world.
getConfig().setAllowStaleReadsDuringClusterStateTransitions(false);
};
- void tearDown() override {
+ void TearDown() override {
close();
}
@@ -309,7 +179,7 @@ public:
uint32_t bucketCount,
uint32_t invalidBucketCount = 0)
{
- CPPUNIT_ASSERT(cmd.getType() == MessageType::REQUESTBUCKETINFO);
+ ASSERT_EQ(cmd.getType(), MessageType::REQUESTBUCKETINFO);
const api::StorageMessageAddress &address(*cmd.getAddress());
getBucketDBUpdater().onRequestBucketInfoReply(
getFakeBucketReply(state,
@@ -322,7 +192,7 @@ public:
void sendFakeReplyForSingleBucketRequest(
const api::RequestBucketInfoCommand& rbi)
{
- CPPUNIT_ASSERT_EQUAL(size_t(1), rbi.getBuckets().size());
+ ASSERT_EQ(size_t(1), rbi.getBuckets().size());
const document::BucketId& bucket(rbi.getBuckets()[0]);
std::shared_ptr<api::RequestBucketInfoReply> reply(
@@ -379,17 +249,17 @@ public:
void verifyInvalid(document::BucketId id, int storageNode) {
BucketDatabase::Entry entry = getBucketDatabase().get(id);
- CPPUNIT_ASSERT(entry.valid());
+ ASSERT_TRUE(entry.valid());
bool found = false;
for (uint32_t j = 0; j<entry->getNodeCount(); j++) {
if (entry->getNodeRef(j).getNode() == storageNode) {
- CPPUNIT_ASSERT(!entry->getNodeRef(j).valid());
+ ASSERT_FALSE(entry->getNodeRef(j).valid());
found = true;
}
}
- CPPUNIT_ASSERT(found);
+ ASSERT_TRUE(found);
}
struct OrderByIncreasingNodeIndex {
@@ -433,10 +303,10 @@ public:
}
void assert_has_activate_cluster_state_reply_with_actual_version(uint32_t version) {
- CPPUNIT_ASSERT_EQUAL(size_t(1), _sender.replies.size());
+ ASSERT_EQ(size_t(1), _sender.replies.size());
auto* response = dynamic_cast<api::ActivateClusterStateVersionReply*>(_sender.replies.back().get());
- CPPUNIT_ASSERT(response != nullptr);
- CPPUNIT_ASSERT_EQUAL(version, response->actualVersion());
+ ASSERT_TRUE(response != nullptr);
+ ASSERT_EQ(version, response->actualVersion());
_sender.clear();
}
@@ -445,11 +315,11 @@ public:
uint32_t bucketCount = 1,
uint32_t invalidBucketCount = 0)
{
- CPPUNIT_ASSERT_EQUAL(expectedMsgs, _sender.commands.size());
+ ASSERT_EQ(expectedMsgs, _sender.commands.size());
for (uint32_t i = 0; i < _sender.commands.size(); i++) {
- fakeBucketReply(state, *_sender.commands[i],
- bucketCount, invalidBucketCount);
+ ASSERT_NO_FATAL_FAILURE(fakeBucketReply(state, *_sender.commands[i],
+ bucketCount, invalidBucketCount));
}
}
@@ -459,7 +329,7 @@ public:
{
_sender.clear();
setSystemState(state);
- completeBucketInfoGathering(state, expectedMsgs, nBuckets);
+ ASSERT_NO_FATAL_FAILURE(completeBucketInfoGathering(state, expectedMsgs, nBuckets));
}
void completeStateTransitionInSeconds(const std::string& stateStr,
@@ -470,7 +340,7 @@ public:
lib::ClusterState state(stateStr);
setSystemState(state);
getClock().addSecondsToTime(seconds);
- completeBucketInfoGathering(state, expectedMsgs);
+ ASSERT_NO_FATAL_FAILURE(completeBucketInfoGathering(state, expectedMsgs));
}
uint64_t lastTransitionTimeInMillis() {
@@ -486,32 +356,31 @@ public:
setSystemState(newState);
for (uint32_t i=0; i< messageCount(numStorageNodes); i++) {
- CPPUNIT_ASSERT(_sender.commands[i]->getType() ==
- MessageType::REQUESTBUCKETINFO);
+ ASSERT_EQ(_sender.commands[i]->getType(), MessageType::REQUESTBUCKETINFO);
const api::StorageMessageAddress *address = _sender.commands[i]->getAddress();
- CPPUNIT_ASSERT_EQUAL((uint32_t)(i / _bucketSpaces.size()), (uint32_t)address->getIndex());
+ ASSERT_EQ((uint32_t)(i / _bucketSpaces.size()), (uint32_t)address->getIndex());
}
}
void initializeNodesAndBuckets(uint32_t numStorageNodes,
uint32_t numBuckets)
{
- setStorageNodes(numStorageNodes);
+ ASSERT_NO_FATAL_FAILURE(setStorageNodes(numStorageNodes));
vespalib::string state(vespalib::make_string(
"distributor:1 storage:%d", numStorageNodes));
lib::ClusterState newState(state);
for (uint32_t i=0; i< messageCount(numStorageNodes); i++) {
- fakeBucketReply(newState, *_sender.commands[i], numBuckets);
+ ASSERT_NO_FATAL_FAILURE(fakeBucketReply(newState, *_sender.commands[i], numBuckets));
}
- assertCorrectBuckets(numBuckets, state);
+ ASSERT_NO_FATAL_FAILURE(assertCorrectBuckets(numBuckets, state));
}
bool bucketHasNode(document::BucketId id, uint16_t node) const {
BucketDatabase::Entry entry = getBucket(id);
- CPPUNIT_ASSERT(entry.valid());
+ assert(entry.valid());
for (uint32_t j=0; j<entry->getNodeCount(); j++) {
if (entry->getNodeRef(j).getNode() == node) {
@@ -555,9 +424,8 @@ public:
void assertCorrectBuckets(int numBuckets, const std::string& stateStr) {
lib::ClusterState state(stateStr);
for (int i=0; i<numBuckets; i++) {
- CPPUNIT_ASSERT_EQUAL(
- getIdealStr(document::BucketId(16, i), state),
- getNodes(document::BucketId(16, i)));
+ ASSERT_EQ(getIdealStr(document::BucketId(16, i), state),
+ getNodes(document::BucketId(16, i)));
}
}
@@ -677,31 +545,26 @@ public:
}
};
-CPPUNIT_TEST_SUITE_REGISTRATION(BucketDBUpdaterTest);
-
BucketDBUpdaterTest::BucketDBUpdaterTest()
- : CppUnit::TestFixture(),
- DistributorTestUtil(),
+ : DistributorTestUtil(),
_bucketSpaces()
{
}
-void
-BucketDBUpdaterTest::testNormalUsage()
-{
+TEST_F(BucketDBUpdaterTest, testNormalUsage) {
setSystemState(lib::ClusterState("distributor:2 .0.s:i .1.s:i storage:3"));
- CPPUNIT_ASSERT_EQUAL(messageCount(3), _sender.commands.size());
+ ASSERT_EQ(messageCount(3), _sender.commands.size());
// Ensure distribution hash is set correctly
- CPPUNIT_ASSERT_EQUAL(
+ ASSERT_EQ(
defaultDistributorBucketSpace().getDistribution()
.getNodeGraph().getDistributionConfigHash(),
dynamic_cast<const RequestBucketInfoCommand&>(
*_sender.commands[0]).getDistributionHash());
- fakeBucketReply(lib::ClusterState("distributor:2 .0.s:i .1.s:i storage:3"),
- *_sender.commands[0], 10);
+ ASSERT_NO_FATAL_FAILURE(fakeBucketReply(lib::ClusterState("distributor:2 .0.s:i .1.s:i storage:3"),
+ *_sender.commands[0], 10));
_sender.clear();
@@ -709,101 +572,96 @@ BucketDBUpdaterTest::testNormalUsage()
// change is only implemented after completion of previous cluster state
setSystemState(lib::ClusterState("distributor:2 .0.s:i storage:3"));
- CPPUNIT_ASSERT_EQUAL(messageCount(3), _sender.commands.size());
+ ASSERT_EQ(messageCount(3), _sender.commands.size());
// Expect reply of first set SystemState request.
- CPPUNIT_ASSERT_EQUAL(size_t(1), _sender.replies.size());
+ ASSERT_EQ(size_t(1), _sender.replies.size());
- completeBucketInfoGathering(lib::ClusterState("distributor:2 .0.s:i .1.s:i storage:3"),
- messageCount(3), 10);
- assertCorrectBuckets(10, "distributor:2 storage:3");
+ ASSERT_NO_FATAL_FAILURE(completeBucketInfoGathering(
+ lib::ClusterState("distributor:2 .0.s:i .1.s:i storage:3"),
+ messageCount(3), 10));
+ ASSERT_NO_FATAL_FAILURE(assertCorrectBuckets(10, "distributor:2 storage:3"));
}
-void
-BucketDBUpdaterTest::testDistributorChange()
-{
+TEST_F(BucketDBUpdaterTest, testDistributorChange) {
int numBuckets = 100;
// First sends request
setSystemState(lib::ClusterState("distributor:2 .0.s:i .1.s:i storage:3"));
- CPPUNIT_ASSERT_EQUAL(messageCount(3), _sender.commands.size());
- completeBucketInfoGathering(lib::ClusterState("distributor:2 .0.s:i .1.s:i storage:3"),
- messageCount(3), numBuckets);
+ ASSERT_EQ(messageCount(3), _sender.commands.size());
+ ASSERT_NO_FATAL_FAILURE(completeBucketInfoGathering(lib::ClusterState("distributor:2 .0.s:i .1.s:i storage:3"),
+ messageCount(3), numBuckets));
_sender.clear();
// No change from initializing to up (when done with last job)
setSystemState(lib::ClusterState("distributor:2 storage:3"));
- CPPUNIT_ASSERT_EQUAL(size_t(0), _sender.commands.size());
+ ASSERT_EQ(size_t(0), _sender.commands.size());
_sender.clear();
// Adding node. No new read requests, but buckets thrown
setSystemState(lib::ClusterState("distributor:3 storage:3"));
- CPPUNIT_ASSERT_EQUAL(size_t(0), _sender.commands.size());
- assertCorrectBuckets(numBuckets, "distributor:3 storage:3");
+ ASSERT_EQ(size_t(0), _sender.commands.size());
+ ASSERT_NO_FATAL_FAILURE(assertCorrectBuckets(numBuckets, "distributor:3 storage:3"));
_sender.clear();
// Removing distributor. Need to refetch new data from all nodes.
setSystemState(lib::ClusterState("distributor:2 storage:3"));
- CPPUNIT_ASSERT_EQUAL(messageCount(3), _sender.commands.size());
- completeBucketInfoGathering(lib::ClusterState("distributor:2 storage:3"),
- messageCount(3), numBuckets);
+ ASSERT_EQ(messageCount(3), _sender.commands.size());
+ ASSERT_NO_FATAL_FAILURE(completeBucketInfoGathering(lib::ClusterState("distributor:2 storage:3"),
+ messageCount(3), numBuckets));
_sender.clear();
- assertCorrectBuckets(numBuckets, "distributor:2 storage:3");
+ ASSERT_NO_FATAL_FAILURE(assertCorrectBuckets(numBuckets, "distributor:2 storage:3"));
}
-void
-BucketDBUpdaterTest::testDistributorChangeWithGrouping()
-{
+TEST_F(BucketDBUpdaterTest, testDistributorChangeWithGrouping) {
std::string distConfig(getDistConfig6Nodes2Groups());
setDistribution(distConfig);
int numBuckets = 100;
setSystemState(lib::ClusterState("distributor:6 storage:6"));
- CPPUNIT_ASSERT_EQUAL(messageCount(6), _sender.commands.size());
- completeBucketInfoGathering(lib::ClusterState("distributor:6 storage:6"),
- messageCount(6), numBuckets);
+ ASSERT_EQ(messageCount(6), _sender.commands.size());
+ ASSERT_NO_FATAL_FAILURE(completeBucketInfoGathering(lib::ClusterState("distributor:6 storage:6"),
+ messageCount(6), numBuckets));
_sender.clear();
// Distributor going down in other group, no change
setSystemState(lib::ClusterState("distributor:6 .5.s:d storage:6"));
- CPPUNIT_ASSERT_EQUAL(size_t(0), _sender.commands.size());
+ ASSERT_EQ(size_t(0), _sender.commands.size());
_sender.clear();
setSystemState(lib::ClusterState("distributor:6 storage:6"));
- CPPUNIT_ASSERT_EQUAL(size_t(0), _sender.commands.size());
- assertCorrectBuckets(numBuckets, "distributor:6 storage:6");
+ ASSERT_EQ(size_t(0), _sender.commands.size());
+ ASSERT_NO_FATAL_FAILURE(assertCorrectBuckets(numBuckets, "distributor:6 storage:6"));
_sender.clear();
// Unchanged grouping cause no change.
setDistribution(distConfig);
- CPPUNIT_ASSERT_EQUAL(size_t(0), _sender.commands.size());
+ ASSERT_EQ(size_t(0), _sender.commands.size());
// Changed grouping cause change
setDistribution(getDistConfig6Nodes4Groups());
- CPPUNIT_ASSERT_EQUAL(messageCount(6), _sender.commands.size());
+ ASSERT_EQ(messageCount(6), _sender.commands.size());
}
-void
-BucketDBUpdaterTest::testNormalUsageInitializing()
-{
+TEST_F(BucketDBUpdaterTest, testNormalUsageInitializing) {
setSystemState(lib::ClusterState("distributor:1 .0.s:i storage:1 .0.s:i"));
- CPPUNIT_ASSERT_EQUAL(_bucketSpaces.size(), _sender.commands.size());
+ ASSERT_EQ(_bucketSpaces.size(), _sender.commands.size());
// Not yet passing on system state.
- CPPUNIT_ASSERT_EQUAL(size_t(0), _senderDown.commands.size());
+ ASSERT_EQ(size_t(0), _senderDown.commands.size());
- completeBucketInfoGathering(lib::ClusterState("distributor:1 .0.s:i storage:1"),
- _bucketSpaces.size(), 10, 10);
+ ASSERT_NO_FATAL_FAILURE(completeBucketInfoGathering(lib::ClusterState("distributor:1 .0.s:i storage:1"),
+ _bucketSpaces.size(), 10, 10));
- assertCorrectBuckets(10, "distributor:1 storage:1");
+ ASSERT_NO_FATAL_FAILURE(assertCorrectBuckets(10, "distributor:1 storage:1"));
for (int i=10; i<20; i++) {
- verifyInvalid(document::BucketId(16, i), 0);
+ ASSERT_NO_FATAL_FAILURE(verifyInvalid(document::BucketId(16, i), 0));
}
// Pass on cluster state and recheck buckets now.
- CPPUNIT_ASSERT_EQUAL(size_t(1), _senderDown.commands.size());
+ ASSERT_EQ(size_t(1), _senderDown.commands.size());
_sender.clear();
_senderDown.clear();
@@ -811,24 +669,22 @@ BucketDBUpdaterTest::testNormalUsageInitializing()
setSystemState(lib::ClusterState("distributor:1 .0.s:i storage:1"));
// Send a new request bucket info up.
- CPPUNIT_ASSERT_EQUAL(_bucketSpaces.size(), _sender.commands.size());
+ ASSERT_EQ(_bucketSpaces.size(), _sender.commands.size());
- completeBucketInfoGathering(lib::ClusterState("distributor:1 .0.s:i storage:1"),
- _bucketSpaces.size(), 20);
+ ASSERT_NO_FATAL_FAILURE(completeBucketInfoGathering(lib::ClusterState("distributor:1 .0.s:i storage:1"),
+ _bucketSpaces.size(), 20));
// Pass on cluster state and recheck buckets now.
- CPPUNIT_ASSERT_EQUAL(size_t(1), _senderDown.commands.size());
+ ASSERT_EQ(size_t(1), _senderDown.commands.size());
- assertCorrectBuckets(20, "distributor:1 storage:1");
+ ASSERT_NO_FATAL_FAILURE(assertCorrectBuckets(20, "distributor:1 storage:1"));
}
-void
-BucketDBUpdaterTest::testFailedRequestBucketInfo()
-{
+TEST_F(BucketDBUpdaterTest, testFailedRequestBucketInfo) {
setSystemState(lib::ClusterState("distributor:1 .0.s:i storage:1"));
// 2 messages sent up: 1 to the nodes, and one reply to the setsystemstate.
- CPPUNIT_ASSERT_EQUAL(_bucketSpaces.size(), _sender.commands.size());
+ ASSERT_EQ(_bucketSpaces.size(), _sender.commands.size());
{
for (uint32_t i = 0; i < _bucketSpaces.size(); ++i) {
@@ -847,43 +703,38 @@ BucketDBUpdaterTest::testFailedRequestBucketInfo()
}
// Should be resent.
- CPPUNIT_ASSERT_EQUAL(getRequestBucketInfoStrings(messageCount(2)),
- _sender.getCommands());
+ ASSERT_EQ(getRequestBucketInfoStrings(messageCount(2)), _sender.getCommands());
- CPPUNIT_ASSERT_EQUAL(size_t(0), _senderDown.commands.size());
+ ASSERT_EQ(size_t(0), _senderDown.commands.size());
for (uint32_t i = 0; i < _bucketSpaces.size(); ++i) {
- fakeBucketReply(lib::ClusterState("distributor:1 .0.s:i storage:1"),
- *_sender.commands[_bucketSpaces.size() + i], 10);
+ ASSERT_NO_FATAL_FAILURE(fakeBucketReply(lib::ClusterState("distributor:1 .0.s:i storage:1"),
+ *_sender.commands[_bucketSpaces.size() + i], 10));
}
for (int i=0; i<10; i++) {
- CPPUNIT_ASSERT_EQUAL(
- std::string(""),
- verifyBucket(document::BucketId(16, i),
- lib::ClusterState("distributor:1 storage:1")));
+ EXPECT_EQ(std::string(""),
+ verifyBucket(document::BucketId(16, i),
+ lib::ClusterState("distributor:1 storage:1")));
}
// Set system state should now be passed on
- CPPUNIT_ASSERT_EQUAL(std::string("Set system state"),
- _senderDown.getCommands());
+ EXPECT_EQ(std::string("Set system state"), _senderDown.getCommands());
}
-void
-BucketDBUpdaterTest::testDownWhileInit()
-{
- setStorageNodes(3);
+TEST_F(BucketDBUpdaterTest, testDownWhileInit) {
+ ASSERT_NO_FATAL_FAILURE(setStorageNodes(3));
- fakeBucketReply(lib::ClusterState("distributor:1 storage:3"),
- *_sender.commands[0], 5);
+ ASSERT_NO_FATAL_FAILURE(fakeBucketReply(lib::ClusterState("distributor:1 storage:3"),
+ *_sender.commands[0], 5));
setSystemState(lib::ClusterState("distributor:1 storage:3 .1.s:d"));
- fakeBucketReply(lib::ClusterState("distributor:1 storage:3"),
- *_sender.commands[2], 5);
+ ASSERT_NO_FATAL_FAILURE(fakeBucketReply(lib::ClusterState("distributor:1 storage:3"),
+ *_sender.commands[2], 5));
- fakeBucketReply(lib::ClusterState("distributor:1 storage:3"),
- *_sender.commands[1], 5);
+ ASSERT_NO_FATAL_FAILURE(fakeBucketReply(lib::ClusterState("distributor:1 storage:3"),
+ *_sender.commands[1], 5));
}
bool
@@ -934,96 +785,83 @@ BucketDBUpdaterTest::expandNodeVec(const std::vector<uint16_t> &nodes)
return res;
}
-void
-BucketDBUpdaterTest::testNodeDown()
-{
- setStorageNodes(3);
+TEST_F(BucketDBUpdaterTest, testNodeDown) {
+ ASSERT_NO_FATAL_FAILURE(setStorageNodes(3));
enableDistributorClusterState("distributor:1 storage:3");
for (int i=1; i<100; i++) {
addIdealNodes(document::BucketId(16, i));
}
- CPPUNIT_ASSERT(bucketExistsThatHasNode(100, 1));
+ EXPECT_TRUE(bucketExistsThatHasNode(100, 1));
setSystemState(lib::ClusterState("distributor:1 storage:3 .1.s:d"));
- CPPUNIT_ASSERT(!bucketExistsThatHasNode(100, 1));
+ EXPECT_FALSE(bucketExistsThatHasNode(100, 1));
}
-void
-BucketDBUpdaterTest::testStorageNodeInMaintenanceClearsBucketsForNode()
-{
- setStorageNodes(3);
+TEST_F(BucketDBUpdaterTest, testStorageNodeInMaintenanceClearsBucketsForNode) {
+ ASSERT_NO_FATAL_FAILURE(setStorageNodes(3));
enableDistributorClusterState("distributor:1 storage:3");
for (int i=1; i<100; i++) {
addIdealNodes(document::BucketId(16, i));
}
- CPPUNIT_ASSERT(bucketExistsThatHasNode(100, 1));
+ EXPECT_TRUE(bucketExistsThatHasNode(100, 1));
setSystemState(lib::ClusterState("distributor:1 storage:3 .1.s:m"));
-
- CPPUNIT_ASSERT(!bucketExistsThatHasNode(100, 1));
+
+ EXPECT_FALSE(bucketExistsThatHasNode(100, 1));
}
-void
-BucketDBUpdaterTest::testNodeDownCopiesGetInSync()
-{
- setStorageNodes(3);
+TEST_F(BucketDBUpdaterTest, testNodeDownCopiesGetInSync) {
+ ASSERT_NO_FATAL_FAILURE(setStorageNodes(3));
- lib::ClusterState systemState("distributor:1 storage:3");
+ lib::ClusterState systemState("distributor:1 storage:3");
document::BucketId bid(16, 1);
addNodesToBucketDB(bid, "0=3,1=2,2=3");
setSystemState(lib::ClusterState("distributor:1 storage:3 .1.s:d"));
- CPPUNIT_ASSERT_EQUAL(
+ EXPECT_EQ(
std::string("BucketId(0x4000000000000001) : "
"node(idx=0,crc=0x3,docs=3/3,bytes=3/3,trusted=true,active=false,ready=false), "
"node(idx=2,crc=0x3,docs=3/3,bytes=3/3,trusted=true,active=false,ready=false)"),
dumpBucket(bid));
}
-void
-BucketDBUpdaterTest::testInitializingWhileRecheck()
-{
+TEST_F(BucketDBUpdaterTest, testInitializingWhileRecheck) {
lib::ClusterState systemState("distributor:1 storage:2 .0.s:i .0.i:0.1");
setSystemState(systemState);
- CPPUNIT_ASSERT_EQUAL(messageCount(2), _sender.commands.size());
- CPPUNIT_ASSERT_EQUAL(size_t(0), _senderDown.commands.size());
+ ASSERT_EQ(messageCount(2), _sender.commands.size());
+ ASSERT_EQ(size_t(0), _senderDown.commands.size());
getBucketDBUpdater().recheckBucketInfo(1, makeDocumentBucket(document::BucketId(16, 3)));
for (uint32_t i = 0; i < messageCount(2); ++i) {
- fakeBucketReply(systemState, *_sender.commands[i], 100);
+ ASSERT_NO_FATAL_FAILURE(fakeBucketReply(systemState, *_sender.commands[i], 100));
}
// Now we can pass on system state.
- CPPUNIT_ASSERT_EQUAL(size_t(1), _senderDown.commands.size());
-
- CPPUNIT_ASSERT_EQUAL(MessageType::SETSYSTEMSTATE,
- _senderDown.commands[0]->getType());
+ ASSERT_EQ(size_t(1), _senderDown.commands.size());
+ EXPECT_EQ(MessageType::SETSYSTEMSTATE, _senderDown.commands[0]->getType());
}
-void
-BucketDBUpdaterTest::testBitChange()
-{
-
+TEST_F(BucketDBUpdaterTest, testBitChange) {
std::vector<document::BucketId> bucketlist;
{
setSystemState(lib::ClusterState("bits:14 storage:1 distributor:2"));
- CPPUNIT_ASSERT_EQUAL(_bucketSpaces.size(), _sender.commands.size());
+ ASSERT_EQ(_bucketSpaces.size(), _sender.commands.size());
for (uint32_t bsi = 0; bsi < _bucketSpaces.size(); ++bsi) {
- CPPUNIT_ASSERT(_sender.commands[bsi]->getType() == MessageType::REQUESTBUCKETINFO);
+ ASSERT_EQ(_sender.commands[bsi]->getType(), MessageType::REQUESTBUCKETINFO);
const auto &req = dynamic_cast<const RequestBucketInfoCommand &>(*_sender.commands[bsi]);
- RequestBucketInfoReply* sreply = new RequestBucketInfoReply(req);
+ auto sreply = std::make_shared<RequestBucketInfoReply>(req);
sreply->setAddress(storageAddress(0));
api::RequestBucketInfoReply::EntryVector &vec = sreply->getBucketInfo();
if (req.getBucketSpace() == FixedBucketSpaces::default_space()) {
@@ -1046,29 +884,27 @@ BucketDBUpdaterTest::testBitChange()
}
}
- getBucketDBUpdater().onRequestBucketInfoReply(std::shared_ptr<RequestBucketInfoReply>(sreply));
+ getBucketDBUpdater().onRequestBucketInfoReply(sreply);
}
}
- CPPUNIT_ASSERT_EQUAL(
- std::string("BucketId(0x4000000000000001) : "
- "node(idx=0,crc=0xa,docs=1/1,bytes=1/1,trusted=true,active=false,ready=false)"),
- dumpBucket(bucketlist[0]));
- CPPUNIT_ASSERT_EQUAL(
- std::string("BucketId(0x4000000000000002) : "
- "node(idx=0,crc=0xa,docs=1/1,bytes=1/1,trusted=true,active=false,ready=false)"),
- dumpBucket(bucketlist[1]));
+ EXPECT_EQ(std::string("BucketId(0x4000000000000001) : "
+ "node(idx=0,crc=0xa,docs=1/1,bytes=1/1,trusted=true,active=false,ready=false)"),
+ dumpBucket(bucketlist[0]));
+ EXPECT_EQ(std::string("BucketId(0x4000000000000002) : "
+ "node(idx=0,crc=0xa,docs=1/1,bytes=1/1,trusted=true,active=false,ready=false)"),
+ dumpBucket(bucketlist[1]));
{
_sender.clear();
setSystemState(lib::ClusterState("bits:16 storage:1 distributor:2"));
- CPPUNIT_ASSERT_EQUAL(_bucketSpaces.size(), _sender.commands.size());
+ ASSERT_EQ(_bucketSpaces.size(), _sender.commands.size());
for (uint32_t bsi = 0; bsi < _bucketSpaces.size(); ++bsi) {
- CPPUNIT_ASSERT(_sender.commands[bsi]->getType() == MessageType::REQUESTBUCKETINFO);
+ ASSERT_EQ(_sender.commands[bsi]->getType(), MessageType::REQUESTBUCKETINFO);
const auto &req = dynamic_cast<const RequestBucketInfoCommand &>(*_sender.commands[bsi]);
- RequestBucketInfoReply* sreply = new RequestBucketInfoReply(req);
+ auto sreply = std::make_shared<RequestBucketInfoReply>(req);
sreply->setAddress(storageAddress(0));
sreply->setResult(api::ReturnCode::OK);
if (req.getBucketSpace() == FixedBucketSpaces::default_space()) {
@@ -1085,27 +921,22 @@ BucketDBUpdaterTest::testBitChange()
api::BucketInfo(10,1,1)));
}
- getBucketDBUpdater().onRequestBucketInfoReply(
- std::shared_ptr<RequestBucketInfoReply>(sreply));
+ getBucketDBUpdater().onRequestBucketInfoReply(sreply);
}
}
- CPPUNIT_ASSERT_EQUAL(
- std::string("BucketId(0x4000000000000000) : "
- "node(idx=0,crc=0xa,docs=1/1,bytes=1/1,trusted=true,active=false,ready=false)"),
- dumpBucket(document::BucketId(16, 0)));
- CPPUNIT_ASSERT_EQUAL(
- std::string("BucketId(0x4000000000000001) : "
- "node(idx=0,crc=0xa,docs=1/1,bytes=1/1,trusted=true,active=false,ready=false)"),
- dumpBucket(document::BucketId(16, 1)));
- CPPUNIT_ASSERT_EQUAL(
- std::string("BucketId(0x4000000000000002) : "
- "node(idx=0,crc=0xa,docs=1/1,bytes=1/1,trusted=true,active=false,ready=false)"),
- dumpBucket(document::BucketId(16, 2)));
- CPPUNIT_ASSERT_EQUAL(
- std::string("BucketId(0x4000000000000004) : "
- "node(idx=0,crc=0xa,docs=1/1,bytes=1/1,trusted=true,active=false,ready=false)"),
- dumpBucket(document::BucketId(16, 4)));
+ EXPECT_EQ(std::string("BucketId(0x4000000000000000) : "
+ "node(idx=0,crc=0xa,docs=1/1,bytes=1/1,trusted=true,active=false,ready=false)"),
+ dumpBucket(document::BucketId(16, 0)));
+ EXPECT_EQ(std::string("BucketId(0x4000000000000001) : "
+ "node(idx=0,crc=0xa,docs=1/1,bytes=1/1,trusted=true,active=false,ready=false)"),
+ dumpBucket(document::BucketId(16, 1)));
+ EXPECT_EQ(std::string("BucketId(0x4000000000000002) : "
+ "node(idx=0,crc=0xa,docs=1/1,bytes=1/1,trusted=true,active=false,ready=false)"),
+ dumpBucket(document::BucketId(16, 2)));
+ EXPECT_EQ(std::string("BucketId(0x4000000000000004) : "
+ "node(idx=0,crc=0xa,docs=1/1,bytes=1/1,trusted=true,active=false,ready=false)"),
+ dumpBucket(document::BucketId(16, 4)));
{
_sender.clear();
@@ -1118,29 +949,23 @@ BucketDBUpdaterTest::testBitChange()
}
};
-void
-BucketDBUpdaterTest::testRecheckNodeWithFailure()
-{
- initializeNodesAndBuckets(3, 5);
+TEST_F(BucketDBUpdaterTest, testRecheckNodeWithFailure) {
+ ASSERT_NO_FATAL_FAILURE(initializeNodesAndBuckets(3, 5));
_sender.clear();
getBucketDBUpdater().recheckBucketInfo(1, makeDocumentBucket(document::BucketId(16, 3)));
- CPPUNIT_ASSERT_EQUAL(size_t(1), _sender.commands.size());
-
+ ASSERT_EQ(size_t(1), _sender.commands.size());
uint16_t index = 0;
{
- api::RequestBucketInfoCommand& rbi(
- dynamic_cast<RequestBucketInfoCommand&>(*_sender.commands[0]));
- CPPUNIT_ASSERT_EQUAL(size_t(1), rbi.getBuckets().size());
- CPPUNIT_ASSERT_EQUAL(document::BucketId(16, 3), rbi.getBuckets()[0]);
- auto reply(std::make_shared<api::RequestBucketInfoReply>(rbi));
-
+ auto& rbi = dynamic_cast<RequestBucketInfoCommand&>(*_sender.commands[0]);
+ ASSERT_EQ(size_t(1), rbi.getBuckets().size());
+ EXPECT_EQ(document::BucketId(16, 3), rbi.getBuckets()[0]);
+ auto reply = std::make_shared<api::RequestBucketInfoReply>(rbi);
const api::StorageMessageAddress *address = _sender.commands[0]->getAddress();
index = address->getIndex();
-
reply->setResult(api::ReturnCode::NOT_CONNECTED);
getBucketDBUpdater().onRequestBucketInfoReply(reply);
// Trigger that delayed message is sent
@@ -1148,43 +973,39 @@ BucketDBUpdaterTest::testRecheckNodeWithFailure()
getBucketDBUpdater().resendDelayedMessages();
}
- CPPUNIT_ASSERT_EQUAL(size_t(2), _sender.commands.size());
+ ASSERT_EQ(size_t(2), _sender.commands.size());
setSystemState(
lib::ClusterState(vespalib::make_string("distributor:1 storage:3 .%d.s:d", index)));
// Recheck bucket.
{
- api::RequestBucketInfoCommand& rbi(dynamic_cast<RequestBucketInfoCommand&>
- (*_sender.commands[1]));
- CPPUNIT_ASSERT_EQUAL(size_t(1), rbi.getBuckets().size());
- CPPUNIT_ASSERT_EQUAL(document::BucketId(16, 3), rbi.getBuckets()[0]);
- auto reply(std::make_shared<api::RequestBucketInfoReply>(rbi));
+ auto& rbi = dynamic_cast<RequestBucketInfoCommand&>(*_sender.commands[1]);
+ ASSERT_EQ(size_t(1), rbi.getBuckets().size());
+ EXPECT_EQ(document::BucketId(16, 3), rbi.getBuckets()[0]);
+ auto reply = std::make_shared<api::RequestBucketInfoReply>(rbi);
reply->setResult(api::ReturnCode::NOT_CONNECTED);
getBucketDBUpdater().onRequestBucketInfoReply(reply);
}
// Should not retry since node is down.
- CPPUNIT_ASSERT_EQUAL(size_t(2), _sender.commands.size());
+ EXPECT_EQ(size_t(2), _sender.commands.size());
}
-void
-BucketDBUpdaterTest::testRecheckNode()
-{
- initializeNodesAndBuckets(3, 5);
+TEST_F(BucketDBUpdaterTest, testRecheckNode) {
+ ASSERT_NO_FATAL_FAILURE(initializeNodesAndBuckets(3, 5));
_sender.clear();
getBucketDBUpdater().recheckBucketInfo(1, makeDocumentBucket(document::BucketId(16, 3)));
- CPPUNIT_ASSERT_EQUAL(size_t(1), _sender.commands.size());
+ ASSERT_EQ(size_t(1), _sender.commands.size());
- api::RequestBucketInfoCommand& rbi(
- dynamic_cast<RequestBucketInfoCommand&>(*_sender.commands[0]));
- CPPUNIT_ASSERT_EQUAL(size_t(1), rbi.getBuckets().size());
- CPPUNIT_ASSERT_EQUAL(document::BucketId(16, 3), rbi.getBuckets()[0]);
+ auto& rbi = dynamic_cast<RequestBucketInfoCommand&>(*_sender.commands[0]);
+ ASSERT_EQ(size_t(1), rbi.getBuckets().size());
+ EXPECT_EQ(document::BucketId(16, 3), rbi.getBuckets()[0]);
- auto reply(std::make_shared<api::RequestBucketInfoReply>(rbi));
+ auto reply = std::make_shared<api::RequestBucketInfoReply>(rbi);
reply->getBucketInfo().push_back(
api::RequestBucketInfoReply::Entry(document::BucketId(16, 3),
api::BucketInfo(20, 10, 12, 50, 60, true, true)));
@@ -1192,29 +1013,24 @@ BucketDBUpdaterTest::testRecheckNode()
lib::ClusterState state("distributor:1 storage:3");
for (uint32_t i = 0; i < 3; i++) {
- CPPUNIT_ASSERT_EQUAL(
- getIdealStr(document::BucketId(16, i), state),
- getNodes(document::BucketId(16, i)));
+ EXPECT_EQ(getIdealStr(document::BucketId(16, i), state),
+ getNodes(document::BucketId(16, i)));
}
for (uint32_t i = 4; i < 5; i++) {
- CPPUNIT_ASSERT_EQUAL(
- getIdealStr(document::BucketId(16, i), state),
- getNodes(document::BucketId(16, i)));
+ EXPECT_EQ(getIdealStr(document::BucketId(16, i), state),
+ getNodes(document::BucketId(16, i)));
}
BucketDatabase::Entry entry = getBucketDatabase().get(document::BucketId(16, 3));
- CPPUNIT_ASSERT(entry.valid());
+ ASSERT_TRUE(entry.valid());
const BucketCopy* copy = entry->getNode(1);
- CPPUNIT_ASSERT(copy != 0);
- CPPUNIT_ASSERT_EQUAL(api::BucketInfo(20,10,12, 50, 60, true, true),
- copy->getBucketInfo());
+ ASSERT_TRUE(copy != nullptr);
+ EXPECT_EQ(api::BucketInfo(20,10,12, 50, 60, true, true), copy->getBucketInfo());
}
-void
-BucketDBUpdaterTest::testNotifyBucketChange()
-{
+TEST_F(BucketDBUpdaterTest, testNotifyBucketChange) {
enableDistributorClusterState("distributor:1 storage:1");
addNodesToBucketDB(document::BucketId(16, 1), "0=1234");
@@ -1237,54 +1053,47 @@ BucketDBUpdaterTest::testNotifyBucketChange()
}
// Must receive reply
- CPPUNIT_ASSERT_EQUAL(size_t(2), _sender.replies.size());
+ ASSERT_EQ(size_t(2), _sender.replies.size());
for (int i = 0; i < 2; ++i) {
- CPPUNIT_ASSERT_EQUAL(MessageType::NOTIFYBUCKETCHANGE_REPLY,
- _sender.replies[i]->getType());
+ ASSERT_EQ(MessageType::NOTIFYBUCKETCHANGE_REPLY,
+ _sender.replies[i]->getType());
}
// No database update until request bucket info replies have been received.
- CPPUNIT_ASSERT_EQUAL(std::string("BucketId(0x4000000000000001) : "
- "node(idx=0,crc=0x4d2,docs=1234/1234,bytes=1234/1234,"
- "trusted=false,active=false,ready=false)"),
- dumpBucket(document::BucketId(16, 1)));
- CPPUNIT_ASSERT_EQUAL(std::string("NONEXISTING"),
- dumpBucket(document::BucketId(16, 2)));
+ EXPECT_EQ(std::string("BucketId(0x4000000000000001) : "
+ "node(idx=0,crc=0x4d2,docs=1234/1234,bytes=1234/1234,"
+ "trusted=false,active=false,ready=false)"),
+ dumpBucket(document::BucketId(16, 1)));
+ EXPECT_EQ(std::string("NONEXISTING"), dumpBucket(document::BucketId(16, 2)));
- CPPUNIT_ASSERT_EQUAL(size_t(2), _sender.commands.size());
+ ASSERT_EQ(size_t(2), _sender.commands.size());
std::vector<api::BucketInfo> infos;
infos.push_back(api::BucketInfo(4567, 200, 2000, 400, 4000, true, true));
infos.push_back(api::BucketInfo(8999, 300, 3000, 500, 5000, false, false));
for (int i = 0; i < 2; ++i) {
- api::RequestBucketInfoCommand& rbi(
- dynamic_cast<RequestBucketInfoCommand&>(*_sender.commands[i]));
- CPPUNIT_ASSERT_EQUAL(size_t(1), rbi.getBuckets().size());
- CPPUNIT_ASSERT_EQUAL(document::BucketId(16, i + 1), rbi.getBuckets()[0]);
+ auto& rbi = dynamic_cast<RequestBucketInfoCommand&>(*_sender.commands[i]);
+ ASSERT_EQ(size_t(1), rbi.getBuckets().size());
+ EXPECT_EQ(document::BucketId(16, i + 1), rbi.getBuckets()[0]);
- auto reply(std::make_shared<api::RequestBucketInfoReply>(rbi));
+ auto reply = std::make_shared<api::RequestBucketInfoReply>(rbi);
reply->getBucketInfo().push_back(
api::RequestBucketInfoReply::Entry(document::BucketId(16, i + 1),
infos[i]));
getBucketDBUpdater().onRequestBucketInfoReply(reply);
}
- CPPUNIT_ASSERT_EQUAL(
- std::string("BucketId(0x4000000000000001) : "
- "node(idx=0,crc=0x11d7,docs=200/400,bytes=2000/4000,trusted=true,active=true,ready=true)"),
- dumpBucket(document::BucketId(16, 1)));
- CPPUNIT_ASSERT_EQUAL(
- std::string("BucketId(0x4000000000000002) : "
- "node(idx=0,crc=0x2327,docs=300/500,bytes=3000/5000,trusted=true,active=false,ready=false)"),
- dumpBucket(document::BucketId(16, 2)));
-
+ EXPECT_EQ(std::string("BucketId(0x4000000000000001) : "
+ "node(idx=0,crc=0x11d7,docs=200/400,bytes=2000/4000,trusted=true,active=true,ready=true)"),
+ dumpBucket(document::BucketId(16, 1)));
+ EXPECT_EQ(std::string("BucketId(0x4000000000000002) : "
+ "node(idx=0,crc=0x2327,docs=300/500,bytes=3000/5000,trusted=true,active=false,ready=false)"),
+ dumpBucket(document::BucketId(16, 2)));
}
-void
-BucketDBUpdaterTest::testNotifyBucketChangeFromNodeDown()
-{
+TEST_F(BucketDBUpdaterTest, testNotifyBucketChangeFromNodeDown) {
enableDistributorClusterState("distributor:1 storage:2");
addNodesToBucketDB(document::BucketId(16, 1), "1=1234");
@@ -1302,25 +1111,22 @@ BucketDBUpdaterTest::testNotifyBucketChangeFromNodeDown()
// (sendRequestBucketInfo drops message if node is down).
enableDistributorClusterState("distributor:1 storage:2 .0.s:d");
- CPPUNIT_ASSERT_EQUAL(
- std::string("BucketId(0x4000000000000001) : "
- "node(idx=1,crc=0x4d2,docs=1234/1234,bytes=1234/1234,trusted=false,active=false,ready=false)"),
- dumpBucket(document::BucketId(16, 1)));
+ ASSERT_EQ(std::string("BucketId(0x4000000000000001) : "
+ "node(idx=1,crc=0x4d2,docs=1234/1234,bytes=1234/1234,trusted=false,active=false,ready=false)"),
+ dumpBucket(document::BucketId(16, 1)));
- CPPUNIT_ASSERT_EQUAL(size_t(1), _sender.replies.size());
- CPPUNIT_ASSERT_EQUAL(MessageType::NOTIFYBUCKETCHANGE_REPLY,
- _sender.replies[0]->getType());
+ ASSERT_EQ(size_t(1), _sender.replies.size());
+ ASSERT_EQ(MessageType::NOTIFYBUCKETCHANGE_REPLY, _sender.replies[0]->getType());
// Currently, this pending operation will be auto-flushed when the cluster state
// changes so the behavior is still correct. Keep this test around to prevent
// regressions here.
- CPPUNIT_ASSERT_EQUAL(size_t(1), _sender.commands.size());
- api::RequestBucketInfoCommand& rbi(
- dynamic_cast<RequestBucketInfoCommand&>(*_sender.commands[0]));
- CPPUNIT_ASSERT_EQUAL(size_t(1), rbi.getBuckets().size());
- CPPUNIT_ASSERT_EQUAL(document::BucketId(16, 1), rbi.getBuckets()[0]);
+ ASSERT_EQ(size_t(1), _sender.commands.size());
+ auto& rbi = dynamic_cast<RequestBucketInfoCommand&>(*_sender.commands[0]);
+ ASSERT_EQ(size_t(1), rbi.getBuckets().size());
+ EXPECT_EQ(document::BucketId(16, 1), rbi.getBuckets()[0]);
- auto reply(std::make_shared<api::RequestBucketInfoReply>(rbi));
+ auto reply = std::make_shared<api::RequestBucketInfoReply>(rbi);
reply->getBucketInfo().push_back(
api::RequestBucketInfoReply::Entry(
document::BucketId(16, 1),
@@ -1328,10 +1134,9 @@ BucketDBUpdaterTest::testNotifyBucketChangeFromNodeDown()
getBucketDBUpdater().onRequestBucketInfoReply(reply);
// No change
- CPPUNIT_ASSERT_EQUAL(
- std::string("BucketId(0x4000000000000001) : "
- "node(idx=1,crc=0x4d2,docs=1234/1234,bytes=1234/1234,trusted=false,active=false,ready=false)"),
- dumpBucket(document::BucketId(16, 1)));
+ EXPECT_EQ(std::string("BucketId(0x4000000000000001) : "
+ "node(idx=1,crc=0x4d2,docs=1234/1234,bytes=1234/1234,trusted=false,active=false,ready=false)"),
+ dumpBucket(document::BucketId(16, 1)));
}
/**
@@ -1342,11 +1147,9 @@ BucketDBUpdaterTest::testNotifyBucketChangeFromNodeDown()
* distributor in the pending state but not by the current state would be
* discarded when attempted inserted into the bucket database.
*/
-void
-BucketDBUpdaterTest::testNotifyChangeWithPendingStateQueuesBucketInfoRequests()
-{
+TEST_F(BucketDBUpdaterTest, testNotifyChangeWithPendingStateQueuesBucketInfoRequests) {
setSystemState(lib::ClusterState("distributor:1 storage:1"));
- CPPUNIT_ASSERT_EQUAL(_bucketSpaces.size(), _sender.commands.size());
+ ASSERT_EQ(_bucketSpaces.size(), _sender.commands.size());
{
api::BucketInfo info(8999, 300, 3000, 500, 5000, false, false);
@@ -1356,18 +1159,17 @@ BucketDBUpdaterTest::testNotifyChangeWithPendingStateQueuesBucketInfoRequests()
getBucketDBUpdater().onNotifyBucketChange(cmd);
}
- CPPUNIT_ASSERT_EQUAL(_bucketSpaces.size(), _sender.commands.size());
+ ASSERT_EQ(_bucketSpaces.size(), _sender.commands.size());
- completeBucketInfoGathering(lib::ClusterState("distributor:1 storage:1"),
- _bucketSpaces.size(), 10);
+ ASSERT_NO_FATAL_FAILURE(completeBucketInfoGathering(lib::ClusterState("distributor:1 storage:1"),
+ _bucketSpaces.size(), 10));
- CPPUNIT_ASSERT_EQUAL(_bucketSpaces.size() + 1, _sender.commands.size());
+ ASSERT_EQ(_bucketSpaces.size() + 1, _sender.commands.size());
{
- api::RequestBucketInfoCommand& rbi(
- dynamic_cast<RequestBucketInfoCommand&>(*_sender.commands[_bucketSpaces.size()]));
- CPPUNIT_ASSERT_EQUAL(size_t(1), rbi.getBuckets().size());
- CPPUNIT_ASSERT_EQUAL(document::BucketId(16, 1), rbi.getBuckets()[0]);
+ auto& rbi = dynamic_cast<RequestBucketInfoCommand&>(*_sender.commands[_bucketSpaces.size()]);
+ ASSERT_EQ(size_t(1), rbi.getBuckets().size());
+ EXPECT_EQ(document::BucketId(16, 1), rbi.getBuckets()[0]);
}
_sender.clear();
@@ -1375,19 +1177,16 @@ BucketDBUpdaterTest::testNotifyChangeWithPendingStateQueuesBucketInfoRequests()
{
lib::ClusterState state("distributor:1 storage:2");
uint32_t expectedMsgs = _bucketSpaces.size(), dummyBucketsToReturn = 1;
- setAndEnableClusterState(state, expectedMsgs, dummyBucketsToReturn);
+ ASSERT_NO_FATAL_FAILURE(setAndEnableClusterState(state, expectedMsgs, dummyBucketsToReturn));
}
- CPPUNIT_ASSERT_EQUAL(_bucketSpaces.size(), _sender.commands.size());
+ ASSERT_EQ(_bucketSpaces.size(), _sender.commands.size());
{
- api::RequestBucketInfoCommand& rbi(
- dynamic_cast<RequestBucketInfoCommand&>(*_sender.commands[0]));
- CPPUNIT_ASSERT_EQUAL(size_t(0), rbi.getBuckets().size());
+ auto& rbi = dynamic_cast<RequestBucketInfoCommand&>(*_sender.commands[0]);
+ EXPECT_EQ(size_t(0), rbi.getBuckets().size());
}
}
-void
-BucketDBUpdaterTest::testMergeReply()
-{
+TEST_F(BucketDBUpdaterTest, testMergeReply) {
enableDistributorClusterState("distributor:1 storage:3");
addNodesToBucketDB(document::BucketId(16, 1234),
@@ -1400,23 +1199,21 @@ BucketDBUpdaterTest::testMergeReply()
api::MergeBucketCommand cmd(makeDocumentBucket(document::BucketId(16, 1234)), nodes, 0);
- auto reply(std::make_shared<api::MergeBucketReply>(cmd));
+ auto reply = std::make_shared<api::MergeBucketReply>(cmd);
_sender.clear();
getBucketDBUpdater().onMergeBucketReply(reply);
- CPPUNIT_ASSERT_EQUAL(size_t(3), _sender.commands.size());
+ ASSERT_EQ(size_t(3), _sender.commands.size());
for (uint32_t i = 0; i < 3; i++) {
- std::shared_ptr<api::RequestBucketInfoCommand>
- req(std::dynamic_pointer_cast<api::RequestBucketInfoCommand>(
- _sender.commands[i]));
+ auto req = std::dynamic_pointer_cast<api::RequestBucketInfoCommand>(_sender.commands[i]);
- CPPUNIT_ASSERT(req.get());
- CPPUNIT_ASSERT_EQUAL(size_t(1), req->getBuckets().size());
- CPPUNIT_ASSERT_EQUAL(document::BucketId(16, 1234), req->getBuckets()[0]);
+ ASSERT_TRUE(req.get() != nullptr);
+ ASSERT_EQ(size_t(1), req->getBuckets().size());
+ EXPECT_EQ(document::BucketId(16, 1234), req->getBuckets()[0]);
- auto reqreply(std::make_shared<api::RequestBucketInfoReply>(*req));
+ auto reqreply = std::make_shared<api::RequestBucketInfoReply>(*req);
reqreply->getBucketInfo().push_back(
api::RequestBucketInfoReply::Entry(document::BucketId(16, 1234),
api::BucketInfo(10 * (i + 1), 100 * (i +1), 1000 * (i+1))));
@@ -1424,17 +1221,14 @@ BucketDBUpdaterTest::testMergeReply()
getBucketDBUpdater().onRequestBucketInfoReply(reqreply);
}
- CPPUNIT_ASSERT_EQUAL(
- std::string("BucketId(0x40000000000004d2) : "
- "node(idx=0,crc=0xa,docs=100/100,bytes=1000/1000,trusted=false,active=false,ready=false), "
- "node(idx=1,crc=0x14,docs=200/200,bytes=2000/2000,trusted=false,active=false,ready=false), "
- "node(idx=2,crc=0x1e,docs=300/300,bytes=3000/3000,trusted=false,active=false,ready=false)"),
- dumpBucket(document::BucketId(16, 1234)));
+ EXPECT_EQ(std::string("BucketId(0x40000000000004d2) : "
+ "node(idx=0,crc=0xa,docs=100/100,bytes=1000/1000,trusted=false,active=false,ready=false), "
+ "node(idx=1,crc=0x14,docs=200/200,bytes=2000/2000,trusted=false,active=false,ready=false), "
+ "node(idx=2,crc=0x1e,docs=300/300,bytes=3000/3000,trusted=false,active=false,ready=false)"),
+ dumpBucket(document::BucketId(16, 1234)));
};
-void
-BucketDBUpdaterTest::testMergeReplyNodeDown()
-{
+TEST_F(BucketDBUpdaterTest, testMergeReplyNodeDown) {
enableDistributorClusterState("distributor:1 storage:3");
std::vector<api::MergeBucketCommand::Node> nodes;
@@ -1446,25 +1240,23 @@ BucketDBUpdaterTest::testMergeReplyNodeDown()
api::MergeBucketCommand cmd(makeDocumentBucket(document::BucketId(16, 1234)), nodes, 0);
- auto reply(std::make_shared<api::MergeBucketReply>(cmd));
+ auto reply = std::make_shared<api::MergeBucketReply>(cmd);
setSystemState(lib::ClusterState("distributor:1 storage:2"));
_sender.clear();
getBucketDBUpdater().onMergeBucketReply(reply);
- CPPUNIT_ASSERT_EQUAL(size_t(2), _sender.commands.size());
+ ASSERT_EQ(size_t(2), _sender.commands.size());
for (uint32_t i = 0; i < 2; i++) {
- std::shared_ptr<api::RequestBucketInfoCommand> req(
- std::dynamic_pointer_cast<api::RequestBucketInfoCommand>(
- _sender.commands[i]));
+ auto req = std::dynamic_pointer_cast<api::RequestBucketInfoCommand>(_sender.commands[i]);
- CPPUNIT_ASSERT(req.get());
- CPPUNIT_ASSERT_EQUAL(size_t(1), req->getBuckets().size());
- CPPUNIT_ASSERT_EQUAL(document::BucketId(16, 1234), req->getBuckets()[0]);
+ ASSERT_TRUE(req.get() != nullptr);
+ ASSERT_EQ(size_t(1), req->getBuckets().size());
+ EXPECT_EQ(document::BucketId(16, 1234), req->getBuckets()[0]);
- auto reqreply(std::make_shared<api::RequestBucketInfoReply>(*req));
+ auto reqreply = std::make_shared<api::RequestBucketInfoReply>(*req);
reqreply->getBucketInfo().push_back(
api::RequestBucketInfoReply::Entry(
document::BucketId(16, 1234),
@@ -1472,16 +1264,13 @@ BucketDBUpdaterTest::testMergeReplyNodeDown()
getBucketDBUpdater().onRequestBucketInfoReply(reqreply);
}
- CPPUNIT_ASSERT_EQUAL(
- std::string("BucketId(0x40000000000004d2) : "
- "node(idx=0,crc=0xa,docs=100/100,bytes=1000/1000,trusted=false,active=false,ready=false), "
- "node(idx=1,crc=0x14,docs=200/200,bytes=2000/2000,trusted=false,active=false,ready=false)"),
- dumpBucket(document::BucketId(16, 1234)));
+ EXPECT_EQ(std::string("BucketId(0x40000000000004d2) : "
+ "node(idx=0,crc=0xa,docs=100/100,bytes=1000/1000,trusted=false,active=false,ready=false), "
+ "node(idx=1,crc=0x14,docs=200/200,bytes=2000/2000,trusted=false,active=false,ready=false)"),
+ dumpBucket(document::BucketId(16, 1234)));
};
-void
-BucketDBUpdaterTest::testMergeReplyNodeDownAfterRequestSent()
-{
+TEST_F(BucketDBUpdaterTest, testMergeReplyNodeDownAfterRequestSent) {
enableDistributorClusterState("distributor:1 storage:3");
std::vector<api::MergeBucketCommand::Node> nodes;
@@ -1498,20 +1287,18 @@ BucketDBUpdaterTest::testMergeReplyNodeDownAfterRequestSent()
_sender.clear();
getBucketDBUpdater().onMergeBucketReply(reply);
- CPPUNIT_ASSERT_EQUAL(size_t(3), _sender.commands.size());
+ ASSERT_EQ(size_t(3), _sender.commands.size());
setSystemState(lib::ClusterState("distributor:1 storage:2"));
for (uint32_t i = 0; i < 3; i++) {
- std::shared_ptr<api::RequestBucketInfoCommand> req(
- std::dynamic_pointer_cast<api::RequestBucketInfoCommand>(
- _sender.commands[i]));
+ auto req = std::dynamic_pointer_cast<api::RequestBucketInfoCommand>(_sender.commands[i]);
- CPPUNIT_ASSERT(req.get());
- CPPUNIT_ASSERT_EQUAL(size_t(1), req->getBuckets().size());
- CPPUNIT_ASSERT_EQUAL(document::BucketId(16, 1234), req->getBuckets()[0]);
+ ASSERT_TRUE(req.get() != nullptr);
+ ASSERT_EQ(size_t(1), req->getBuckets().size());
+ EXPECT_EQ(document::BucketId(16, 1234), req->getBuckets()[0]);
- auto reqreply(std::make_shared<api::RequestBucketInfoReply>(*req));
+ auto reqreply = std::make_shared<api::RequestBucketInfoReply>(*req);
reqreply->getBucketInfo().push_back(
api::RequestBucketInfoReply::Entry(
document::BucketId(16, 1234),
@@ -1519,17 +1306,14 @@ BucketDBUpdaterTest::testMergeReplyNodeDownAfterRequestSent()
getBucketDBUpdater().onRequestBucketInfoReply(reqreply);
}
- CPPUNIT_ASSERT_EQUAL(
- std::string("BucketId(0x40000000000004d2) : "
- "node(idx=0,crc=0xa,docs=100/100,bytes=1000/1000,trusted=false,active=false,ready=false), "
- "node(idx=1,crc=0x14,docs=200/200,bytes=2000/2000,trusted=false,active=false,ready=false)"),
- dumpBucket(document::BucketId(16, 1234)));
+ EXPECT_EQ(std::string("BucketId(0x40000000000004d2) : "
+ "node(idx=0,crc=0xa,docs=100/100,bytes=1000/1000,trusted=false,active=false,ready=false), "
+ "node(idx=1,crc=0x14,docs=200/200,bytes=2000/2000,trusted=false,active=false,ready=false)"),
+ dumpBucket(document::BucketId(16, 1234)));
};
-void
-BucketDBUpdaterTest::testFlush()
-{
+TEST_F(BucketDBUpdaterTest, testFlush) {
enableDistributorClusterState("distributor:1 storage:3");
_sender.clear();
@@ -1540,21 +1324,19 @@ BucketDBUpdaterTest::testFlush()
nodes.push_back(api::MergeBucketCommand::Node(i));
}
- api::MergeBucketCommand cmd(makeDocumentBucket(document::BucketId(16, 1234)),
- nodes,
- 0);
+ api::MergeBucketCommand cmd(makeDocumentBucket(document::BucketId(16, 1234)), nodes, 0);
auto reply(std::make_shared<api::MergeBucketReply>(cmd));
_sender.clear();
getBucketDBUpdater().onMergeBucketReply(reply);
- CPPUNIT_ASSERT_EQUAL(size_t(3), _sender.commands.size());
- CPPUNIT_ASSERT_EQUAL(size_t(0), _senderDown.replies.size());
+ ASSERT_EQ(size_t(3), _sender.commands.size());
+ ASSERT_EQ(size_t(0), _senderDown.replies.size());
getBucketDBUpdater().flush();
// Flushing should drop all merge bucket replies
- CPPUNIT_ASSERT_EQUAL(size_t(0), _senderDown.commands.size());
+ EXPECT_EQ(size_t(0), _senderDown.commands.size());
}
std::string
@@ -1569,8 +1351,7 @@ BucketDBUpdaterTest::getSentNodes(
std::ostringstream ost;
for (uint32_t i = 0; i < fixture->sender.commands.size(); i++) {
- RequestBucketInfoCommand& req(dynamic_cast<RequestBucketInfoCommand&>(
- *fixture->sender.commands[i]));
+ auto& req = dynamic_cast<RequestBucketInfoCommand&>(*fixture->sender.commands[i]);
if (i > 0) {
ost << ",";
@@ -1599,155 +1380,124 @@ BucketDBUpdaterTest::getSentNodesDistributionChanged(
std::ostringstream ost;
for (uint32_t i = 0; i < sender.commands.size(); i++) {
- RequestBucketInfoCommand* req =
- dynamic_cast<RequestBucketInfoCommand*>(sender.commands[i].get());
+ auto& req = dynamic_cast<RequestBucketInfoCommand&>(*sender.commands[i]);
if (i > 0) {
ost << ",";
}
- ost << req->getAddress()->getIndex();
+ ost << req.getAddress()->getIndex();
}
return ost.str();
}
-void
-BucketDBUpdaterTest::testPendingClusterStateSendMessages()
-{
- CPPUNIT_ASSERT_EQUAL(
- getNodeList({0, 1, 2}),
- getSentNodes("cluster:d",
- "distributor:1 storage:3"));
-
- CPPUNIT_ASSERT_EQUAL(
- getNodeList({0, 1}),
- getSentNodes("cluster:d",
- "distributor:1 storage:3 .2.s:m"));
-
- CPPUNIT_ASSERT_EQUAL(
- getNodeList({2}),
- getSentNodes("distributor:1 storage:2",
- "distributor:1 storage:3"));
-
- CPPUNIT_ASSERT_EQUAL(
- getNodeList({2, 3, 4, 5}),
- getSentNodes("distributor:1 storage:2",
- "distributor:1 storage:6"));
-
- CPPUNIT_ASSERT_EQUAL(
- getNodeList({0, 1, 2}),
- getSentNodes("distributor:4 storage:3",
- "distributor:3 storage:3"));
-
- CPPUNIT_ASSERT_EQUAL(
- getNodeList({0, 1, 2, 3}),
- getSentNodes("distributor:4 storage:3",
- "distributor:4 .2.s:d storage:4"));
-
- CPPUNIT_ASSERT_EQUAL(
- std::string(""),
- getSentNodes("distributor:4 storage:3",
- "distributor:4 .0.s:d storage:4"));
-
- CPPUNIT_ASSERT_EQUAL(
- std::string(""),
- getSentNodes("distributor:3 storage:3",
- "distributor:4 storage:3"));
-
- CPPUNIT_ASSERT_EQUAL(
- getNodeList({2}),
- getSentNodes("distributor:3 storage:3 .2.s:i",
- "distributor:3 storage:3"));
-
- CPPUNIT_ASSERT_EQUAL(
- getNodeList({1}),
- getSentNodes("distributor:3 storage:3 .1.s:d",
- "distributor:3 storage:3"));
-
- CPPUNIT_ASSERT_EQUAL(
- getNodeList({1, 2, 4}),
- getSentNodes("distributor:3 storage:4 .1.s:d .2.s:i",
- "distributor:3 storage:5"));
-
- CPPUNIT_ASSERT_EQUAL(
- std::string(""),
- getSentNodes("distributor:1 storage:3",
- "cluster:d"));
-
- CPPUNIT_ASSERT_EQUAL(
- std::string(""),
- getSentNodes("distributor:1 storage:3",
- "distributor:1 storage:3"));
-
- CPPUNIT_ASSERT_EQUAL(
- std::string(""),
- getSentNodes("distributor:1 storage:3",
- "cluster:d distributor:1 storage:6"));
-
- CPPUNIT_ASSERT_EQUAL(
- std::string(""),
- getSentNodes("distributor:3 storage:3",
- "distributor:3 .2.s:m storage:3"));
-
- CPPUNIT_ASSERT_EQUAL(
- getNodeList({0, 1, 2}),
- getSentNodes("distributor:3 .2.s:m storage:3",
- "distributor:3 .2.s:d storage:3"));
-
- CPPUNIT_ASSERT_EQUAL(
- std::string(""),
- getSentNodes("distributor:3 .2.s:m storage:3",
- "distributor:3 storage:3"));
-
- CPPUNIT_ASSERT_EQUAL(
- getNodeList({0, 1, 2}),
- getSentNodesDistributionChanged("distributor:3 storage:3"));
-
- CPPUNIT_ASSERT_EQUAL(
- getNodeList({0, 1}),
- getSentNodes("distributor:10 storage:2",
- "distributor:10 .1.s:d storage:2"));
-
- CPPUNIT_ASSERT_EQUAL(
- getNodeList({1}),
- getSentNodes("distributor:2 storage:2",
- "distributor:2 storage:2 .1.d:3 .1.d.1.s:d"));
+TEST_F(BucketDBUpdaterTest, testPendingClusterStateSendMessages) {
+ EXPECT_EQ(getNodeList({0, 1, 2}),
+ getSentNodes("cluster:d",
+ "distributor:1 storage:3"));
- CPPUNIT_ASSERT_EQUAL(
- getNodeList({1}),
- getSentNodes("distributor:2 storage:2 .1.s:d",
- "distributor:2 storage:2 .1.d:3 .1.d.1.s:d"));
+ EXPECT_EQ(getNodeList({0, 1}),
+ getSentNodes("cluster:d",
+ "distributor:1 storage:3 .2.s:m"));
- CPPUNIT_ASSERT_EQUAL(
- std::string(""),
- getSentNodes("distributor:2 storage:2",
- "distributor:3 .2.s:i storage:2"));
+ EXPECT_EQ(getNodeList({2}),
+ getSentNodes("distributor:1 storage:2",
+ "distributor:1 storage:3"));
- CPPUNIT_ASSERT_EQUAL(
- getNodeList({0, 1, 2}),
- getSentNodes("distributor:3 storage:3",
- "distributor:3 .2.s:s storage:3"));
+ EXPECT_EQ(getNodeList({2, 3, 4, 5}),
+ getSentNodes("distributor:1 storage:2",
+ "distributor:1 storage:6"));
- CPPUNIT_ASSERT_EQUAL(
- std::string(""),
- getSentNodes("distributor:3 .2.s:s storage:3",
- "distributor:3 .2.s:d storage:3"));
+ EXPECT_EQ(getNodeList({0, 1, 2}),
+ getSentNodes("distributor:4 storage:3",
+ "distributor:3 storage:3"));
- CPPUNIT_ASSERT_EQUAL(
- getNodeList({1}),
- getSentNodes("distributor:3 storage:3 .1.s:m",
- "distributor:3 storage:3"));
-
- CPPUNIT_ASSERT_EQUAL(
- std::string(""),
- getSentNodes("distributor:3 storage:3",
- "distributor:3 storage:3 .1.s:m"));
+ EXPECT_EQ(getNodeList({0, 1, 2, 3}),
+ getSentNodes("distributor:4 storage:3",
+ "distributor:4 .2.s:d storage:4"));
+
+ EXPECT_EQ(std::string(""),
+ getSentNodes("distributor:4 storage:3",
+ "distributor:4 .0.s:d storage:4"));
+
+ EXPECT_EQ(std::string(""),
+ getSentNodes("distributor:3 storage:3",
+ "distributor:4 storage:3"));
+
+ EXPECT_EQ(getNodeList({2}),
+ getSentNodes("distributor:3 storage:3 .2.s:i",
+ "distributor:3 storage:3"));
+
+ EXPECT_EQ(getNodeList({1}),
+ getSentNodes("distributor:3 storage:3 .1.s:d",
+ "distributor:3 storage:3"));
+
+ EXPECT_EQ(getNodeList({1, 2, 4}),
+ getSentNodes("distributor:3 storage:4 .1.s:d .2.s:i",
+ "distributor:3 storage:5"));
+
+ EXPECT_EQ(std::string(""),
+ getSentNodes("distributor:1 storage:3",
+ "cluster:d"));
+
+ EXPECT_EQ(std::string(""),
+ getSentNodes("distributor:1 storage:3",
+ "distributor:1 storage:3"));
+
+ EXPECT_EQ(std::string(""),
+ getSentNodes("distributor:1 storage:3",
+ "cluster:d distributor:1 storage:6"));
+
+ EXPECT_EQ(std::string(""),
+ getSentNodes("distributor:3 storage:3",
+ "distributor:3 .2.s:m storage:3"));
+
+ EXPECT_EQ(getNodeList({0, 1, 2}),
+ getSentNodes("distributor:3 .2.s:m storage:3",
+ "distributor:3 .2.s:d storage:3"));
+
+ EXPECT_EQ(std::string(""),
+ getSentNodes("distributor:3 .2.s:m storage:3",
+ "distributor:3 storage:3"));
+
+ EXPECT_EQ(getNodeList({0, 1, 2}),
+ getSentNodesDistributionChanged("distributor:3 storage:3"));
+
+ EXPECT_EQ(getNodeList({0, 1}),
+ getSentNodes("distributor:10 storage:2",
+ "distributor:10 .1.s:d storage:2"));
+
+ EXPECT_EQ(getNodeList({1}),
+ getSentNodes("distributor:2 storage:2",
+ "distributor:2 storage:2 .1.d:3 .1.d.1.s:d"));
+
+ EXPECT_EQ(getNodeList({1}),
+ getSentNodes("distributor:2 storage:2 .1.s:d",
+ "distributor:2 storage:2 .1.d:3 .1.d.1.s:d"));
+
+ EXPECT_EQ(std::string(""),
+ getSentNodes("distributor:2 storage:2",
+ "distributor:3 .2.s:i storage:2"));
+
+ EXPECT_EQ(getNodeList({0, 1, 2}),
+ getSentNodes("distributor:3 storage:3",
+ "distributor:3 .2.s:s storage:3"));
+
+ EXPECT_EQ(std::string(""),
+ getSentNodes("distributor:3 .2.s:s storage:3",
+ "distributor:3 .2.s:d storage:3"));
+
+ EXPECT_EQ(getNodeList({1}),
+ getSentNodes("distributor:3 storage:3 .1.s:m",
+ "distributor:3 storage:3"));
+
+ EXPECT_EQ(std::string(""),
+ getSentNodes("distributor:3 storage:3",
+ "distributor:3 storage:3 .1.s:m"));
};
-void
-BucketDBUpdaterTest::testPendingClusterStateReceive()
-{
+TEST_F(BucketDBUpdaterTest, testPendingClusterStateReceive) {
MessageSenderStub sender;
auto cmd(std::make_shared<api::SetSystemStateCommand>(
@@ -1761,38 +1511,31 @@ BucketDBUpdaterTest::testPendingClusterStateReceive()
clock, clusterInfo, sender, getBucketSpaceRepo(), getReadOnlyBucketSpaceRepo(),
cmd, outdatedNodesMap, api::Timestamp(1)));
- CPPUNIT_ASSERT_EQUAL(messageCount(3), sender.commands.size());
+ ASSERT_EQ(messageCount(3), sender.commands.size());
sortSentMessagesByIndex(sender);
std::ostringstream ost;
for (uint32_t i = 0; i < sender.commands.size(); i++) {
- RequestBucketInfoCommand* req =
- dynamic_cast<RequestBucketInfoCommand*>(sender.commands[i].get());
+ auto* req = dynamic_cast<RequestBucketInfoCommand*>(sender.commands[i].get());
+ ASSERT_TRUE(req != nullptr);
- RequestBucketInfoReply* rep =
- new RequestBucketInfoReply(*req);
+ auto rep = std::make_shared<RequestBucketInfoReply>(*req);
rep->getBucketInfo().push_back(
RequestBucketInfoReply::Entry(
document::BucketId(16, i),
api::BucketInfo(i, i, i, i, i)));
- CPPUNIT_ASSERT(
- state->onRequestBucketInfoReply(
- std::shared_ptr<api::RequestBucketInfoReply>(rep)));
-
- CPPUNIT_ASSERT_EQUAL(i == sender.commands.size() - 1 ? true : false,
- state->done());
+ ASSERT_TRUE(state->onRequestBucketInfoReply(rep));
+ ASSERT_EQ((i == (sender.commands.size() - 1)), state->done());
}
- auto &pendingTransition = state->getPendingBucketSpaceDbTransition(makeBucketSpace());
- CPPUNIT_ASSERT_EQUAL(3, (int)pendingTransition.results().size());
+ auto& pendingTransition = state->getPendingBucketSpaceDbTransition(makeBucketSpace());
+ EXPECT_EQ(3, (int)pendingTransition.results().size());
}
-void
-BucketDBUpdaterTest::testPendingClusterStateWithGroupDown()
-{
+TEST_F(BucketDBUpdaterTest, testPendingClusterStateWithGroupDown) {
std::string config(getDistConfig6Nodes4Groups());
config += "distributor_auto_ownership_transfer_on_whole_group_down true\n";
setDistribution(config);
@@ -1801,30 +1544,25 @@ BucketDBUpdaterTest::testPendingClusterStateWithGroupDown()
// We're node index 0.
// Entire group 1 goes down. Must refetch from all nodes.
- CPPUNIT_ASSERT_EQUAL(
- getNodeList({0, 1, 2, 3, 4, 5}),
- getSentNodes("distributor:6 storage:6",
- "distributor:6 .2.s:d .3.s:d storage:6"));
+ EXPECT_EQ(getNodeList({0, 1, 2, 3, 4, 5}),
+ getSentNodes("distributor:6 storage:6",
+ "distributor:6 .2.s:d .3.s:d storage:6"));
// But don't fetch if not the entire group is down.
- CPPUNIT_ASSERT_EQUAL(
- std::string(""),
- getSentNodes("distributor:6 storage:6",
- "distributor:6 .2.s:d storage:6"));
+ EXPECT_EQ(std::string(""),
+ getSentNodes("distributor:6 storage:6",
+ "distributor:6 .2.s:d storage:6"));
}
-void
-BucketDBUpdaterTest::testPendingClusterStateWithGroupDownAndNoHandover()
-{
+TEST_F(BucketDBUpdaterTest, testPendingClusterStateWithGroupDownAndNoHandover) {
std::string config(getDistConfig6Nodes4Groups());
config += "distributor_auto_ownership_transfer_on_whole_group_down false\n";
setDistribution(config);
// Group is down, but config says to not do anything about it.
- CPPUNIT_ASSERT_EQUAL(
- getNodeList({0, 1, 2, 3, 4, 5}, _bucketSpaces.size() - 1),
- getSentNodes("distributor:6 storage:6",
- "distributor:6 .2.s:d .3.s:d storage:6"));
+ EXPECT_EQ(getNodeList({0, 1, 2, 3, 4, 5}, _bucketSpaces.size() - 1),
+ getSentNodes("distributor:6 storage:6",
+ "distributor:6 .2.s:d .3.s:d storage:6"));
}
void
@@ -1840,7 +1578,7 @@ parseInputData(const std::string& data,
uint16_t node = atoi(tok2[0].data());
state.setNodeReplied(node);
- auto &pendingTransition = state.getPendingBucketSpaceDbTransition(makeBucketSpace());
+ auto& pendingTransition = state.getPendingBucketSpaceDbTransition(makeBucketSpace());
vespalib::StringTokenizer tok3(tok2[1], ",");
for (uint32_t j = 0; j < tok3.size(); j++) {
@@ -1874,7 +1612,7 @@ struct BucketDumper : public BucketDatabase::EntryProcessor
std::ostringstream ost;
bool _includeBucketInfo;
- BucketDumper(bool includeBucketInfo)
+ explicit BucketDumper(bool includeBucketInfo)
: _includeBucketInfo(includeBucketInfo)
{
}
@@ -1969,11 +1707,9 @@ BucketDBUpdaterTest::mergeBucketLists(const std::string& existingData,
includeBucketInfo);
}
-void
-BucketDBUpdaterTest::testPendingClusterStateMerge()
-{
+TEST_F(BucketDBUpdaterTest, testPendingClusterStateMerge) {
// Simple initializing case - ask all nodes for info
- CPPUNIT_ASSERT_EQUAL(
+ EXPECT_EQ(
// Result is on the form: [bucket w/o count bits]:[node indexes]|..
std::string("4:0,1|2:0,1|6:1,2|1:0,2|5:2,0|3:2,1|"),
// Input is on the form: [node]:[bucket w/o count bits]|...
@@ -1982,7 +1718,7 @@ BucketDBUpdaterTest::testPendingClusterStateMerge()
"0:1,2,4,5|1:2,3,4,6|2:1,3,5,6"));
// Node came up with fewer buckets (lost disk)
- CPPUNIT_ASSERT_EQUAL(
+ EXPECT_EQ(
std::string("4:1|2:0,1|6:1,2|1:2,0|5:2|3:2,1|"),
mergeBucketLists(
lib::ClusterState("distributor:1 storage:3"),
@@ -1992,7 +1728,7 @@ BucketDBUpdaterTest::testPendingClusterStateMerge()
);
// New node came up
- CPPUNIT_ASSERT_EQUAL(
+ EXPECT_EQ(
std::string("4:0,1|2:0,1|6:1,2,3|1:0,2,3|5:2,0,3|3:2,1,3|"),
mergeBucketLists(
"0:1,2,4,5|1:2,3,4,6|2:1,3,5,6",
@@ -2001,14 +1737,14 @@ BucketDBUpdaterTest::testPendingClusterStateMerge()
// Node came up with some buckets removed and some added
// Buckets that were removed should not be removed as the node
// didn't lose a disk.
- CPPUNIT_ASSERT_EQUAL(
+ EXPECT_EQ(
std::string("8:0|4:0,1|2:0,1|6:1,0,2|1:0,2|5:2,0|3:2,1|"),
mergeBucketLists(
"0:1,2,4,5|1:2,3,4,6|2:1,3,5,6",
"0:1,2,6,8"));
// Node came up with no buckets
- CPPUNIT_ASSERT_EQUAL(
+ EXPECT_EQ(
std::string("4:1|2:1|6:1,2|1:2|5:2|3:2,1|"),
mergeBucketLists(
lib::ClusterState("distributor:1 storage:3"),
@@ -2019,7 +1755,7 @@ BucketDBUpdaterTest::testPendingClusterStateMerge()
// One node lost a disk, another was just reasked (distributor
// change)
- CPPUNIT_ASSERT_EQUAL(
+ EXPECT_EQ(
std::string("2:0,1|6:1,2|1:2,0|5:2|3:2,1|"),
mergeBucketLists(
lib::ClusterState("distributor:1 storage:3"),
@@ -2030,23 +1766,20 @@ BucketDBUpdaterTest::testPendingClusterStateMerge()
// Bucket info format is "bucketid/checksum/count/size"
// Node went from initializing to up and invalid bucket went to empty.
- CPPUNIT_ASSERT_EQUAL(
+ EXPECT_EQ(
std::string("2:0/0/0/0/t|"),
mergeBucketLists(
"0:2/0/0/1",
"0:2/0/0/0",
true));
- CPPUNIT_ASSERT_EQUAL(
- std::string("5:1/2/3/4/u,0/0/0/0/u|"),
- mergeBucketLists("", "0:5/0/0/0|1:5/2/3/4", true));
+ EXPECT_EQ(std::string("5:1/2/3/4/u,0/0/0/0/u|"),
+ mergeBucketLists("", "0:5/0/0/0|1:5/2/3/4", true));
}
-void
-BucketDBUpdaterTest::testPendingClusterStateMergeReplicaChanged()
-{
+TEST_F(BucketDBUpdaterTest, testPendingClusterStateMergeReplicaChanged) {
// Node went from initializing to up and non-invalid bucket changed.
- CPPUNIT_ASSERT_EQUAL(
+ EXPECT_EQ(
std::string("2:0/2/3/4/t|3:0/2/4/6/t|"),
mergeBucketLists(
lib::ClusterState("distributor:1 storage:1 .0.s:i"),
@@ -2056,20 +1789,18 @@ BucketDBUpdaterTest::testPendingClusterStateMergeReplicaChanged()
true));
}
-void
-BucketDBUpdaterTest::testNoDbResurrectionForBucketNotOwnedInCurrentState()
-{
+TEST_F(BucketDBUpdaterTest, testNoDbResurrectionForBucketNotOwnedInCurrentState) {
document::BucketId bucket(16, 3);
lib::ClusterState stateBefore("distributor:1 storage:1");
{
uint32_t expectedMsgs = _bucketSpaces.size(), dummyBucketsToReturn = 1;
- setAndEnableClusterState(stateBefore, expectedMsgs, dummyBucketsToReturn);
+ ASSERT_NO_FATAL_FAILURE(setAndEnableClusterState(stateBefore, expectedMsgs, dummyBucketsToReturn));
}
_sender.clear();
getBucketDBUpdater().recheckBucketInfo(0, makeDocumentBucket(bucket));
- CPPUNIT_ASSERT_EQUAL(size_t(1), _sender.commands.size());
+ ASSERT_EQ(size_t(1), _sender.commands.size());
std::shared_ptr<api::RequestBucketInfoCommand> rbi(
std::dynamic_pointer_cast<RequestBucketInfoCommand>(
_sender.commands[0]));
@@ -2078,30 +1809,28 @@ BucketDBUpdaterTest::testNoDbResurrectionForBucketNotOwnedInCurrentState()
{
uint32_t expectedMsgs = messageCount(2), dummyBucketsToReturn = 1;
- setAndEnableClusterState(stateAfter, expectedMsgs, dummyBucketsToReturn);
+ ASSERT_NO_FATAL_FAILURE(setAndEnableClusterState(stateAfter, expectedMsgs, dummyBucketsToReturn));
}
- CPPUNIT_ASSERT(!getBucketDBUpdater().getDistributorComponent()
- .ownsBucketInCurrentState(makeDocumentBucket(bucket)));
+ EXPECT_FALSE(getBucketDBUpdater().getDistributorComponent()
+ .ownsBucketInCurrentState(makeDocumentBucket(bucket)));
- sendFakeReplyForSingleBucketRequest(*rbi);
+ ASSERT_NO_FATAL_FAILURE(sendFakeReplyForSingleBucketRequest(*rbi));
- CPPUNIT_ASSERT_EQUAL(std::string("NONEXISTING"), dumpBucket(bucket));
+ EXPECT_EQ(std::string("NONEXISTING"), dumpBucket(bucket));
}
-void
-BucketDBUpdaterTest::testNoDbResurrectionForBucketNotOwnedInPendingState()
-{
+TEST_F(BucketDBUpdaterTest, testNoDbResurrectionForBucketNotOwnedInPendingState) {
document::BucketId bucket(16, 3);
lib::ClusterState stateBefore("distributor:1 storage:1");
{
uint32_t expectedMsgs = _bucketSpaces.size(), dummyBucketsToReturn = 1;
- setAndEnableClusterState(stateBefore, expectedMsgs, dummyBucketsToReturn);
+ ASSERT_NO_FATAL_FAILURE(setAndEnableClusterState(stateBefore, expectedMsgs, dummyBucketsToReturn));
}
_sender.clear();
getBucketDBUpdater().recheckBucketInfo(0, makeDocumentBucket(bucket));
- CPPUNIT_ASSERT_EQUAL(size_t(1), _sender.commands.size());
+ ASSERT_EQ(size_t(1), _sender.commands.size());
std::shared_ptr<api::RequestBucketInfoCommand> rbi(
std::dynamic_pointer_cast<RequestBucketInfoCommand>(
_sender.commands[0]));
@@ -2109,14 +1838,14 @@ BucketDBUpdaterTest::testNoDbResurrectionForBucketNotOwnedInPendingState()
lib::ClusterState stateAfter("distributor:3 storage:3");
// Set, but _don't_ enable cluster state. We want it to be pending.
setSystemState(stateAfter);
- CPPUNIT_ASSERT(getBucketDBUpdater().getDistributorComponent()
- .ownsBucketInCurrentState(makeDocumentBucket(bucket)));
- CPPUNIT_ASSERT(!getBucketDBUpdater()
- .checkOwnershipInPendingState(makeDocumentBucket(bucket)).isOwned());
+ EXPECT_TRUE(getBucketDBUpdater().getDistributorComponent()
+ .ownsBucketInCurrentState(makeDocumentBucket(bucket)));
+ EXPECT_FALSE(getBucketDBUpdater()
+ .checkOwnershipInPendingState(makeDocumentBucket(bucket)).isOwned());
- sendFakeReplyForSingleBucketRequest(*rbi);
+ ASSERT_NO_FATAL_FAILURE(sendFakeReplyForSingleBucketRequest(*rbi));
- CPPUNIT_ASSERT_EQUAL(std::string("NONEXISTING"), dumpBucket(bucket));
+ EXPECT_EQ(std::string("NONEXISTING"), dumpBucket(bucket));
}
/*
@@ -2126,109 +1855,101 @@ BucketDBUpdaterTest::testNoDbResurrectionForBucketNotOwnedInPendingState()
* will with a high likelihood end up not getting the complete view of the buckets in
* the cluster.
*/
-void
-BucketDBUpdaterTest::testClusterStateAlwaysSendsFullFetchWhenDistributionChangePending()
-{
+TEST_F(BucketDBUpdaterTest, testClusterStateAlwaysSendsFullFetchWhenDistributionChangePending) {
lib::ClusterState stateBefore("distributor:6 storage:6");
{
uint32_t expectedMsgs = messageCount(6), dummyBucketsToReturn = 1;
- setAndEnableClusterState(stateBefore, expectedMsgs, dummyBucketsToReturn);
+ ASSERT_NO_FATAL_FAILURE(setAndEnableClusterState(stateBefore, expectedMsgs, dummyBucketsToReturn));
}
_sender.clear();
std::string distConfig(getDistConfig6Nodes2Groups());
setDistribution(distConfig);
sortSentMessagesByIndex(_sender);
- CPPUNIT_ASSERT_EQUAL(messageCount(6), _sender.commands.size());
+ ASSERT_EQ(messageCount(6), _sender.commands.size());
// Suddenly, a wild cluster state change appears! Even though this state
// does not in itself imply any bucket changes, it will still overwrite the
// pending cluster state and thus its state of pending bucket info requests.
setSystemState(lib::ClusterState("distributor:6 .2.t:12345 storage:6"));
- CPPUNIT_ASSERT_EQUAL(messageCount(12), _sender.commands.size());
+ ASSERT_EQ(messageCount(12), _sender.commands.size());
// Send replies for first messageCount(6) (outdated requests).
int numBuckets = 10;
for (uint32_t i = 0; i < messageCount(6); ++i) {
- fakeBucketReply(lib::ClusterState("distributor:6 storage:6"),
- *_sender.commands[i], numBuckets);
+ ASSERT_NO_FATAL_FAILURE(fakeBucketReply(lib::ClusterState("distributor:6 storage:6"),
+ *_sender.commands[i], numBuckets));
}
// No change from these.
- assertCorrectBuckets(1, "distributor:6 storage:6");
+ ASSERT_NO_FATAL_FAILURE(assertCorrectBuckets(1, "distributor:6 storage:6"));
// Send for current pending.
for (uint32_t i = 0; i < messageCount(6); ++i) {
- fakeBucketReply(lib::ClusterState("distributor:6 .2.t:12345 storage:6"),
- *_sender.commands[i + messageCount(6)],
- numBuckets);
+ ASSERT_NO_FATAL_FAILURE(fakeBucketReply(lib::ClusterState("distributor:6 .2.t:12345 storage:6"),
+ *_sender.commands[i + messageCount(6)],
+ numBuckets));
}
- assertCorrectBuckets(numBuckets, "distributor:6 storage:6");
+ ASSERT_NO_FATAL_FAILURE(assertCorrectBuckets(numBuckets, "distributor:6 storage:6"));
_sender.clear();
// No more pending global fetch; this should be a no-op state.
setSystemState(lib::ClusterState("distributor:6 .3.t:12345 storage:6"));
- CPPUNIT_ASSERT_EQUAL(size_t(0), _sender.commands.size());
+ EXPECT_EQ(size_t(0), _sender.commands.size());
}
-void
-BucketDBUpdaterTest::testChangedDistributionConfigTriggersRecoveryMode()
-{
- setAndEnableClusterState(lib::ClusterState("distributor:6 storage:6"), messageCount(6), 20);
+TEST_F(BucketDBUpdaterTest, testChangedDistributionConfigTriggersRecoveryMode) {
+ ASSERT_NO_FATAL_FAILURE(setAndEnableClusterState(lib::ClusterState("distributor:6 storage:6"), messageCount(6), 20));
_sender.clear();
// First cluster state; implicit scan of all buckets which does not
// use normal recovery mode ticking-path.
- CPPUNIT_ASSERT(!_distributor->isInRecoveryMode());
+ EXPECT_FALSE(_distributor->isInRecoveryMode());
std::string distConfig(getDistConfig6Nodes4Groups());
setDistribution(distConfig);
sortSentMessagesByIndex(_sender);
// No replies received yet, still no recovery mode.
- CPPUNIT_ASSERT(!_distributor->isInRecoveryMode());
+ EXPECT_FALSE(_distributor->isInRecoveryMode());
- CPPUNIT_ASSERT_EQUAL(messageCount(6), _sender.commands.size());
+ ASSERT_EQ(messageCount(6), _sender.commands.size());
uint32_t numBuckets = 10;
for (uint32_t i = 0; i < messageCount(6); ++i) {
- fakeBucketReply(lib::ClusterState("distributor:6 storage:6"),
- *_sender.commands[i], numBuckets);
+ ASSERT_NO_FATAL_FAILURE(fakeBucketReply(lib::ClusterState("distributor:6 storage:6"),
+ *_sender.commands[i], numBuckets));
}
// Pending cluster state (i.e. distribution) has been enabled, which should
// cause recovery mode to be entered.
- CPPUNIT_ASSERT(_distributor->isInRecoveryMode());
+ EXPECT_TRUE(_distributor->isInRecoveryMode());
}
-void
-BucketDBUpdaterTest::testNewlyAddedBucketsHaveCurrentTimeAsGcTimestamp()
-{
+TEST_F(BucketDBUpdaterTest, testNewlyAddedBucketsHaveCurrentTimeAsGcTimestamp) {
getClock().setAbsoluteTimeInSeconds(101234);
lib::ClusterState stateBefore("distributor:1 storage:1");
{
uint32_t expectedMsgs = _bucketSpaces.size(), dummyBucketsToReturn = 1;
- setAndEnableClusterState(stateBefore, expectedMsgs, dummyBucketsToReturn);
+ ASSERT_NO_FATAL_FAILURE(setAndEnableClusterState(stateBefore, expectedMsgs, dummyBucketsToReturn));
}
// setAndEnableClusterState adds n buckets with id (16, i)
document::BucketId bucket(16, 0);
BucketDatabase::Entry e(getBucket(bucket));
- CPPUNIT_ASSERT(e.valid());
- CPPUNIT_ASSERT_EQUAL(uint32_t(101234), e->getLastGarbageCollectionTime());
+ ASSERT_TRUE(e.valid());
+ EXPECT_EQ(uint32_t(101234), e->getLastGarbageCollectionTime());
}
-void
-BucketDBUpdaterTest::testNewerMutationsNotOverwrittenByEarlierBucketFetch()
-{
+TEST_F(BucketDBUpdaterTest, testNewerMutationsNotOverwrittenByEarlierBucketFetch) {
{
lib::ClusterState stateBefore("distributor:1 storage:1 .0.s:i");
uint32_t expectedMsgs = _bucketSpaces.size(), dummyBucketsToReturn = 0;
// This step is required to make the distributor ready for accepting
// the below explicit database insertion towards node 0.
- setAndEnableClusterState(stateBefore, expectedMsgs,
- dummyBucketsToReturn);
+ ASSERT_NO_FATAL_FAILURE(setAndEnableClusterState(stateBefore, expectedMsgs,
+ dummyBucketsToReturn));
}
_sender.clear();
getClock().setAbsoluteTimeInSeconds(1000);
lib::ClusterState state("distributor:1 storage:1");
setSystemState(state);
- CPPUNIT_ASSERT_EQUAL(_bucketSpaces.size(), _sender.commands.size());
+ ASSERT_EQ(_bucketSpaces.size(), _sender.commands.size());
// Before replying with the bucket info, simulate the arrival of a mutation
// reply that alters the state of the bucket with information that will be
@@ -2253,13 +1974,12 @@ BucketDBUpdaterTest::testNewerMutationsNotOverwrittenByEarlierBucketFetch()
// correctness, as this should contain the same bucket info as that
// contained in the full bucket reply and the DB update is thus idempotent.
for (uint32_t i = 0; i < _bucketSpaces.size(); ++i) {
- fakeBucketReply(state, *_sender.commands[i], bucketsReturned);
+ ASSERT_NO_FATAL_FAILURE(fakeBucketReply(state, *_sender.commands[i], bucketsReturned));
}
BucketDatabase::Entry e(getBucket(bucket));
- CPPUNIT_ASSERT_EQUAL(uint32_t(1), e->getNodeCount());
- CPPUNIT_ASSERT_EQUAL(wantedInfo, e->getNodeRef(0).getBucketInfo());
-
+ ASSERT_EQ(uint32_t(1), e->getNodeCount());
+ EXPECT_EQ(wantedInfo, e->getNodeRef(0).getBucketInfo());
}
std::vector<uint16_t>
@@ -2286,9 +2006,11 @@ BucketDBUpdaterTest::getSentNodesWithPreemption(
{
lib::ClusterState stateBefore(oldClusterState);
uint32_t dummyBucketsToReturn = 10;
+ // FIXME cannot chain assertion checks in non-void function
setAndEnableClusterState(lib::ClusterState(oldClusterState),
expectedOldStateMessages,
dummyBucketsToReturn);
+
_sender.clear();
setSystemState(lib::ClusterState(preemptedClusterState));
@@ -2309,10 +2031,8 @@ using nodeVec = std::vector<uint16_t>;
* database modifications caused by intermediate states will not be
* accounted for (basically the ABA problem in a distributed setting).
*/
-void
-BucketDBUpdaterTest::preemptedDistrChangeCarriesNodeSetOverToNextStateFetch()
-{
- CPPUNIT_ASSERT_EQUAL(
+TEST_F(BucketDBUpdaterTest, preemptedDistrChangeCarriesNodeSetOverToNextStateFetch) {
+ EXPECT_EQ(
expandNodeVec({0, 1, 2, 3, 4, 5}),
getSentNodesWithPreemption("version:1 distributor:6 storage:6",
messageCount(6),
@@ -2320,10 +2040,8 @@ BucketDBUpdaterTest::preemptedDistrChangeCarriesNodeSetOverToNextStateFetch()
"version:3 distributor:6 storage:6"));
}
-void
-BucketDBUpdaterTest::preemptedStorChangeCarriesNodeSetOverToNextStateFetch()
-{
- CPPUNIT_ASSERT_EQUAL(
+TEST_F(BucketDBUpdaterTest, preemptedStorChangeCarriesNodeSetOverToNextStateFetch) {
+ EXPECT_EQ(
expandNodeVec({2, 3}),
getSentNodesWithPreemption(
"version:1 distributor:6 storage:6 .2.s:d",
@@ -2332,10 +2050,8 @@ BucketDBUpdaterTest::preemptedStorChangeCarriesNodeSetOverToNextStateFetch()
"version:3 distributor:6 storage:6"));
}
-void
-BucketDBUpdaterTest::preemptedStorageNodeDownMustBeReFetched()
-{
- CPPUNIT_ASSERT_EQUAL(
+TEST_F(BucketDBUpdaterTest, preemptedStorageNodeDownMustBeReFetched) {
+ EXPECT_EQ(
expandNodeVec({2}),
getSentNodesWithPreemption(
"version:1 distributor:6 storage:6",
@@ -2344,10 +2060,8 @@ BucketDBUpdaterTest::preemptedStorageNodeDownMustBeReFetched()
"version:3 distributor:6 storage:6"));
}
-void
-BucketDBUpdaterTest::doNotSendToPreemptedNodeNowInDownState()
-{
- CPPUNIT_ASSERT_EQUAL(
+TEST_F(BucketDBUpdaterTest, doNotSendToPreemptedNodeNowInDownState) {
+ EXPECT_EQ(
nodeVec{},
getSentNodesWithPreemption(
"version:1 distributor:6 storage:6 .2.s:d",
@@ -2356,12 +2070,10 @@ BucketDBUpdaterTest::doNotSendToPreemptedNodeNowInDownState()
"version:3 distributor:6 storage:6 .2.s:d")); // 2 down again.
}
-void
-BucketDBUpdaterTest::doNotSendToPreemptedNodeNotPartOfNewState()
-{
+TEST_F(BucketDBUpdaterTest, doNotSendToPreemptedNodeNotPartOfNewState) {
// Even though 100 nodes are preempted, not all of these should be part
// of the request afterwards when only 6 are part of the state.
- CPPUNIT_ASSERT_EQUAL(
+ EXPECT_EQ(
expandNodeVec({0, 1, 2, 3, 4, 5}),
getSentNodesWithPreemption(
"version:1 distributor:6 storage:100",
@@ -2370,20 +2082,18 @@ BucketDBUpdaterTest::doNotSendToPreemptedNodeNotPartOfNewState()
"version:3 distributor:6 storage:6"));
}
-void
-BucketDBUpdaterTest::outdatedNodeSetClearedAfterSuccessfulStateCompletion()
-{
+TEST_F(BucketDBUpdaterTest, outdatedNodeSetClearedAfterSuccessfulStateCompletion) {
lib::ClusterState stateBefore(
"version:1 distributor:6 storage:6 .1.t:1234");
uint32_t expectedMsgs = messageCount(6), dummyBucketsToReturn = 10;
- setAndEnableClusterState(stateBefore, expectedMsgs, dummyBucketsToReturn);
+ ASSERT_NO_FATAL_FAILURE(setAndEnableClusterState(stateBefore, expectedMsgs, dummyBucketsToReturn));
_sender.clear();
// New cluster state that should not by itself trigger any new fetches,
// unless outdated node set is somehow not cleared after an enabled
// (completed) cluster state has been set.
lib::ClusterState stateAfter("version:3 distributor:6 storage:6");
setSystemState(stateAfter);
- CPPUNIT_ASSERT_EQUAL(size_t(0), _sender.commands.size());
+ EXPECT_EQ(size_t(0), _sender.commands.size());
}
// XXX test currently disabled since distribution config currently isn't used
@@ -2392,12 +2102,10 @@ BucketDBUpdaterTest::outdatedNodeSetClearedAfterSuccessfulStateCompletion()
// distribution config will follow very shortly after the config has been
// applied to the node. The new cluster state will then send out requests to
// the correct node set.
-void
-BucketDBUpdaterTest::clusterConfigDownsizeOnlySendsToAvailableNodes()
-{
+TEST_F(BucketDBUpdaterTest, DISABLED_clusterConfigDownsizeOnlySendsToAvailableNodes) {
uint32_t expectedMsgs = 6, dummyBucketsToReturn = 20;
- setAndEnableClusterState(lib::ClusterState("distributor:6 storage:6"),
- expectedMsgs, dummyBucketsToReturn);
+ ASSERT_NO_FATAL_FAILURE(setAndEnableClusterState(lib::ClusterState("distributor:6 storage:6"),
+ expectedMsgs, dummyBucketsToReturn));
_sender.clear();
// Intentionally trigger a racing config change which arrives before the
@@ -2406,14 +2114,12 @@ BucketDBUpdaterTest::clusterConfigDownsizeOnlySendsToAvailableNodes()
setDistribution(distConfig);
sortSentMessagesByIndex(_sender);
- CPPUNIT_ASSERT_EQUAL((nodeVec{0, 1, 2}), getSendSet());
+ EXPECT_EQ((nodeVec{0, 1, 2}), getSendSet());
}
-void
-BucketDBUpdaterTest::changedDiskSetTriggersReFetch()
-{
+TEST_F(BucketDBUpdaterTest, changedDiskSetTriggersReFetch) {
// Same number of online disks, but the set of disks has changed.
- CPPUNIT_ASSERT_EQUAL(
+ EXPECT_EQ(
getNodeList({1}),
getSentNodes("distributor:2 storage:2 .1.d:3 .1.d.2.s:d",
"distributor:2 storage:2 .1.d:3 .1.d.1.s:d"));
@@ -2427,12 +2133,10 @@ BucketDBUpdaterTest::changedDiskSetTriggersReFetch()
*
* See VESPA-790 for details.
*/
-void
-BucketDBUpdaterTest::nodeMissingFromConfigIsTreatedAsNeedingOwnershipTransfer()
-{
+TEST_F(BucketDBUpdaterTest, nodeMissingFromConfigIsTreatedAsNeedingOwnershipTransfer) {
uint32_t expectedMsgs = messageCount(3), dummyBucketsToReturn = 1;
- setAndEnableClusterState(lib::ClusterState("distributor:3 storage:3"),
- expectedMsgs, dummyBucketsToReturn);
+ ASSERT_NO_FATAL_FAILURE(setAndEnableClusterState(lib::ClusterState("distributor:3 storage:3"),
+ expectedMsgs, dummyBucketsToReturn));
_sender.clear();
// Cluster goes from {0, 1, 2} -> {0, 1}. This leaves us with a config
@@ -2459,78 +2163,64 @@ BucketDBUpdaterTest::nodeMissingFromConfigIsTreatedAsNeedingOwnershipTransfer()
// Attempt to apply state with {0, 1} set. This will compare the new state
// with the previous state, which still has node 2.
expectedMsgs = messageCount(2);
- setAndEnableClusterState(lib::ClusterState("distributor:2 storage:2"),
- expectedMsgs, dummyBucketsToReturn);
+ ASSERT_NO_FATAL_FAILURE(setAndEnableClusterState(lib::ClusterState("distributor:2 storage:2"),
+ expectedMsgs, dummyBucketsToReturn));
- CPPUNIT_ASSERT_EQUAL(expandNodeVec({0, 1}), getSendSet());
+ EXPECT_EQ(expandNodeVec({0, 1}), getSendSet());
}
-void
-BucketDBUpdaterTest::changed_distributor_set_implies_ownership_transfer()
-{
+TEST_F(BucketDBUpdaterTest, changed_distributor_set_implies_ownership_transfer) {
auto fixture = createPendingStateFixtureForStateChange(
"distributor:2 storage:2", "distributor:1 storage:2");
- CPPUNIT_ASSERT(fixture->state->hasBucketOwnershipTransfer());
+ EXPECT_TRUE(fixture->state->hasBucketOwnershipTransfer());
fixture = createPendingStateFixtureForStateChange(
"distributor:2 storage:2", "distributor:2 .1.s:d storage:2");
- CPPUNIT_ASSERT(fixture->state->hasBucketOwnershipTransfer());
+ EXPECT_TRUE(fixture->state->hasBucketOwnershipTransfer());
}
-void
-BucketDBUpdaterTest::unchanged_distributor_set_implies_no_ownership_transfer()
-{
+TEST_F(BucketDBUpdaterTest, unchanged_distributor_set_implies_no_ownership_transfer) {
auto fixture = createPendingStateFixtureForStateChange(
"distributor:2 storage:2", "distributor:2 storage:1");
- CPPUNIT_ASSERT(!fixture->state->hasBucketOwnershipTransfer());
+ EXPECT_FALSE(fixture->state->hasBucketOwnershipTransfer());
fixture = createPendingStateFixtureForStateChange(
"distributor:2 storage:2", "distributor:2 storage:2 .1.s:d");
- CPPUNIT_ASSERT(!fixture->state->hasBucketOwnershipTransfer());
+ EXPECT_FALSE(fixture->state->hasBucketOwnershipTransfer());
}
-void
-BucketDBUpdaterTest::changed_distribution_config_implies_ownership_transfer()
-{
+TEST_F(BucketDBUpdaterTest, changed_distribution_config_implies_ownership_transfer) {
auto fixture = createPendingStateFixtureForDistributionChange(
"distributor:2 storage:2");
- CPPUNIT_ASSERT(fixture->state->hasBucketOwnershipTransfer());
+ EXPECT_TRUE(fixture->state->hasBucketOwnershipTransfer());
}
-void
-BucketDBUpdaterTest::transition_time_tracked_for_single_state_change()
-{
- completeStateTransitionInSeconds("distributor:2 storage:2", 5, messageCount(2));
+TEST_F(BucketDBUpdaterTest, transition_time_tracked_for_single_state_change) {
+ ASSERT_NO_FATAL_FAILURE(completeStateTransitionInSeconds("distributor:2 storage:2", 5, messageCount(2)));
- CPPUNIT_ASSERT_EQUAL(uint64_t(5000), lastTransitionTimeInMillis());
+ EXPECT_EQ(uint64_t(5000), lastTransitionTimeInMillis());
}
-void
-BucketDBUpdaterTest::transition_time_reset_across_non_preempting_state_changes()
-{
- completeStateTransitionInSeconds("distributor:2 storage:2", 5, messageCount(2));
- completeStateTransitionInSeconds("distributor:2 storage:3", 3, messageCount(1));
+TEST_F(BucketDBUpdaterTest, transition_time_reset_across_non_preempting_state_changes) {
+ ASSERT_NO_FATAL_FAILURE(completeStateTransitionInSeconds("distributor:2 storage:2", 5, messageCount(2)));
+ ASSERT_NO_FATAL_FAILURE(completeStateTransitionInSeconds("distributor:2 storage:3", 3, messageCount(1)));
- CPPUNIT_ASSERT_EQUAL(uint64_t(3000), lastTransitionTimeInMillis());
+ EXPECT_EQ(uint64_t(3000), lastTransitionTimeInMillis());
}
-void
-BucketDBUpdaterTest::transition_time_tracked_for_distribution_config_change()
-{
+TEST_F(BucketDBUpdaterTest, transition_time_tracked_for_distribution_config_change) {
lib::ClusterState state("distributor:2 storage:2");
- setAndEnableClusterState(state, messageCount(2), 1);
+ ASSERT_NO_FATAL_FAILURE(setAndEnableClusterState(state, messageCount(2), 1));
_sender.clear();
std::string distConfig(getDistConfig3Nodes1Group());
setDistribution(distConfig);
getClock().addSecondsToTime(4);
- completeBucketInfoGathering(state, messageCount(2));
- CPPUNIT_ASSERT_EQUAL(uint64_t(4000), lastTransitionTimeInMillis());
+ ASSERT_NO_FATAL_FAILURE(completeBucketInfoGathering(state, messageCount(2)));
+ EXPECT_EQ(uint64_t(4000), lastTransitionTimeInMillis());
}
-void
-BucketDBUpdaterTest::transition_time_tracked_across_preempted_transitions()
-{
+TEST_F(BucketDBUpdaterTest, transition_time_tracked_across_preempted_transitions) {
_sender.clear();
lib::ClusterState state("distributor:2 storage:2");
setSystemState(state);
@@ -2538,9 +2228,9 @@ BucketDBUpdaterTest::transition_time_tracked_across_preempted_transitions()
// Pre-empted with new state here, which will push out the old pending
// state and replace it with a new one. We should still count the time
// used processing the old state.
- completeStateTransitionInSeconds("distributor:2 storage:3", 3, messageCount(3));
+ ASSERT_NO_FATAL_FAILURE(completeStateTransitionInSeconds("distributor:2 storage:3", 3, messageCount(3)));
- CPPUNIT_ASSERT_EQUAL(uint64_t(8000), lastTransitionTimeInMillis());
+ EXPECT_EQ(uint64_t(8000), lastTransitionTimeInMillis());
}
/*
@@ -2554,10 +2244,10 @@ BucketDBUpdaterTest::transition_time_tracked_across_preempted_transitions()
* Yes, the order of node<->bucket id is reversed between the two, perhaps to make sure you're awake.
*/
-void BucketDBUpdaterTest::batch_update_of_existing_diverging_replicas_does_not_mark_any_as_trusted() {
+TEST_F(BucketDBUpdaterTest, batch_update_of_existing_diverging_replicas_does_not_mark_any_as_trusted) {
// Replacing bucket information for content node 0 should not mark existing
// untrusted replica as trusted as a side effect.
- CPPUNIT_ASSERT_EQUAL(
+ EXPECT_EQ(
std::string("5:1/7/8/9/u,0/1/2/3/u|"),
mergeBucketLists(
lib::ClusterState("distributor:1 storage:3 .0.s:i"),
@@ -2566,43 +2256,38 @@ void BucketDBUpdaterTest::batch_update_of_existing_diverging_replicas_does_not_m
"0:5/1/2/3|1:5/7/8/9", true));
}
-void BucketDBUpdaterTest::batch_add_of_new_diverging_replicas_does_not_mark_any_as_trusted() {
- CPPUNIT_ASSERT_EQUAL(
- std::string("5:1/7/8/9/u,0/1/2/3/u|"),
- mergeBucketLists("", "0:5/1/2/3|1:5/7/8/9", true));
+TEST_F(BucketDBUpdaterTest, batch_add_of_new_diverging_replicas_does_not_mark_any_as_trusted) {
+ EXPECT_EQ(std::string("5:1/7/8/9/u,0/1/2/3/u|"),
+ mergeBucketLists("", "0:5/1/2/3|1:5/7/8/9", true));
}
-void BucketDBUpdaterTest::batch_add_with_single_resulting_replica_implicitly_marks_as_trusted() {
- CPPUNIT_ASSERT_EQUAL(
- std::string("5:0/1/2/3/t|"),
- mergeBucketLists("", "0:5/1/2/3", true));
+TEST_F(BucketDBUpdaterTest, batch_add_with_single_resulting_replica_implicitly_marks_as_trusted) {
+ EXPECT_EQ(std::string("5:0/1/2/3/t|"),
+ mergeBucketLists("", "0:5/1/2/3", true));
}
-void BucketDBUpdaterTest::identity_update_of_single_replica_does_not_clear_trusted() {
- CPPUNIT_ASSERT_EQUAL(
- std::string("5:0/1/2/3/t|"),
- mergeBucketLists("0:5/1/2/3", "0:5/1/2/3", true));
+TEST_F(BucketDBUpdaterTest, identity_update_of_single_replica_does_not_clear_trusted) {
+ EXPECT_EQ(std::string("5:0/1/2/3/t|"),
+ mergeBucketLists("0:5/1/2/3", "0:5/1/2/3", true));
}
-void BucketDBUpdaterTest::identity_update_of_diverging_untrusted_replicas_does_not_mark_any_as_trusted() {
- CPPUNIT_ASSERT_EQUAL(
- std::string("5:1/7/8/9/u,0/1/2/3/u|"),
- mergeBucketLists("0:5/1/2/3|1:5/7/8/9", "0:5/1/2/3|1:5/7/8/9", true));
+TEST_F(BucketDBUpdaterTest, identity_update_of_diverging_untrusted_replicas_does_not_mark_any_as_trusted) {
+ EXPECT_EQ(std::string("5:1/7/8/9/u,0/1/2/3/u|"),
+ mergeBucketLists("0:5/1/2/3|1:5/7/8/9", "0:5/1/2/3|1:5/7/8/9", true));
}
-void BucketDBUpdaterTest::adding_diverging_replica_to_existing_trusted_does_not_remove_trusted() {
- CPPUNIT_ASSERT_EQUAL(
- std::string("5:1/2/3/4/u,0/1/2/3/t|"),
- mergeBucketLists("0:5/1/2/3", "0:5/1/2/3|1:5/2/3/4", true));
+TEST_F(BucketDBUpdaterTest, adding_diverging_replica_to_existing_trusted_does_not_remove_trusted) {
+ EXPECT_EQ(std::string("5:1/2/3/4/u,0/1/2/3/t|"),
+ mergeBucketLists("0:5/1/2/3", "0:5/1/2/3|1:5/2/3/4", true));
}
-void BucketDBUpdaterTest::batch_update_from_distributor_change_does_not_mark_diverging_replicas_as_trusted() {
+TEST_F(BucketDBUpdaterTest, batch_update_from_distributor_change_does_not_mark_diverging_replicas_as_trusted) {
// This differs from batch_update_of_existing_diverging_replicas_does_not_mark_any_as_trusted
// in that _all_ content nodes are considered outdated when distributor changes take place,
// and therefore a slightly different code path is taken. In particular, bucket info for
// outdated nodes gets removed before possibly being re-added (if present in the bucket info
// response).
- CPPUNIT_ASSERT_EQUAL(
+ EXPECT_EQ(
std::string("5:1/7/8/9/u,0/1/2/3/u|"),
mergeBucketLists(
lib::ClusterState("distributor:2 storage:3"),
@@ -2612,7 +2297,7 @@ void BucketDBUpdaterTest::batch_update_from_distributor_change_does_not_mark_div
}
// TODO remove on Vespa 8 - this is a workaround for https://github.com/vespa-engine/vespa/issues/8475
-void BucketDBUpdaterTest::global_distribution_hash_falls_back_to_legacy_format_upon_request_rejection() {
+TEST_F(BucketDBUpdaterTest, global_distribution_hash_falls_back_to_legacy_format_upon_request_rejection) {
std::string distConfig(getDistConfig6Nodes2Groups());
setDistribution(distConfig);
@@ -2620,7 +2305,7 @@ void BucketDBUpdaterTest::global_distribution_hash_falls_back_to_legacy_format_u
const vespalib::string legacy_hash = "(0d3|3|*(0;0;1;2)(1;3;4;5))";
setSystemState(lib::ClusterState("distributor:6 storage:6"));
- CPPUNIT_ASSERT_EQUAL(messageCount(6), _sender.commands.size());
+ ASSERT_EQ(messageCount(6), _sender.commands.size());
api::RequestBucketInfoCommand* global_req = nullptr;
for (auto& cmd : _sender.commands) {
@@ -2630,8 +2315,8 @@ void BucketDBUpdaterTest::global_distribution_hash_falls_back_to_legacy_format_u
break;
}
}
- CPPUNIT_ASSERT(global_req != nullptr);
- CPPUNIT_ASSERT_EQUAL(current_hash, global_req->getDistributionHash());
+ ASSERT_TRUE(global_req != nullptr);
+ ASSERT_EQ(current_hash, global_req->getDistributionHash());
auto reply = std::make_shared<api::RequestBucketInfoReply>(*global_req);
reply->setResult(api::ReturnCode::REJECTED);
@@ -2641,9 +2326,9 @@ void BucketDBUpdaterTest::global_distribution_hash_falls_back_to_legacy_format_u
getBucketDBUpdater().resendDelayedMessages();
// Should now be a resent request with legacy distribution hash
- CPPUNIT_ASSERT_EQUAL(messageCount(6) + 1, _sender.commands.size());
+ ASSERT_EQ(messageCount(6) + 1, _sender.commands.size());
auto& legacy_req = dynamic_cast<api::RequestBucketInfoCommand&>(*_sender.commands.back());
- CPPUNIT_ASSERT_EQUAL(legacy_hash, legacy_req.getDistributionHash());
+ ASSERT_EQ(legacy_hash, legacy_req.getDistributionHash());
// Now if we reject it _again_ we should cycle back to the current hash
// in case it wasn't a hash-based rejection after all. And the circle of life continues.
@@ -2654,9 +2339,9 @@ void BucketDBUpdaterTest::global_distribution_hash_falls_back_to_legacy_format_u
getClock().addSecondsToTime(10);
getBucketDBUpdater().resendDelayedMessages();
- CPPUNIT_ASSERT_EQUAL(messageCount(6) + 2, _sender.commands.size());
+ ASSERT_EQ(messageCount(6) + 2, _sender.commands.size());
auto& new_current_req = dynamic_cast<api::RequestBucketInfoCommand&>(*_sender.commands.back());
- CPPUNIT_ASSERT_EQUAL(current_hash, new_current_req.getDistributionHash());
+ ASSERT_EQ(current_hash, new_current_req.getDistributionHash());
}
namespace {
@@ -2680,23 +2365,21 @@ void for_each_bucket(const DistributorBucketSpaceRepo& repo, Func&& f) {
}
-using ConfigBuilder = vespa::config::content::core::StorDistributormanagerConfigBuilder;
-
-void BucketDBUpdaterTest::non_owned_buckets_moved_to_read_only_db_on_ownership_change() {
+TEST_F(BucketDBUpdaterTest, non_owned_buckets_moved_to_read_only_db_on_ownership_change) {
getConfig().setAllowStaleReadsDuringClusterStateTransitions(true);
lib::ClusterState initial_state("distributor:1 storage:4"); // All buckets owned by us by definition
set_cluster_state_bundle(lib::ClusterStateBundle(initial_state, {}, false)); // Skip activation step for simplicity
- CPPUNIT_ASSERT_EQUAL(messageCount(4), _sender.commands.size());
+ ASSERT_EQ(messageCount(4), _sender.commands.size());
constexpr uint32_t n_buckets = 10;
- completeBucketInfoGathering(initial_state, messageCount(4), n_buckets);
+ ASSERT_NO_FATAL_FAILURE(completeBucketInfoGathering(initial_state, messageCount(4), n_buckets));
_sender.clear();
- CPPUNIT_ASSERT_EQUAL(size_t(n_buckets), mutable_default_db().size());
- CPPUNIT_ASSERT_EQUAL(size_t(n_buckets), mutable_global_db().size());
- CPPUNIT_ASSERT_EQUAL(size_t(0), read_only_default_db().size());
- CPPUNIT_ASSERT_EQUAL(size_t(0), read_only_global_db().size());
+ EXPECT_EQ(size_t(n_buckets), mutable_default_db().size());
+ EXPECT_EQ(size_t(n_buckets), mutable_global_db().size());
+ EXPECT_EQ(size_t(0), read_only_default_db().size());
+ EXPECT_EQ(size_t(0), read_only_global_db().size());
lib::ClusterState pending_state("distributor:2 storage:4");
@@ -2707,54 +2390,54 @@ void BucketDBUpdaterTest::non_owned_buckets_moved_to_read_only_db_on_ownership_c
buckets_not_owned_in_pending_state.insert(Bucket(space, entry.getBucketId()));
}
});
- CPPUNIT_ASSERT(!buckets_not_owned_in_pending_state.empty());
+ EXPECT_FALSE(buckets_not_owned_in_pending_state.empty());
set_cluster_state_bundle(lib::ClusterStateBundle(pending_state, {}, true)); // Now requires activation
const auto buckets_not_owned_per_space = (buckets_not_owned_in_pending_state.size() / 2); // 2 spaces
const auto expected_mutable_buckets = n_buckets - buckets_not_owned_per_space;
- CPPUNIT_ASSERT_EQUAL(expected_mutable_buckets, mutable_default_db().size());
- CPPUNIT_ASSERT_EQUAL(expected_mutable_buckets, mutable_global_db().size());
- CPPUNIT_ASSERT_EQUAL(buckets_not_owned_per_space, read_only_default_db().size());
- CPPUNIT_ASSERT_EQUAL(buckets_not_owned_per_space, read_only_global_db().size());
+ EXPECT_EQ(expected_mutable_buckets, mutable_default_db().size());
+ EXPECT_EQ(expected_mutable_buckets, mutable_global_db().size());
+ EXPECT_EQ(buckets_not_owned_per_space, read_only_default_db().size());
+ EXPECT_EQ(buckets_not_owned_per_space, read_only_global_db().size());
for_each_bucket(read_only_repo(), [&](const auto& space, const auto& entry) {
- CPPUNIT_ASSERT(buckets_not_owned_in_pending_state.find(Bucket(space, entry.getBucketId()))
- != buckets_not_owned_in_pending_state.end());
+ EXPECT_TRUE(buckets_not_owned_in_pending_state.find(Bucket(space, entry.getBucketId()))
+ != buckets_not_owned_in_pending_state.end());
});
}
-void BucketDBUpdaterTest::buckets_no_longer_available_are_not_moved_to_read_only_database() {
+TEST_F(BucketDBUpdaterTest, buckets_no_longer_available_are_not_moved_to_read_only_database) {
constexpr uint32_t n_buckets = 10;
// No ownership change, just node down. Test redundancy is 2, so removing 2 nodes will
// cause some buckets to be entirely unavailable.
trigger_completed_but_not_yet_activated_transition("version:1 distributor:1 storage:4", n_buckets, 4,
"version:2 distributor:1 storage:4 .0.s:d .1.s:m", n_buckets, 0);
- CPPUNIT_ASSERT_EQUAL(size_t(0), read_only_default_db().size());
- CPPUNIT_ASSERT_EQUAL(size_t(0), read_only_global_db().size());
+ EXPECT_EQ(size_t(0), read_only_default_db().size());
+ EXPECT_EQ(size_t(0), read_only_global_db().size());
}
-void BucketDBUpdaterTest::non_owned_buckets_purged_when_read_only_support_is_config_disabled() {
+TEST_F(BucketDBUpdaterTest, non_owned_buckets_purged_when_read_only_support_is_config_disabled) {
getConfig().setAllowStaleReadsDuringClusterStateTransitions(false);
lib::ClusterState initial_state("distributor:1 storage:4"); // All buckets owned by us by definition
set_cluster_state_bundle(lib::ClusterStateBundle(initial_state, {}, false)); // Skip activation step for simplicity
- CPPUNIT_ASSERT_EQUAL(messageCount(4), _sender.commands.size());
+ ASSERT_EQ(messageCount(4), _sender.commands.size());
constexpr uint32_t n_buckets = 10;
- completeBucketInfoGathering(initial_state, messageCount(4), n_buckets);
+ ASSERT_NO_FATAL_FAILURE(completeBucketInfoGathering(initial_state, messageCount(4), n_buckets));
_sender.clear();
// Nothing in read-only DB after first bulk load of buckets.
- CPPUNIT_ASSERT_EQUAL(size_t(0), read_only_default_db().size());
- CPPUNIT_ASSERT_EQUAL(size_t(0), read_only_global_db().size());
+ EXPECT_EQ(size_t(0), read_only_default_db().size());
+ EXPECT_EQ(size_t(0), read_only_global_db().size());
lib::ClusterState pending_state("distributor:2 storage:4");
setSystemState(pending_state);
// No buckets should be moved into read only db after ownership changes.
- CPPUNIT_ASSERT_EQUAL(size_t(0), read_only_default_db().size());
- CPPUNIT_ASSERT_EQUAL(size_t(0), read_only_global_db().size());
+ EXPECT_EQ(size_t(0), read_only_default_db().size());
+ EXPECT_EQ(size_t(0), read_only_global_db().size());
}
void BucketDBUpdaterTest::trigger_completed_but_not_yet_activated_transition(
@@ -2768,83 +2451,88 @@ void BucketDBUpdaterTest::trigger_completed_but_not_yet_activated_transition(
getConfig().setAllowStaleReadsDuringClusterStateTransitions(true);
lib::ClusterState initial_state(initial_state_str);
setSystemState(initial_state);
- CPPUNIT_ASSERT_EQUAL(messageCount(initial_expected_msgs), _sender.commands.size());
- completeBucketInfoGathering(initial_state, messageCount(initial_expected_msgs), initial_buckets);
+ ASSERT_EQ(messageCount(initial_expected_msgs), _sender.commands.size());
+ ASSERT_NO_FATAL_FAILURE(completeBucketInfoGathering(
+ initial_state, messageCount(initial_expected_msgs), initial_buckets));
_sender.clear();
lib::ClusterState pending_state(pending_state_str); // Ownership change
set_cluster_state_bundle(lib::ClusterStateBundle(pending_state, {}, true));
- CPPUNIT_ASSERT_EQUAL(messageCount(pending_expected_msgs), _sender.commands.size());
- completeBucketInfoGathering(pending_state, messageCount(pending_expected_msgs), pending_buckets);
+ ASSERT_EQ(messageCount(pending_expected_msgs), _sender.commands.size());
+ ASSERT_NO_FATAL_FAILURE(completeBucketInfoGathering(
+ pending_state, messageCount(pending_expected_msgs), pending_buckets));
_sender.clear();
}
-void BucketDBUpdaterTest::deferred_activated_state_does_not_enable_state_until_activation_received() {
+TEST_F(BucketDBUpdaterTest, deferred_activated_state_does_not_enable_state_until_activation_received) {
constexpr uint32_t n_buckets = 10;
- trigger_completed_but_not_yet_activated_transition("version:1 distributor:2 storage:4", 0, 4,
- "version:2 distributor:1 storage:4", n_buckets, 4);
+ ASSERT_NO_FATAL_FAILURE(
+ trigger_completed_but_not_yet_activated_transition("version:1 distributor:2 storage:4", 0, 4,
+ "version:2 distributor:1 storage:4", n_buckets, 4));
// Version should not be switched over yet
- CPPUNIT_ASSERT_EQUAL(uint32_t(1), getDistributor().getClusterStateBundle().getVersion());
+ EXPECT_EQ(uint32_t(1), getDistributor().getClusterStateBundle().getVersion());
- CPPUNIT_ASSERT_EQUAL(uint64_t(0), mutable_default_db().size());
- CPPUNIT_ASSERT_EQUAL(uint64_t(0), mutable_global_db().size());
+ EXPECT_EQ(uint64_t(0), mutable_default_db().size());
+ EXPECT_EQ(uint64_t(0), mutable_global_db().size());
- CPPUNIT_ASSERT(!activate_cluster_state_version(2));
+ EXPECT_FALSE(activate_cluster_state_version(2));
- CPPUNIT_ASSERT_EQUAL(uint32_t(2), getDistributor().getClusterStateBundle().getVersion());
- CPPUNIT_ASSERT_EQUAL(uint64_t(n_buckets), mutable_default_db().size());
- CPPUNIT_ASSERT_EQUAL(uint64_t(n_buckets), mutable_global_db().size());
+ EXPECT_EQ(uint32_t(2), getDistributor().getClusterStateBundle().getVersion());
+ EXPECT_EQ(uint64_t(n_buckets), mutable_default_db().size());
+ EXPECT_EQ(uint64_t(n_buckets), mutable_global_db().size());
}
-void BucketDBUpdaterTest::read_only_db_cleared_once_pending_state_is_activated() {
+TEST_F(BucketDBUpdaterTest, read_only_db_cleared_once_pending_state_is_activated) {
constexpr uint32_t n_buckets = 10;
- trigger_completed_but_not_yet_activated_transition("version:1 distributor:1 storage:4", n_buckets, 4,
- "version:2 distributor:2 storage:4", n_buckets, 0);
- CPPUNIT_ASSERT(!activate_cluster_state_version(2));
+ ASSERT_NO_FATAL_FAILURE(
+ trigger_completed_but_not_yet_activated_transition("version:1 distributor:1 storage:4", n_buckets, 4,
+ "version:2 distributor:2 storage:4", n_buckets, 0));
+ EXPECT_FALSE(activate_cluster_state_version(2));
- CPPUNIT_ASSERT_EQUAL(uint64_t(0), read_only_default_db().size());
- CPPUNIT_ASSERT_EQUAL(uint64_t(0), read_only_global_db().size());
+ EXPECT_EQ(uint64_t(0), read_only_default_db().size());
+ EXPECT_EQ(uint64_t(0), read_only_global_db().size());
}
-void BucketDBUpdaterTest::read_only_db_is_populated_even_when_self_is_marked_down() {
+TEST_F(BucketDBUpdaterTest, read_only_db_is_populated_even_when_self_is_marked_down) {
constexpr uint32_t n_buckets = 10;
- trigger_completed_but_not_yet_activated_transition("version:1 distributor:1 storage:4", n_buckets, 4,
- "version:2 distributor:1 .0.s:d storage:4", n_buckets, 0);
+ ASSERT_NO_FATAL_FAILURE(
+ trigger_completed_but_not_yet_activated_transition("version:1 distributor:1 storage:4", n_buckets, 4,
+ "version:2 distributor:1 .0.s:d storage:4", n_buckets, 0));
// State not yet activated, so read-only DBs have got all the buckets we used to have.
- CPPUNIT_ASSERT_EQUAL(uint64_t(0), mutable_default_db().size());
- CPPUNIT_ASSERT_EQUAL(uint64_t(0), mutable_global_db().size());
- CPPUNIT_ASSERT_EQUAL(uint64_t(n_buckets), read_only_default_db().size());
- CPPUNIT_ASSERT_EQUAL(uint64_t(n_buckets), read_only_global_db().size());
+ EXPECT_EQ(uint64_t(0), mutable_default_db().size());
+ EXPECT_EQ(uint64_t(0), mutable_global_db().size());
+ EXPECT_EQ(uint64_t(n_buckets), read_only_default_db().size());
+ EXPECT_EQ(uint64_t(n_buckets), read_only_global_db().size());
}
-void BucketDBUpdaterTest::activate_cluster_state_request_with_mismatching_version_returns_actual_version() {
+TEST_F(BucketDBUpdaterTest, activate_cluster_state_request_with_mismatching_version_returns_actual_version) {
constexpr uint32_t n_buckets = 10;
- trigger_completed_but_not_yet_activated_transition("version:4 distributor:1 storage:4", n_buckets, 4,
- "version:5 distributor:2 storage:4", n_buckets, 0);
+ ASSERT_NO_FATAL_FAILURE(
+ trigger_completed_but_not_yet_activated_transition("version:4 distributor:1 storage:4", n_buckets, 4,
+ "version:5 distributor:2 storage:4", n_buckets, 0));
- CPPUNIT_ASSERT(activate_cluster_state_version(4)); // Too old version
- assert_has_activate_cluster_state_reply_with_actual_version(5);
+ EXPECT_TRUE(activate_cluster_state_version(4)); // Too old version
+ ASSERT_NO_FATAL_FAILURE(assert_has_activate_cluster_state_reply_with_actual_version(5));
- CPPUNIT_ASSERT(activate_cluster_state_version(6)); // More recent version than what has been observed
- assert_has_activate_cluster_state_reply_with_actual_version(5);
+ EXPECT_TRUE(activate_cluster_state_version(6)); // More recent version than what has been observed
+ ASSERT_NO_FATAL_FAILURE(assert_has_activate_cluster_state_reply_with_actual_version(5));
}
-void BucketDBUpdaterTest::activate_cluster_state_request_without_pending_transition_passes_message_through() {
+TEST_F(BucketDBUpdaterTest, activate_cluster_state_request_without_pending_transition_passes_message_through) {
constexpr uint32_t n_buckets = 10;
- trigger_completed_but_not_yet_activated_transition("version:1 distributor:2 storage:4", 0, 4,
- "version:2 distributor:1 storage:4", n_buckets, 4);
+ ASSERT_NO_FATAL_FAILURE(
+ trigger_completed_but_not_yet_activated_transition("version:1 distributor:2 storage:4", 0, 4,
+ "version:2 distributor:1 storage:4", n_buckets, 4));
// Activate version 2; no pending cluster state after this.
- CPPUNIT_ASSERT(!activate_cluster_state_version(2));
+ EXPECT_FALSE(activate_cluster_state_version(2));
// No pending cluster state for version 3, just passed through to be implicitly bounced by state manager.
// Note: state manager is not modelled in this test, so we just check that the message handler returns
// false (meaning "didn't take message ownership") and there's no auto-generated reply.
- CPPUNIT_ASSERT(!activate_cluster_state_version(3));
- CPPUNIT_ASSERT_EQUAL(size_t(0), _sender.replies.size());
+ EXPECT_FALSE(activate_cluster_state_version(3));
+ EXPECT_EQ(size_t(0), _sender.replies.size());
}
-// TODO rename distributor config to imply two phase functionlity explicitly?
-
}