From 71947d62ce117cd5803ca03c1e63e8e9db9e8a86 Mon Sep 17 00:00:00 2001 From: Tor Brede Vekterli Date: Thu, 13 Jun 2019 16:25:25 +0000 Subject: Convert storageserver and visiting tests from CppUnit to GTest --- .../src/tests/storageserver/statemanagertest.cpp | 278 +++++++++------------ 1 file changed, 122 insertions(+), 156 deletions(-) (limited to 'storage/src/tests/storageserver/statemanagertest.cpp') diff --git a/storage/src/tests/storageserver/statemanagertest.cpp b/storage/src/tests/storageserver/statemanagertest.cpp index cdf990fa28f..c2074c53dd7 100644 --- a/storage/src/tests/storageserver/statemanagertest.cpp +++ b/storage/src/tests/storageserver/statemanagertest.cpp @@ -1,6 +1,5 @@ // Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. -#include #include #include #include @@ -11,15 +10,17 @@ #include #include #include +#include using storage::lib::NodeState; using storage::lib::NodeType; using storage::lib::State; using storage::lib::ClusterState; +using namespace ::testing; namespace storage { -struct StateManagerTest : public CppUnit::TestFixture { +struct StateManagerTest : Test { std::unique_ptr _node; std::unique_ptr _upper; std::unique_ptr _metricManager; @@ -28,26 +29,8 @@ struct StateManagerTest : public CppUnit::TestFixture { StateManagerTest(); - void setUp() override; - void tearDown() override; - - void testSystemState(); - void testReportedNodeState(); - void current_cluster_state_version_is_included_in_host_info_json(); - void can_explicitly_send_get_node_state_reply(); - void explicit_node_state_replying_without_pending_request_immediately_replies_on_next_request(); - void immediate_node_state_replying_is_tracked_per_controller(); - void activation_command_is_bounced_with_current_cluster_state_version(); - - CPPUNIT_TEST_SUITE(StateManagerTest); - CPPUNIT_TEST(testSystemState); - CPPUNIT_TEST(testReportedNodeState); - CPPUNIT_TEST(current_cluster_state_version_is_included_in_host_info_json); - CPPUNIT_TEST(can_explicitly_send_get_node_state_reply); - CPPUNIT_TEST(explicit_node_state_replying_without_pending_request_immediately_replies_on_next_request); - CPPUNIT_TEST(immediate_node_state_replying_is_tracked_per_controller); - CPPUNIT_TEST(activation_command_is_bounced_with_current_cluster_state_version); - CPPUNIT_TEST_SUITE_END(); + void SetUp() override; + void TearDown() override; void force_current_cluster_state_version(uint32_t version); void mark_reported_node_state_up(); @@ -55,52 +38,49 @@ struct StateManagerTest : public CppUnit::TestFixture { void assert_ok_get_node_state_reply_sent_and_clear(); void clear_sent_replies(); void mark_reply_observed_from_n_controllers(uint16_t n); -}; -CPPUNIT_TEST_SUITE_REGISTRATION(StateManagerTest); + std::string get_node_info() const { + return _manager->getNodeInfo(); + } +}; StateManagerTest::StateManagerTest() : _node(), _upper(), - _manager(0), - _lower(0) + _manager(nullptr), + _lower(nullptr) { } void -StateManagerTest::setUp() { - try{ - vdstestlib::DirConfig config(getStandardConfig(true)); - _node.reset(new TestServiceLayerApp(DiskCount(1), NodeIndex(2))); - // Clock will increase 1 sec per call. - _node->getClock().setAbsoluteTimeInSeconds(1); - _metricManager.reset(new metrics::MetricManager); - _upper.reset(new DummyStorageLink()); - _manager = new StateManager(_node->getComponentRegister(), - *_metricManager, - std::unique_ptr(new HostInfo)); - _lower = new DummyStorageLink(); - _upper->push_back(StorageLink::UP(_manager)); - _upper->push_back(StorageLink::UP(_lower)); - _upper->open(); - } catch (std::exception& e) { - std::cerr << "Failed to static initialize objects: " << e.what() - << "\n"; - } +StateManagerTest::SetUp() { + vdstestlib::DirConfig config(getStandardConfig(true)); + _node = std::make_unique(DiskCount(1), NodeIndex(2)); + // Clock will increase 1 sec per call. + _node->getClock().setAbsoluteTimeInSeconds(1); + _metricManager = std::make_unique(); + _upper = std::make_unique(); + _manager = new StateManager(_node->getComponentRegister(), + *_metricManager, + std::make_unique()); + _lower = new DummyStorageLink(); + _upper->push_back(StorageLink::UP(_manager)); + _upper->push_back(StorageLink::UP(_lower)); + _upper->open(); } void -StateManagerTest::tearDown() { - CPPUNIT_ASSERT_EQUAL(size_t(0), _lower->getNumReplies()); - CPPUNIT_ASSERT_EQUAL(size_t(0), _lower->getNumCommands()); - CPPUNIT_ASSERT_EQUAL(size_t(0), _upper->getNumReplies()); - CPPUNIT_ASSERT_EQUAL(size_t(0), _upper->getNumCommands()); - _manager = 0; - _lower = 0; +StateManagerTest::TearDown() { + assert(_lower->getNumReplies() == 0); + assert(_lower->getNumCommands() == 0); + assert(_upper->getNumReplies() == 0); + assert(_upper->getNumCommands() == 0); + _manager = nullptr; + _lower = nullptr; _upper->close(); _upper->flush(); - _upper.reset(0); - _node.reset(0); + _upper.reset(); + _node.reset(); _metricManager.reset(); } @@ -112,107 +92,96 @@ void StateManagerTest::force_current_cluster_state_version(uint32_t version) { #define GET_ONLY_OK_REPLY(varname) \ { \ - CPPUNIT_ASSERT_EQUAL(size_t(1), _upper->getNumReplies()); \ - CPPUNIT_ASSERT(_upper->getReply(0)->getType().isReply()); \ + ASSERT_EQ(size_t(1), _upper->getNumReplies()); \ + ASSERT_TRUE(_upper->getReply(0)->getType().isReply()); \ varname = std::dynamic_pointer_cast( \ _upper->getReply(0)); \ - CPPUNIT_ASSERT(varname != 0); \ + ASSERT_TRUE(varname.get() != nullptr); \ _upper->reset(); \ - CPPUNIT_ASSERT_EQUAL(api::ReturnCode(api::ReturnCode::OK), \ - varname->getResult()); \ + ASSERT_EQ(api::ReturnCode(api::ReturnCode::OK), \ + varname->getResult()); \ } -void -StateManagerTest::testSystemState() -{ +TEST_F(StateManagerTest, cluster_state) { std::shared_ptr reply; - // Verify initial state on startup - ClusterState::CSP currentState = _manager->getClusterStateBundle()->getBaselineClusterState(); - CPPUNIT_ASSERT_EQUAL(std::string("cluster:d"), - currentState->toString(false)); + // Verify initial state on startup + auto currentState = _manager->getClusterStateBundle()->getBaselineClusterState(); + EXPECT_EQ("cluster:d", currentState->toString(false)); - NodeState::CSP currentNodeState = _manager->getCurrentNodeState(); - CPPUNIT_ASSERT_EQUAL(std::string("s:d"), currentNodeState->toString(false)); + auto currentNodeState = _manager->getCurrentNodeState(); + EXPECT_EQ("s:d", currentNodeState->toString(false)); ClusterState sendState("storage:4 .2.s:m"); - std::shared_ptr cmd( - new api::SetSystemStateCommand(sendState)); + auto cmd = std::make_shared(sendState); _upper->sendDown(cmd); GET_ONLY_OK_REPLY(reply); currentState = _manager->getClusterStateBundle()->getBaselineClusterState(); - CPPUNIT_ASSERT_EQUAL(sendState, *currentState); + EXPECT_EQ(sendState, *currentState); currentNodeState = _manager->getCurrentNodeState(); - CPPUNIT_ASSERT_EQUAL(std::string("s:m"), currentNodeState->toString(false)); + EXPECT_EQ("s:m", currentNodeState->toString(false)); } namespace { - struct MyStateListener : public StateListener { - const NodeStateUpdater& updater; - lib::NodeState current; - std::ostringstream ost; - - MyStateListener(const NodeStateUpdater& upd) - : updater(upd), current(*updater.getReportedNodeState()) {} - ~MyStateListener() { } - - void handleNewState() override { - ost << current << " -> "; - current = *updater.getReportedNodeState(); - ost << current << "\n"; - } - }; +struct MyStateListener : public StateListener { + const NodeStateUpdater& updater; + lib::NodeState current; + std::ostringstream ost; + + MyStateListener(const NodeStateUpdater& upd) + : updater(upd), current(*updater.getReportedNodeState()) {} + ~MyStateListener() override = default; + + void handleNewState() override { + ost << current << " -> "; + current = *updater.getReportedNodeState(); + ost << current << "\n"; + } +}; } -void -StateManagerTest::testReportedNodeState() -{ +TEST_F(StateManagerTest, reported_node_state) { std::shared_ptr reply; - // Add a state listener to check that we get events. + // Add a state listener to check that we get events. MyStateListener stateListener(*_manager); _manager->addStateListener(stateListener); - // Test that initial state is initializing - NodeState::CSP nodeState = _manager->getReportedNodeState(); - CPPUNIT_ASSERT_EQUAL(std::string("s:i b:58 i:0 t:1"), nodeState->toString(false)); - // Test that it works to update the state + // Test that initial state is initializing + auto nodeState = _manager->getReportedNodeState(); + EXPECT_EQ("s:i b:58 i:0 t:1", nodeState->toString(false)); + // Test that it works to update the state { - NodeStateUpdater::Lock::SP lock(_manager->grabStateChangeLock()); + auto lock = _manager->grabStateChangeLock(); NodeState ns(*_manager->getReportedNodeState()); ns.setState(State::UP); _manager->setReportedNodeState(ns); } - // And that we get the change both through state interface + // And that we get the change both through state interface nodeState = _manager->getReportedNodeState(); - CPPUNIT_ASSERT_EQUAL(std::string("s:u b:58 t:1"), - nodeState->toString(false)); - // And get node state command (no expected state) - std::shared_ptr cmd( - new api::GetNodeStateCommand(lib::NodeState::UP())); + EXPECT_EQ("s:u b:58 t:1", nodeState->toString(false)); + // And get node state command (no expected state) + auto cmd = std::make_shared(lib::NodeState::UP()); _upper->sendDown(cmd); GET_ONLY_OK_REPLY(reply); - CPPUNIT_ASSERT_EQUAL(api::MessageType::GETNODESTATE_REPLY, - reply->getType()); - nodeState.reset(new NodeState( - dynamic_cast(*reply).getNodeState())); - CPPUNIT_ASSERT_EQUAL(std::string("s:u b:58 t:1"), - nodeState->toString(false)); - // We should also get it with wrong expected state - cmd.reset(new api::GetNodeStateCommand(lib::NodeState::UP(new NodeState(NodeType::STORAGE, State::INITIALIZING)))); + ASSERT_EQ(api::MessageType::GETNODESTATE_REPLY, reply->getType()); + nodeState = std::make_shared( + dynamic_cast(*reply).getNodeState()); + EXPECT_EQ("s:u b:58 t:1", nodeState->toString(false)); + // We should also get it with wrong expected state + cmd = std::make_shared( + std::make_unique(NodeType::STORAGE, State::INITIALIZING)); _upper->sendDown(cmd); GET_ONLY_OK_REPLY(reply); - CPPUNIT_ASSERT_EQUAL(api::MessageType::GETNODESTATE_REPLY, - reply->getType()); - nodeState.reset(new NodeState( - dynamic_cast(*reply).getNodeState())); - CPPUNIT_ASSERT_EQUAL(std::string("s:u b:58 t:1"), - nodeState->toString(false)); - // With correct wanted state we should not get response right away - cmd.reset(new api::GetNodeStateCommand( - lib::NodeState::UP(new NodeState("s:u b:58 t:1", &NodeType::STORAGE)))); + ASSERT_EQ(api::MessageType::GETNODESTATE_REPLY, reply->getType()); + nodeState = std::make_unique( + dynamic_cast(*reply).getNodeState()); + EXPECT_EQ("s:u b:58 t:1", nodeState->toString(false)); + // With correct wanted state we should not get response right away + cmd = std::make_shared( + std::make_unique("s:u b:58 t:1", &NodeType::STORAGE)); _upper->sendDown(cmd); - CPPUNIT_ASSERT_EQUAL(size_t(0), _upper->getNumReplies()); - // But when we update state, we get the reply + ASSERT_EQ(size_t(0), _upper->getNumReplies()); + // But when we update state, we get the reply { NodeStateUpdater::Lock::SP lock(_manager->grabStateChangeLock()); NodeState ns(*_manager->getReportedNodeState()); @@ -222,16 +191,14 @@ StateManagerTest::testReportedNodeState() } GET_ONLY_OK_REPLY(reply); - CPPUNIT_ASSERT_EQUAL(api::MessageType::GETNODESTATE_REPLY, - reply->getType()); - nodeState.reset(new NodeState( - dynamic_cast(*reply).getNodeState())); - CPPUNIT_ASSERT_EQUAL(std::string("s:s b:58 t:1 m:Stopping\\x20node"), - nodeState->toString(false)); - - // Removing state listener, it stops getting updates + ASSERT_EQ(api::MessageType::GETNODESTATE_REPLY, reply->getType()); + nodeState = std::make_unique( + dynamic_cast(*reply).getNodeState()); + EXPECT_EQ("s:s b:58 t:1 m:Stopping\\x20node", nodeState->toString(false)); + + // Removing state listener, it stops getting updates _manager->removeStateListener(stateListener); - // Do another update which listener should not get.. + // Do another update which listener should not get.. { NodeStateUpdater::Lock::SP lock(_manager->grabStateChangeLock()); NodeState ns(*_manager->getReportedNodeState()); @@ -241,35 +208,34 @@ StateManagerTest::testReportedNodeState() std::string expectedEvents = "s:i b:58 i:0 t:1 -> s:u b:58 t:1\n" "s:u b:58 t:1 -> s:s b:58 t:1 m:Stopping\\x20node\n"; - CPPUNIT_ASSERT_EQUAL(expectedEvents, stateListener.ost.str()); + EXPECT_EQ(expectedEvents, stateListener.ost.str()); } -void StateManagerTest::current_cluster_state_version_is_included_in_host_info_json() { +TEST_F(StateManagerTest, current_cluster_state_version_is_included_in_host_info_json) { force_current_cluster_state_version(123); - std::string nodeInfoString(_manager->getNodeInfo()); + std::string nodeInfoString = get_node_info(); vespalib::Memory goldenMemory(nodeInfoString); vespalib::Slime nodeInfo; vespalib::slime::JsonFormat::decode(nodeInfoString, nodeInfo); - vespalib::slime::Symbol lookupSymbol = - nodeInfo.lookup("cluster-state-version"); + vespalib::slime::Symbol lookupSymbol = nodeInfo.lookup("cluster-state-version"); if (lookupSymbol.undefined()) { - CPPUNIT_FAIL("No cluster-state-version was found in the node info"); + FAIL() << "No cluster-state-version was found in the node info"; } auto& cursor = nodeInfo.get(); auto& clusterStateVersionCursor = cursor["cluster-state-version"]; if (!clusterStateVersionCursor.valid()) { - CPPUNIT_FAIL("No cluster-state-version was found in the node info"); + FAIL() << "No cluster-state-version was found in the node info"; } if (clusterStateVersionCursor.type().getId() != vespalib::slime::LONG::ID) { - CPPUNIT_FAIL("No cluster-state-version was found in the node info"); + FAIL() << "No cluster-state-version was found in the node info"; } int version = clusterStateVersionCursor.asLong(); - CPPUNIT_ASSERT_EQUAL(123, version); + EXPECT_EQ(123, version); } void StateManagerTest::mark_reported_node_state_up() { @@ -286,10 +252,10 @@ void StateManagerTest::send_down_get_node_state_request(uint16_t controller_inde } void StateManagerTest::assert_ok_get_node_state_reply_sent_and_clear() { - CPPUNIT_ASSERT_EQUAL(size_t(1), _upper->getNumReplies()); + ASSERT_EQ(1, _upper->getNumReplies()); std::shared_ptr reply; GET_ONLY_OK_REPLY(reply); // Implicitly clears messages from _upper - CPPUNIT_ASSERT_EQUAL(api::MessageType::GETNODESTATE_REPLY, reply->getType()); + ASSERT_EQ(api::MessageType::GETNODESTATE_REPLY, reply->getType()); } void StateManagerTest::clear_sent_replies() { @@ -299,11 +265,11 @@ void StateManagerTest::clear_sent_replies() { void StateManagerTest::mark_reply_observed_from_n_controllers(uint16_t n) { for (uint16_t i = 0; i < n; ++i) { send_down_get_node_state_request(i); - assert_ok_get_node_state_reply_sent_and_clear(); + ASSERT_NO_FATAL_FAILURE(assert_ok_get_node_state_reply_sent_and_clear()); } } -void StateManagerTest::can_explicitly_send_get_node_state_reply() { +TEST_F(StateManagerTest, can_explicitly_send_get_node_state_reply) { mark_reported_node_state_up(); // Must "pre-trigger" that a controller has already received a GetNodeState // reply, or an immediate reply will be sent by default when the first request @@ -311,13 +277,13 @@ void StateManagerTest::can_explicitly_send_get_node_state_reply() { mark_reply_observed_from_n_controllers(1); send_down_get_node_state_request(0); - CPPUNIT_ASSERT_EQUAL(size_t(0), _upper->getNumReplies()); + ASSERT_EQ(0, _upper->getNumReplies()); _manager->immediately_send_get_node_state_replies(); - assert_ok_get_node_state_reply_sent_and_clear(); + ASSERT_NO_FATAL_FAILURE(assert_ok_get_node_state_reply_sent_and_clear()); } -void StateManagerTest::explicit_node_state_replying_without_pending_request_immediately_replies_on_next_request() { +TEST_F(StateManagerTest, explicit_node_state_replying_without_pending_request_immediately_replies_on_next_request) { mark_reported_node_state_up(); mark_reply_observed_from_n_controllers(1); @@ -325,13 +291,13 @@ void StateManagerTest::explicit_node_state_replying_without_pending_request_imme _manager->immediately_send_get_node_state_replies(); send_down_get_node_state_request(0); - assert_ok_get_node_state_reply_sent_and_clear(); + ASSERT_NO_FATAL_FAILURE(assert_ok_get_node_state_reply_sent_and_clear()); // Sending a new request should now _not_ immediately receive a reply send_down_get_node_state_request(0); - CPPUNIT_ASSERT_EQUAL(size_t(0), _upper->getNumReplies()); + ASSERT_EQ(0, _upper->getNumReplies()); } -void StateManagerTest::immediate_node_state_replying_is_tracked_per_controller() { +TEST_F(StateManagerTest, immediate_node_state_replying_is_tracked_per_controller) { mark_reported_node_state_up(); mark_reply_observed_from_n_controllers(3); @@ -340,17 +306,17 @@ void StateManagerTest::immediate_node_state_replying_is_tracked_per_controller() send_down_get_node_state_request(0); send_down_get_node_state_request(1); send_down_get_node_state_request(2); - CPPUNIT_ASSERT_EQUAL(size_t(3), _upper->getNumReplies()); + ASSERT_EQ(3, _upper->getNumReplies()); clear_sent_replies(); // Sending a new request should now _not_ immediately receive a reply send_down_get_node_state_request(0); send_down_get_node_state_request(1); send_down_get_node_state_request(2); - CPPUNIT_ASSERT_EQUAL(size_t(0), _upper->getNumReplies()); + ASSERT_EQ(0, _upper->getNumReplies()); } -void StateManagerTest::activation_command_is_bounced_with_current_cluster_state_version() { +TEST_F(StateManagerTest, activation_command_is_bounced_with_current_cluster_state_version) { force_current_cluster_state_version(12345); auto cmd = std::make_shared(12340); @@ -358,13 +324,13 @@ void StateManagerTest::activation_command_is_bounced_with_current_cluster_state_ cmd->setSourceIndex(0); _upper->sendDown(cmd); - CPPUNIT_ASSERT_EQUAL(size_t(1), _upper->getNumReplies()); + ASSERT_EQ(1, _upper->getNumReplies()); std::shared_ptr reply; GET_ONLY_OK_REPLY(reply); // Implicitly clears messages from _upper - CPPUNIT_ASSERT_EQUAL(api::MessageType::ACTIVATE_CLUSTER_STATE_VERSION_REPLY, reply->getType()); + ASSERT_EQ(api::MessageType::ACTIVATE_CLUSTER_STATE_VERSION_REPLY, reply->getType()); auto& activate_reply = dynamic_cast(*reply); - CPPUNIT_ASSERT_EQUAL(uint32_t(12340), activate_reply.activateVersion()); - CPPUNIT_ASSERT_EQUAL(uint32_t(12345), activate_reply.actualVersion()); + EXPECT_EQ(12340, activate_reply.activateVersion()); + EXPECT_EQ(12345, activate_reply.actualVersion()); } } // storage -- cgit v1.2.3