summaryrefslogtreecommitdiffstats
path: root/messagebus
diff options
context:
space:
mode:
Diffstat (limited to 'messagebus')
-rw-r--r--messagebus/src/tests/routing/CMakeLists.txt1
-rw-r--r--messagebus/src/tests/routing/routing.cpp579
-rw-r--r--messagebus/src/tests/routingcontext/CMakeLists.txt1
-rw-r--r--messagebus/src/tests/routingcontext/routingcontext.cpp74
-rw-r--r--messagebus/src/tests/routingspec/CMakeLists.txt1
-rw-r--r--messagebus/src/tests/routingspec/routingspec.cpp206
-rw-r--r--messagebus/src/tests/sourcesession/CMakeLists.txt1
-rw-r--r--messagebus/src/tests/sourcesession/sourcesession.cpp56
-rw-r--r--messagebus/src/tests/throttling/CMakeLists.txt1
-rw-r--r--messagebus/src/tests/throttling/throttling.cpp114
10 files changed, 444 insertions, 590 deletions
diff --git a/messagebus/src/tests/routing/CMakeLists.txt b/messagebus/src/tests/routing/CMakeLists.txt
index 68e466ceff6..6b013f7b9cc 100644
--- a/messagebus/src/tests/routing/CMakeLists.txt
+++ b/messagebus/src/tests/routing/CMakeLists.txt
@@ -5,5 +5,6 @@ vespa_add_executable(messagebus_routing_test_app TEST
DEPENDS
messagebus_messagebus-test
messagebus
+ GTest::gtest
)
vespa_add_test(NAME messagebus_routing_test_app COMMAND messagebus_routing_test_app)
diff --git a/messagebus/src/tests/routing/routing.cpp b/messagebus/src/tests/routing/routing.cpp
index b459f093e4c..f37032e18e7 100644
--- a/messagebus/src/tests/routing/routing.cpp
+++ b/messagebus/src/tests/routing/routing.cpp
@@ -11,7 +11,7 @@
#include <vespa/messagebus/testlib/slobrok.h>
#include <vespa/messagebus/testlib/testserver.h>
#include <vespa/vespalib/component/vtag.h>
-#include <vespa/vespalib/testkit/testapp.h>
+#include <vespa/vespalib/gtest/gtest.h>
#include <vespa/log/log.h>
@@ -330,59 +330,59 @@ public:
mergeFromChild, mergeError, mergeException);
}
- static MyPolicyFactory::SP
- newSelectAndMerge(const string &select)
+ static MyPolicyFactory::SP
+ newSelectAndMerge(const string &select)
{
return newInstance(select, ErrorCode::NONE, false, true, ErrorCode::NONE, false);
}
- static MyPolicyFactory::SP
- newEmptySelection()
+ static MyPolicyFactory::SP
+ newEmptySelection()
{
return newInstance("", ErrorCode::NONE, false, false, ErrorCode::NONE, false);
}
- static MyPolicyFactory::SP
+ static MyPolicyFactory::SP
newSelectError(uint32_t errCode)
{
return newInstance("", errCode, false, false, ErrorCode::NONE, false);
}
- static MyPolicyFactory::SP
- newSelectException()
+ static MyPolicyFactory::SP
+ newSelectException()
{
return newInstance("", ErrorCode::NONE, true, false, ErrorCode::NONE, false);
}
- static MyPolicyFactory::SP
- newSelectAndThrow(const string &select)
+ static MyPolicyFactory::SP
+ newSelectAndThrow(const string &select)
{
return newInstance(select, ErrorCode::NONE, true, false, ErrorCode::NONE, false);
}
- static MyPolicyFactory::SP
- newEmptyMerge(const string &select)
+ static MyPolicyFactory::SP
+ newEmptyMerge(const string &select)
{
return newInstance(select, ErrorCode::NONE, false, false, ErrorCode::NONE, false);
}
- static MyPolicyFactory::SP
- newMergeError(const string &select, int errCode)
+ static MyPolicyFactory::SP
+ newMergeError(const string &select, int errCode)
{
return newInstance(select, ErrorCode::NONE, false, false, errCode, false);
}
- static MyPolicyFactory::SP
- newMergeException(const string &select)
+ static MyPolicyFactory::SP
+ newMergeException(const string &select)
{
return newInstance(select, ErrorCode::NONE, false, false, ErrorCode::NONE, true);
}
- static MyPolicyFactory::SP
+ static MyPolicyFactory::SP
newMergeAndThrow(const string &select)
{
return newInstance(select, ErrorCode::NONE, false, true, ErrorCode::NONE, true);
- }
+ }
};
MyPolicyFactory::MyPolicyFactory(const string &selectRoute, uint32_t &selectError, bool selectException,
@@ -400,7 +400,7 @@ MyPolicyFactory::~MyPolicyFactory() = default;
class MyPolicy : public IRoutingPolicy {
private:
const MyPolicyFactory &_parent;
-
+
public:
explicit MyPolicy(const MyPolicyFactory &parent) :
_parent(parent)
@@ -465,76 +465,6 @@ public:
bool start();
};
-class Test : public vespalib::TestApp {
-private:
- Message::UP createMessage(const string &msg, uint32_t level = 9);
- void setupRouting(TestData &data, RoutingTableSpec && spec);
- void setupPolicy(TestData &data, const string &policyName,
- SimpleProtocol::IPolicyFactory::SP policy);
- static bool testAcknowledge(TestData &data);
- bool testSend(TestData &data, const string &route, uint32_t level = 9);
- bool testTrace(TestData &data, const std::vector<string> &expected);
- bool testTrace(const std::vector<string> &expected, const Trace &trace);
-
- static const duration RECEPTOR_TIMEOUT;
-
-public:
- int Main() override;
- void testNoRoutingTable(TestData &data);
- void testUnknownRoute(TestData &data);
- void testNoRoute(TestData &data);
- void testRecognizeHopName(TestData &data);
- void testRecognizeRouteDirective(TestData &data);
- void testRecognizeRouteName(TestData &data);
- void testHopResolutionOverflow(TestData &data);
- void testRouteResolutionOverflow(TestData &data);
- void testInsertRoute(TestData &data);
- void testErrorDirective(TestData &data);
- void testSelectError(TestData &data);
- void testSelectNone(TestData &data);
- void testSelectOne(TestData &data);
- void testResend1(TestData &data);
- void testResend2(TestData &data);
- void testNoResend(TestData &data);
- void testSelectOnResend(TestData &data);
- void testNoSelectOnResend(TestData &data);
- void testCanConsumeError(TestData &data);
- void testCantConsumeError(TestData &data);
- void testNestedPolicies(TestData &data);
- void testRemoveReply(TestData &data);
- void testSetReply(TestData &data);
- void testResendSetAndReuseReply(TestData &data);
- void testResendSetAndRemoveReply(TestData &data);
- void testHopIgnoresReply(TestData &data);
- void testHopBlueprintIgnoresReply(TestData &data);
- void testAcceptEmptyRoute(TestData &data);
- void testAbortOnlyActiveNodes(TestData &data);
- void testTimeout(TestData &data);
- void testUnknownPolicy(TestData &data);
- void testSelectException(TestData &data);
- void testMergeException(TestData &data);
-
- void requireThatIgnoreFlagPersistsThroughHopLookup(TestData &data);
- void requireThatIgnoreFlagPersistsThroughRouteLookup(TestData &data);
- void requireThatIgnoreFlagPersistsThroughPolicySelect(TestData &data);
- void requireThatIgnoreFlagIsSerializedWithMessage(TestData &data);
- void requireThatIgnoreFlagDoesNotInterfere(TestData &data);
- void requireThatEmptySelectionCanBeIgnored(TestData &data);
- void requireThatSelectErrorCanBeIgnored(TestData &data);
- void requireThatSelectExceptionCanBeIgnored(TestData &data);
- void requireThatSelectAndThrowCanBeIgnored(TestData &data);
- void requireThatEmptyMergeCanBeIgnored(TestData &data);
- void requireThatMergeErrorCanBeIgnored(TestData &data);
- void requireThatMergeExceptionCanBeIgnored(TestData &data);
- void requireThatMergeAndThrowCanBeIgnored(TestData &data);
- void requireThatAllocServiceCanBeIgnored(TestData &data);
- void requireThatDepthLimitCanBeIgnored(TestData &data);
-};
-
-const duration Test::RECEPTOR_TIMEOUT = 120s;
-
-TEST_APPHOOK(Test);
-
TestData::TestData() :
_slobrok(),
_retryPolicy(std::make_shared<RetryTransientErrorsPolicy>()),
@@ -577,22 +507,81 @@ TestData::start()
return true;
}
+class RoutingTest : public testing::Test {
+protected:
+ static const duration RECEPTOR_TIMEOUT;
+ static std::shared_ptr<TestData> _data;
+ static bool _force_teardown;
+ RoutingTest();
+ ~RoutingTest() override;
+ static void SetUpTestSuite();
+ static void TearDownTestSuite();
+ void SetUp() override;
+ void TearDown() override;
+ static Message::UP createMessage(const string &msg, uint32_t level = 9);
+ static void setupRouting(TestData &data, RoutingTableSpec && spec);
+ static void setupPolicy(TestData &data, const string &policyName,
+ SimpleProtocol::IPolicyFactory::SP policy);
+ static bool testAcknowledge(TestData &data);
+ static bool testSend(TestData &data, const string &route, uint32_t level = 9);
+ static bool testTrace(TestData &data, const std::vector<string> &expected);
+ static bool testTrace(const std::vector<string> &expected, const Trace &trace);
+};
+
+const duration RoutingTest::RECEPTOR_TIMEOUT = 120s;
+std::shared_ptr<TestData> RoutingTest::_data;
+bool RoutingTest::_force_teardown = false;
+
+RoutingTest::RoutingTest() = default;
+RoutingTest::~RoutingTest() = default;
+
+void
+RoutingTest::SetUpTestSuite()
+{
+ _data = std::make_shared<TestData>();
+ ASSERT_TRUE(_data->start());
+}
+
+void
+RoutingTest::TearDownTestSuite()
+{
+ _data.reset();
+}
+
+void
+RoutingTest::SetUp()
+{
+ if (!_data) {
+ _data = std::make_shared<TestData>();
+ ASSERT_TRUE(_data->start());
+ }
+}
+
+void
+RoutingTest::TearDown()
+{
+ if (_force_teardown) {
+ _force_teardown = false;
+ _data.reset();
+ }
+}
+
Message::UP
-Test::createMessage(const string &msg, uint32_t level)
+RoutingTest::createMessage(const string &msg, uint32_t level)
{
auto ret = std::make_unique<SimpleMessage>(msg);
ret->getTrace().setLevel(level);
return ret;
}
-void
-Test::setupRouting(TestData &data, RoutingTableSpec && spec)
+void
+RoutingTest::setupRouting(TestData &data, RoutingTableSpec && spec)
{
data._srcServer.mb.setupRouting(RoutingSpec().addTable(std::move(spec)));
}
-void
-Test::setupPolicy(TestData &data, const string &policyName,
+void
+RoutingTest::setupPolicy(TestData &data, const string &policyName,
SimpleProtocol::IPolicyFactory::SP policy)
{
auto protocol = std::make_shared<SimpleProtocol>();
@@ -600,40 +589,45 @@ Test::setupPolicy(TestData &data, const string &policyName,
data._srcServer.mb.putProtocol(protocol);
}
-bool
-Test::testAcknowledge(TestData &data)
+bool
+RoutingTest::testAcknowledge(TestData &data)
{
Message::UP msg = data._dstHandler.getMessage(RECEPTOR_TIMEOUT);
- if (!EXPECT_TRUE(msg)) {
+ bool failed = false;
+ EXPECT_TRUE(msg) << (failed = true, "");
+ if (failed) {
return false;
}
data._dstSession->acknowledge(std::move(msg));
return true;
}
-
-bool
-Test::testSend(TestData &data, const string &route, uint32_t level)
+
+bool
+RoutingTest::testSend(TestData &data, const string &route, uint32_t level)
{
Message::UP msg = createMessage("msg", level);
msg->setRoute(Route::parse(route));
return data._srcSession->send(std::move(msg)).isAccepted();
}
-bool
-Test::testTrace(TestData &data, const std::vector<string> &expected)
+bool
+RoutingTest::testTrace(TestData &data, const std::vector<string> &expected)
{
Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT);
- if (!EXPECT_TRUE(reply)) {
+ bool failed = false;
+ EXPECT_TRUE(reply) << (failed = true, "");
+ if (failed) {
return false;
}
- if (!EXPECT_FALSE(reply->hasErrors())) {
+ EXPECT_FALSE(reply->hasErrors()) << (failed = true, "");
+ if (failed) {
return false;
}
return testTrace(expected, reply->getTrace());
}
bool
-Test::testTrace(const std::vector<string> &expected, const Trace &trace)
+RoutingTest::testTrace(const std::vector<string> &expected, const Trace &trace)
{
const string& version = vespalib::Vtag::currentVersion.toString();
string actual = trace.toString();
@@ -646,13 +640,17 @@ Test::testTrace(const std::vector<string> &expected, const Trace &trace)
}
if (line[0] == '-') {
string str = line.substr(1);
- if (!EXPECT_TRUE(actual.find(str, pos) == string::npos)) {
+ bool failed = false;
+ EXPECT_TRUE(actual.find(str, pos) == string::npos) << (failed = true, "");
+ if (failed) {
LOG(error, "Line %d '%s' not expected.", i, str.c_str());
return false;
}
} else {
pos = actual.find(line, pos);
- if (!EXPECT_TRUE(pos != string::npos)) {
+ bool failed = false;
+ EXPECT_TRUE(pos != string::npos) << (failed = true, "");
+ if (failed) {
LOG(error, "Line %d '%s' missing.", i, line.c_str());
return false;
}
@@ -662,110 +660,47 @@ Test::testTrace(const std::vector<string> &expected, const Trace &trace)
return true;
}
-int
-Test::Main()
-{
- TEST_INIT("routing_test");
-
- TestData data;
- ASSERT_TRUE(data.start());
-
- testNoRoutingTable(data); TEST_FLUSH();
- testUnknownRoute(data); TEST_FLUSH();
- testNoRoute(data); TEST_FLUSH();
- testRecognizeHopName(data); TEST_FLUSH();
- testRecognizeRouteDirective(data); TEST_FLUSH();
- testRecognizeRouteName(data); TEST_FLUSH();
- testHopResolutionOverflow(data); TEST_FLUSH();
- testRouteResolutionOverflow(data); TEST_FLUSH();
- testInsertRoute(data); TEST_FLUSH();
- testErrorDirective(data); TEST_FLUSH();
- testSelectError(data); TEST_FLUSH();
- testSelectNone(data); TEST_FLUSH();
- testSelectOne(data); TEST_FLUSH();
- testResend1(data); TEST_FLUSH();
- testResend2(data); TEST_FLUSH();
- testNoResend(data); TEST_FLUSH();
- testSelectOnResend(data); TEST_FLUSH();
- testNoSelectOnResend(data); TEST_FLUSH();
- testCanConsumeError(data); TEST_FLUSH();
- testCantConsumeError(data); TEST_FLUSH();
- testNestedPolicies(data); TEST_FLUSH();
- testRemoveReply(data); TEST_FLUSH();
- testSetReply(data); TEST_FLUSH();
- testResendSetAndReuseReply(data); TEST_FLUSH();
- testResendSetAndRemoveReply(data); TEST_FLUSH();
- testHopIgnoresReply(data); TEST_FLUSH();
- testHopBlueprintIgnoresReply(data); TEST_FLUSH();
- testAcceptEmptyRoute(data); TEST_FLUSH();
- testAbortOnlyActiveNodes(data); TEST_FLUSH();
- testUnknownPolicy(data); TEST_FLUSH();
- testSelectException(data); TEST_FLUSH();
- testMergeException(data); TEST_FLUSH();
-
- requireThatIgnoreFlagPersistsThroughHopLookup(data); TEST_FLUSH();
- requireThatIgnoreFlagPersistsThroughRouteLookup(data); TEST_FLUSH();
- requireThatIgnoreFlagPersistsThroughPolicySelect(data); TEST_FLUSH();
- requireThatIgnoreFlagIsSerializedWithMessage(data); TEST_FLUSH();
- requireThatIgnoreFlagDoesNotInterfere(data); TEST_FLUSH();
- requireThatEmptySelectionCanBeIgnored(data); TEST_FLUSH();
- requireThatSelectErrorCanBeIgnored(data); TEST_FLUSH();
- requireThatSelectExceptionCanBeIgnored(data); TEST_FLUSH();
- requireThatSelectAndThrowCanBeIgnored(data); TEST_FLUSH();
- requireThatEmptyMergeCanBeIgnored(data); TEST_FLUSH();
- requireThatMergeErrorCanBeIgnored(data); TEST_FLUSH();
- requireThatMergeExceptionCanBeIgnored(data); TEST_FLUSH();
- requireThatMergeAndThrowCanBeIgnored(data); TEST_FLUSH();
- requireThatAllocServiceCanBeIgnored(data); TEST_FLUSH();
- requireThatDepthLimitCanBeIgnored(data); TEST_FLUSH();
-
- // This needs to be last because it changes timeouts:
- testTimeout(data); TEST_FLUSH();
-
- TEST_DONE();
-}
-
////////////////////////////////////////////////////////////////////////////////
//
// Tests
//
////////////////////////////////////////////////////////////////////////////////
-void
-Test::testNoRoutingTable(TestData &data)
+TEST_F(RoutingTest, test_no_routing_table)
{
+ auto& data = *_data;
Result res = data._srcSession->send(createMessage("msg"), "foo");
EXPECT_FALSE(res.isAccepted());
- EXPECT_EQUAL((uint32_t)ErrorCode::ILLEGAL_ROUTE, res.getError().getCode());
+ EXPECT_EQ((uint32_t)ErrorCode::ILLEGAL_ROUTE, res.getError().getCode());
Message::UP msg = res.getMessage();
EXPECT_TRUE(msg);
}
-void
-Test::testUnknownRoute(TestData &data)
+TEST_F(RoutingTest, test_unknown_route)
{
+ auto& data = *_data;
data._srcServer.mb.setupRouting(RoutingSpec().addTable(RoutingTableSpec(SimpleProtocol::NAME)
.addHop(HopSpec("foo", "bar"))));
Result res = data._srcSession->send(createMessage("msg"), "baz");
EXPECT_FALSE(res.isAccepted());
- EXPECT_EQUAL((uint32_t)ErrorCode::ILLEGAL_ROUTE, res.getError().getCode());
+ EXPECT_EQ((uint32_t)ErrorCode::ILLEGAL_ROUTE, res.getError().getCode());
Message::UP msg = res.getMessage();
EXPECT_TRUE(msg);
}
-void
-Test::testNoRoute(TestData &data)
+TEST_F(RoutingTest, test_no_route)
{
+ auto& data = *_data;
EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route()).isAccepted());
Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT);
ASSERT_TRUE(reply);
- EXPECT_EQUAL(1u, reply->getNumErrors());
- EXPECT_EQUAL((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode());
+ EXPECT_EQ(1u, reply->getNumErrors());
+ EXPECT_EQ((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode());
}
-void
-Test::testRecognizeHopName(TestData &data)
+TEST_F(RoutingTest, test_recognize_hop_name)
{
+ auto& data = *_data;
data._srcServer.mb.setupRouting(RoutingSpec().addTable(RoutingTableSpec(SimpleProtocol::NAME)
.addHop(HopSpec("dst", "dst/session"))));
EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("dst")).isAccepted());
@@ -777,9 +712,9 @@ Test::testRecognizeHopName(TestData &data)
EXPECT_FALSE(reply->hasErrors());
}
-void
-Test::testRecognizeRouteDirective(TestData &data)
+TEST_F(RoutingTest, test_recognize_route_directive)
{
+ auto& data = *_data;
data._srcServer.mb.setupRouting(RoutingSpec().addTable(RoutingTableSpec(SimpleProtocol::NAME)
.addRoute(RouteSpec("dst").addHop("dst/session"))
.addHop(HopSpec("dir", "route:dst"))));
@@ -792,9 +727,9 @@ Test::testRecognizeRouteDirective(TestData &data)
EXPECT_FALSE(reply->hasErrors());
}
-void
-Test::testRecognizeRouteName(TestData &data)
+TEST_F(RoutingTest, test_recognize_route_name)
{
+ auto& data = *_data;
data._srcServer.mb.setupRouting(RoutingSpec().addTable(RoutingTableSpec(SimpleProtocol::NAME)
.addRoute(RouteSpec("dst").addHop("dst/session"))));
EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("dst")).isAccepted());
@@ -806,64 +741,64 @@ Test::testRecognizeRouteName(TestData &data)
EXPECT_FALSE(reply->hasErrors());
}
-void
-Test::testHopResolutionOverflow(TestData &data)
+TEST_F(RoutingTest, test_hop_resolution_overflow)
{
+ auto& data = *_data;
data._srcServer.mb.setupRouting(RoutingSpec().addTable(RoutingTableSpec(SimpleProtocol::NAME)
.addHop(HopSpec("foo", "bar"))
.addHop(HopSpec("bar", "foo"))));
EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("foo")).isAccepted());
Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT);
ASSERT_TRUE(reply);
- EXPECT_EQUAL(1u, reply->getNumErrors());
- EXPECT_EQUAL((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode());
+ EXPECT_EQ(1u, reply->getNumErrors());
+ EXPECT_EQ((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode());
}
-void
-Test::testRouteResolutionOverflow(TestData &data)
+TEST_F(RoutingTest, test_route_resolution_overflow)
{
+ auto& data = *_data;
data._srcServer.mb.setupRouting(RoutingSpec().addTable(RoutingTableSpec(SimpleProtocol::NAME)
.addRoute(RouteSpec("foo").addHop("route:foo"))));
EXPECT_TRUE(data._srcSession->send(createMessage("msg"), "foo").isAccepted());
Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT);
ASSERT_TRUE(reply);
- EXPECT_EQUAL(1u, reply->getNumErrors());
- EXPECT_EQUAL((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode());
+ EXPECT_EQ(1u, reply->getNumErrors());
+ EXPECT_EQ((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode());
}
-void
-Test::testInsertRoute(TestData &data)
+TEST_F(RoutingTest, test_insert_route)
{
+ auto& data = *_data;
data._srcServer.mb.setupRouting(RoutingSpec().addTable(RoutingTableSpec(SimpleProtocol::NAME)
.addRoute(RouteSpec("foo").addHop("dst/session").addHop("bar"))));
EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("route:foo baz")).isAccepted());
Message::UP msg = data._dstHandler.getMessage(RECEPTOR_TIMEOUT);
ASSERT_TRUE(msg);
- EXPECT_EQUAL(2u, msg->getRoute().getNumHops());
- EXPECT_EQUAL("bar", msg->getRoute().getHop(0).toString());
- EXPECT_EQUAL("baz", msg->getRoute().getHop(1).toString());
+ EXPECT_EQ(2u, msg->getRoute().getNumHops());
+ EXPECT_EQ("bar", msg->getRoute().getHop(0).toString());
+ EXPECT_EQ("baz", msg->getRoute().getHop(1).toString());
data._dstSession->acknowledge(std::move(msg));
Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT);
ASSERT_TRUE(reply);
EXPECT_FALSE(reply->hasErrors());
}
-void
-Test::testErrorDirective(TestData &data)
+TEST_F(RoutingTest, test_error_directive)
{
+ auto& data = *_data;
Route route = Route::parse("foo/bar/baz");
route.getHop(0).setDirective(1, std::make_shared<ErrorDirective>("err"));
EXPECT_TRUE(data._srcSession->send(createMessage("msg"), route).isAccepted());
Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT);
ASSERT_TRUE(reply);
- EXPECT_EQUAL(1u, reply->getNumErrors());
- EXPECT_EQUAL((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode());
- EXPECT_EQUAL("err", reply->getError(0).getMessage());
+ EXPECT_EQ(1u, reply->getNumErrors());
+ EXPECT_EQ((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode());
+ EXPECT_EQ("err", reply->getError(0).getMessage());
}
-void
-Test::testSelectError(TestData &data)
+TEST_F(RoutingTest, test_select_error)
{
+ auto& data = *_data;
auto protocol = std::make_shared<SimpleProtocol>();
protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>());
data._srcServer.mb.putProtocol(protocol);
@@ -872,26 +807,26 @@ Test::testSelectError(TestData &data)
ASSERT_TRUE(reply);
LOG(info, "testSelectError trace=%s", reply->getTrace().toString().c_str());
LOG(info, "testSelectError error=%s", reply->getError(0).toString().c_str());
- EXPECT_EQUAL(1u, reply->getNumErrors());
- EXPECT_EQUAL((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode());
+ EXPECT_EQ(1u, reply->getNumErrors());
+ EXPECT_EQ((uint32_t)ErrorCode::ILLEGAL_ROUTE, reply->getError(0).getCode());
}
-void
-Test::testSelectNone(TestData &data)
+TEST_F(RoutingTest, test_select_none)
{
+ auto& data = *_data;
auto protocol = std::make_shared<SimpleProtocol>();
protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>());
data._srcServer.mb.putProtocol(protocol);
EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("[Custom]")).isAccepted());
Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT);
ASSERT_TRUE(reply);
- EXPECT_EQUAL(1u, reply->getNumErrors());
- EXPECT_EQUAL((uint32_t)ErrorCode::NO_SERVICES_FOR_ROUTE, reply->getError(0).getCode());
+ EXPECT_EQ(1u, reply->getNumErrors());
+ EXPECT_EQ((uint32_t)ErrorCode::NO_SERVICES_FOR_ROUTE, reply->getError(0).getCode());
}
-void
-Test::testSelectOne(TestData &data)
+TEST_F(RoutingTest, test_select_one)
{
+ auto& data = *_data;
auto protocol = std::make_shared<SimpleProtocol>();
protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>());
data._srcServer.mb.putProtocol(protocol);
@@ -904,9 +839,9 @@ Test::testSelectOne(TestData &data)
EXPECT_FALSE(reply->hasErrors());
}
-void
-Test::testResend1(TestData &data)
+TEST_F(RoutingTest, test_resend_1)
{
+ auto& data = *_data;
data._retryPolicy->setEnabled(true);
EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("dst/session")).isAccepted());
Message::UP msg = data._dstHandler.getMessage(RECEPTOR_TIMEOUT);
@@ -935,9 +870,9 @@ Test::testResend1(TestData &data)
reply->getTrace()));
}
-void
-Test::testResend2(TestData &data)
+TEST_F(RoutingTest, test_resend_2)
{
+ auto& data = *_data;
auto protocol = std::make_shared<SimpleProtocol>();
protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>());
data._srcServer.mb.putProtocol(protocol);
@@ -1003,9 +938,9 @@ Test::testResend2(TestData &data)
reply->getTrace()));
}
-void
-Test::testNoResend(TestData &data)
+TEST_F(RoutingTest, test_no_resend)
{
+ auto& data = *_data;
data._retryPolicy->setEnabled(false);
EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("dst/session")).isAccepted());
Message::UP msg = data._dstHandler.getMessage(RECEPTOR_TIMEOUT);
@@ -1016,13 +951,13 @@ Test::testNoResend(TestData &data)
data._dstSession->reply(std::move(reply));
reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT);
ASSERT_TRUE(reply);
- EXPECT_EQUAL(1u, reply->getNumErrors());
- EXPECT_EQUAL((uint32_t)ErrorCode::APP_TRANSIENT_ERROR, reply->getError(0).getCode());
+ EXPECT_EQ(1u, reply->getNumErrors());
+ EXPECT_EQ((uint32_t)ErrorCode::APP_TRANSIENT_ERROR, reply->getError(0).getCode());
}
-void
-Test::testSelectOnResend(TestData &data)
+TEST_F(RoutingTest, test_select_on_resend)
{
+ auto& data = *_data;
auto protocol = std::make_shared<SimpleProtocol>();
protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>());
data._srcServer.mb.putProtocol(protocol);
@@ -1051,9 +986,9 @@ Test::testSelectOnResend(TestData &data)
reply->getTrace()));
}
-void
-Test::testNoSelectOnResend(TestData &data)
+TEST_F(RoutingTest, test_no_select_on_resend)
{
+ auto& data = *_data;
auto protocol = std::make_shared<SimpleProtocol>();
protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>(false));
data._srcServer.mb.putProtocol(protocol);
@@ -1082,9 +1017,9 @@ Test::testNoSelectOnResend(TestData &data)
reply->getTrace()));
}
-void
-Test::testCanConsumeError(TestData &data)
+TEST_F(RoutingTest, test_can_consume_error)
{
+ auto& data = *_data;
auto protocol = std::make_shared<SimpleProtocol>();
protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>(true, ErrorCode::NO_ADDRESS_FOR_SERVICE));
data._srcServer.mb.putProtocol(protocol);
@@ -1095,8 +1030,8 @@ Test::testCanConsumeError(TestData &data)
data._dstSession->acknowledge(std::move(msg));
Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT);
ASSERT_TRUE(reply);
- EXPECT_EQUAL(1u, reply->getNumErrors());
- EXPECT_EQUAL((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, reply->getError(0).getCode());
+ EXPECT_EQ(1u, reply->getNumErrors());
+ EXPECT_EQ((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, reply->getError(0).getCode());
EXPECT_TRUE(testTrace(StringList()
.add("Selecting { 'dst/session', 'dst/unknown' }.")
.add("[NO_ADDRESS_FOR_SERVICE @ localhost]")
@@ -1105,9 +1040,9 @@ Test::testCanConsumeError(TestData &data)
reply->getTrace()));
}
-void
-Test::testCantConsumeError(TestData &data)
+TEST_F(RoutingTest, test_cant_consume_error)
{
+ auto& data = *_data;
auto protocol = std::make_shared<SimpleProtocol>();
protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>());
data._srcServer.mb.putProtocol(protocol);
@@ -1116,8 +1051,8 @@ Test::testCantConsumeError(TestData &data)
Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT);
ASSERT_TRUE(reply);
printf("%s", reply->getTrace().toString().c_str());
- EXPECT_EQUAL(1u, reply->getNumErrors());
- EXPECT_EQUAL((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, reply->getError(0).getCode());
+ EXPECT_EQ(1u, reply->getNumErrors());
+ EXPECT_EQ((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, reply->getError(0).getCode());
EXPECT_TRUE(testTrace(StringList()
.add("Selecting { 'dst/unknown' }.")
.add("[NO_ADDRESS_FOR_SERVICE @ localhost]")
@@ -1125,9 +1060,9 @@ Test::testCantConsumeError(TestData &data)
reply->getTrace()));
}
-void
-Test::testNestedPolicies(TestData &data)
+TEST_F(RoutingTest, test_nested_policies)
{
+ auto& data = *_data;
auto protocol = std::make_shared<SimpleProtocol>();
protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>(true, ErrorCode::NO_ADDRESS_FOR_SERVICE));
data._srcServer.mb.putProtocol(protocol);
@@ -1138,13 +1073,13 @@ Test::testNestedPolicies(TestData &data)
data._dstSession->acknowledge(std::move(msg));
Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT);
ASSERT_TRUE(reply);
- EXPECT_EQUAL(1u, reply->getNumErrors());
- EXPECT_EQUAL((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, reply->getError(0).getCode());
+ EXPECT_EQ(1u, reply->getNumErrors());
+ EXPECT_EQ((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, reply->getError(0).getCode());
}
-void
-Test::testRemoveReply(TestData &data)
+TEST_F(RoutingTest, test_remove_reply)
{
+ auto& data = *_data;
auto protocol = std::make_shared<SimpleProtocol>();
protocol->addPolicyFactory("Custom", std::make_shared<RemoveReplyPolicyFactory>(true, UIntList().add(ErrorCode::NO_ADDRESS_FOR_SERVICE), 0));
data._srcServer.mb.putProtocol(protocol);
@@ -1164,9 +1099,9 @@ Test::testRemoveReply(TestData &data)
reply->getTrace()));
}
-void
-Test::testSetReply(TestData &data)
+TEST_F(RoutingTest, test_set_reply)
{
+ auto& data = *_data;
auto protocol = std::make_shared<SimpleProtocol>();
protocol->addPolicyFactory("Select", std::make_shared<CustomPolicyFactory>(true, ErrorCode::APP_FATAL_ERROR));
protocol->addPolicyFactory("SetReply", std::make_shared<SetReplyPolicyFactory>(true, UIntList().add(ErrorCode::APP_FATAL_ERROR)));
@@ -1178,14 +1113,14 @@ Test::testSetReply(TestData &data)
data._dstSession->acknowledge(std::move(msg));
Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT);
ASSERT_TRUE(reply);
- EXPECT_EQUAL(1u, reply->getNumErrors());
- EXPECT_EQUAL((uint32_t)ErrorCode::APP_FATAL_ERROR, reply->getError(0).getCode());
- EXPECT_EQUAL("foo", reply->getError(0).getMessage());
+ EXPECT_EQ(1u, reply->getNumErrors());
+ EXPECT_EQ((uint32_t)ErrorCode::APP_FATAL_ERROR, reply->getError(0).getCode());
+ EXPECT_EQ("foo", reply->getError(0).getMessage());
}
-void
-Test::testResendSetAndReuseReply(TestData &data)
+TEST_F(RoutingTest, test_resend_set_and_reuse_reply)
{
+ auto& data = *_data;
auto protocol = std::make_shared<SimpleProtocol>();
protocol->addPolicyFactory("ReuseReply", std::make_shared<ReuseReplyPolicyFactory>(false, UIntList().add(ErrorCode::APP_FATAL_ERROR)));
protocol->addPolicyFactory("SetReply", std::make_shared<SetReplyPolicyFactory>(false, UIntList().add(ErrorCode::APP_FATAL_ERROR)));
@@ -1206,9 +1141,9 @@ Test::testResendSetAndReuseReply(TestData &data)
EXPECT_FALSE(reply->hasErrors());
}
-void
-Test::testResendSetAndRemoveReply(TestData &data)
+TEST_F(RoutingTest, test_resend_set_and_remove_reply)
{
+ auto& data = *_data;
auto protocol = std::make_shared<SimpleProtocol>();
protocol->addPolicyFactory("RemoveReply", std::make_shared<RemoveReplyPolicyFactory>(false, UIntList().add(ErrorCode::APP_TRANSIENT_ERROR), 0));
protocol->addPolicyFactory("SetReply", std::make_shared<SetReplyPolicyFactory>(false, UIntList().add(ErrorCode::APP_TRANSIENT_ERROR).add(ErrorCode::APP_FATAL_ERROR)));
@@ -1220,9 +1155,9 @@ Test::testResendSetAndRemoveReply(TestData &data)
data._dstSession->acknowledge(std::move(msg));
Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT);
ASSERT_TRUE(reply);
- EXPECT_EQUAL(1u, reply->getNumErrors());
- EXPECT_EQUAL((uint32_t)ErrorCode::APP_FATAL_ERROR, reply->getError(0).getCode());
- EXPECT_EQUAL("foo", reply->getError(0).getMessage());
+ EXPECT_EQ(1u, reply->getNumErrors());
+ EXPECT_EQ((uint32_t)ErrorCode::APP_FATAL_ERROR, reply->getError(0).getCode());
+ EXPECT_EQ("foo", reply->getError(0).getMessage());
EXPECT_TRUE(testTrace(StringList()
.add("Resolving '[SetReply:foo]'.")
.add("Resolving 'dst/session'.")
@@ -1232,9 +1167,9 @@ Test::testResendSetAndRemoveReply(TestData &data)
reply->getTrace()));
}
-void
-Test::testHopIgnoresReply(TestData &data)
+TEST_F(RoutingTest, test_hop_ignores_reply)
{
+ auto& data = *_data;
EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("?dst/session")).isAccepted());
Message::UP msg = data._dstHandler.getMessage(RECEPTOR_TIMEOUT);
ASSERT_TRUE(msg);
@@ -1250,9 +1185,9 @@ Test::testHopIgnoresReply(TestData &data)
reply->getTrace()));
}
-void
-Test::testHopBlueprintIgnoresReply(TestData &data)
+TEST_F(RoutingTest, test_hop_blueprint_ignores_reply)
{
+ auto& data = *_data;
data._srcServer.mb.setupRouting(RoutingSpec().addTable(RoutingTableSpec(SimpleProtocol::NAME)
.addHop(std::move(HopSpec("foo", "dst/session").setIgnoreResult(true)))));
EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("foo")).isAccepted());
@@ -1270,22 +1205,22 @@ Test::testHopBlueprintIgnoresReply(TestData &data)
reply->getTrace()));
}
-void
-Test::testAcceptEmptyRoute(TestData &data)
+TEST_F(RoutingTest, test_accept_empty_route)
{
+ auto& data = *_data;
EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("dst/session")).isAccepted());
Message::UP msg = data._dstHandler.getMessage(RECEPTOR_TIMEOUT);
ASSERT_TRUE(msg);
const Route &route = msg->getRoute();
- EXPECT_EQUAL(0u, route.getNumHops());
+ EXPECT_EQ(0u, route.getNumHops());
data._dstSession->acknowledge(std::move(msg));
Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT);
ASSERT_TRUE(reply);
}
-void
-Test::testAbortOnlyActiveNodes(TestData &data)
+TEST_F(RoutingTest, test_abort_only_active_nodes)
{
+ auto& data = *_data;
auto protocol = std::make_shared<SimpleProtocol>();
protocol->addPolicyFactory("Custom", std::make_shared<CustomPolicyFactory>(false));
protocol->addPolicyFactory("SetReply", std::make_shared<SetReplyPolicyFactory>(false,
@@ -1297,39 +1232,39 @@ Test::testAbortOnlyActiveNodes(TestData &data)
EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("[Custom:[SetReply:foo],?bar,dst/session]")).isAccepted());
Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT);
ASSERT_TRUE(reply);
- EXPECT_EQUAL(2u, reply->getNumErrors());
- EXPECT_EQUAL((uint32_t)ErrorCode::APP_FATAL_ERROR, reply->getError(0).getCode());
- EXPECT_EQUAL((uint32_t)ErrorCode::SEND_ABORTED, reply->getError(1).getCode());
+ EXPECT_EQ(2u, reply->getNumErrors());
+ EXPECT_EQ((uint32_t)ErrorCode::APP_FATAL_ERROR, reply->getError(0).getCode());
+ EXPECT_EQ((uint32_t)ErrorCode::SEND_ABORTED, reply->getError(1).getCode());
}
-void
-Test::testUnknownPolicy(TestData &data)
+TEST_F(RoutingTest, test_unknown_policy)
{
+ auto& data = *_data;
EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("[Unknown]")).isAccepted());
Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT);
ASSERT_TRUE(reply);
- EXPECT_EQUAL(1u, reply->getNumErrors());
- EXPECT_EQUAL((uint32_t)ErrorCode::UNKNOWN_POLICY, reply->getError(0).getCode());
+ EXPECT_EQ(1u, reply->getNumErrors());
+ EXPECT_EQ((uint32_t)ErrorCode::UNKNOWN_POLICY, reply->getError(0).getCode());
}
-void
-Test::testSelectException(TestData &data)
+TEST_F(RoutingTest, test_select_exception)
{
+ auto& data = *_data;
auto protocol = std::make_shared<SimpleProtocol>();
protocol->addPolicyFactory("SelectException", std::make_shared<SelectExceptionPolicyFactory>());
data._srcServer.mb.putProtocol(protocol);
EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("[SelectException]")).isAccepted());
Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT);
ASSERT_TRUE(reply);
- EXPECT_EQUAL(1u, reply->getNumErrors());
- EXPECT_EQUAL((uint32_t)ErrorCode::POLICY_ERROR, reply->getError(0).getCode());
- EXPECT_EQUAL("Policy 'SelectException' threw an exception; {test exception}",
- reply->getError(0).getMessage());
+ EXPECT_EQ(1u, reply->getNumErrors());
+ EXPECT_EQ((uint32_t)ErrorCode::POLICY_ERROR, reply->getError(0).getCode());
+ EXPECT_EQ("Policy 'SelectException' threw an exception; {test exception}",
+ reply->getError(0).getMessage());
}
-void
-Test::testMergeException(TestData &data)
+TEST_F(RoutingTest, test_merge_exception)
{
+ auto& data = *_data;
auto protocol = std::make_shared<SimpleProtocol>();
protocol->addPolicyFactory("MergeException", std::make_shared<MergeExceptionPolicyFactory>());
data._srcServer.mb.putProtocol(protocol);
@@ -1340,157 +1275,161 @@ Test::testMergeException(TestData &data)
data._dstSession->acknowledge(std::move(msg));
Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT);
ASSERT_TRUE(reply);
- EXPECT_EQUAL(1u, reply->getNumErrors());
- EXPECT_EQUAL((uint32_t)ErrorCode::POLICY_ERROR,
+ EXPECT_EQ(1u, reply->getNumErrors());
+ EXPECT_EQ((uint32_t)ErrorCode::POLICY_ERROR,
reply->getError(0).getCode());
- EXPECT_EQUAL("Policy 'MergeException' threw an exception; {test exception}",
- reply->getError(0).getMessage());
+ EXPECT_EQ("Policy 'MergeException' threw an exception; {test exception}",
+ reply->getError(0).getMessage());
}
-void
-Test::requireThatIgnoreFlagPersistsThroughHopLookup(TestData &data)
+TEST_F(RoutingTest, require_that_ignore_flag_persists_through_hop_lookup)
{
+ auto& data = *_data;
setupRouting(data, RoutingTableSpec(SimpleProtocol::NAME).addHop(HopSpec("foo", "dst/unknown")));
ASSERT_TRUE(testSend(data, "?foo"));
ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply.")));
}
-void
-Test::requireThatIgnoreFlagPersistsThroughRouteLookup(TestData &data)
+TEST_F(RoutingTest, require_that_ignore_flag_persists_through_route_lookup)
{
+ auto& data = *_data;
setupRouting(data, RoutingTableSpec(SimpleProtocol::NAME).addRoute(RouteSpec("foo").addHop("dst/unknown")));
ASSERT_TRUE(testSend(data, "?foo"));
ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply.")));
}
-void
-Test::requireThatIgnoreFlagPersistsThroughPolicySelect(TestData &data)
+TEST_F(RoutingTest, require_that_ignore_flag_persists_through_policy_select)
{
+ auto& data = *_data;
setupPolicy(data, "Custom", MyPolicyFactory::newSelectAndMerge("dst/unknown"));
ASSERT_TRUE(testSend(data, "?[Custom]"));
ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply.")));
}
-void
-Test::requireThatIgnoreFlagIsSerializedWithMessage(TestData &data)
+TEST_F(RoutingTest, require_that_ignore_flag_is_serialized_with_message)
{
+ auto& data = *_data;
ASSERT_TRUE(testSend(data, "dst/session foo ?bar"));
Message::UP msg = data._dstHandler.getMessage(RECEPTOR_TIMEOUT);
ASSERT_TRUE(msg);
Route route = msg->getRoute();
- EXPECT_EQUAL(2u, route.getNumHops());
+ EXPECT_EQ(2u, route.getNumHops());
Hop hop = route.getHop(0);
- EXPECT_EQUAL("foo", hop.toString());
+ EXPECT_EQ("foo", hop.toString());
EXPECT_FALSE(hop.getIgnoreResult());
hop = route.getHop(1);
- EXPECT_EQUAL("?bar", hop.toString());
+ EXPECT_EQ("?bar", hop.toString());
EXPECT_TRUE(hop.getIgnoreResult());
data._dstSession->acknowledge(std::move(msg));
ASSERT_TRUE(testTrace(data, StringList().add("-Ignoring errors in reply.")));
}
-void
-Test::requireThatIgnoreFlagDoesNotInterfere(TestData &data)
+TEST_F(RoutingTest, require_that_ignore_flag_does_not_interfere)
{
+ auto& data = *_data;
setupPolicy(data, "Custom", MyPolicyFactory::newSelectAndMerge("dst/session"));
ASSERT_TRUE(testSend(data, "?[Custom]"));
ASSERT_TRUE(testTrace(data, StringList().add("-Ignoring errors in reply.")));
ASSERT_TRUE(testAcknowledge(data));
}
-
-void
-Test::requireThatEmptySelectionCanBeIgnored(TestData &data)
+
+TEST_F(RoutingTest, require_that_empty_selection_can_be_ignored)
{
+ auto& data = *_data;
setupPolicy(data, "Custom", MyPolicyFactory::newEmptySelection());
ASSERT_TRUE(testSend(data, "?[Custom]"));
ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply.")));
}
-void
-Test::requireThatSelectErrorCanBeIgnored(TestData &data)
+TEST_F(RoutingTest, require_that_select_error_can_be_ignored)
{
+ auto& data = *_data;
setupPolicy(data, "Custom", MyPolicyFactory::newSelectError(ErrorCode::APP_FATAL_ERROR));
ASSERT_TRUE(testSend(data, "?[Custom]"));
ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply.")));
}
-void
-Test::requireThatSelectExceptionCanBeIgnored(TestData &data)
+TEST_F(RoutingTest, require_that_select_exception_can_be_ignored)
{
+ auto& data = *_data;
setupPolicy(data, "Custom", MyPolicyFactory::newSelectException());
ASSERT_TRUE(testSend(data, "?[Custom]"));
ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply.")));
}
-void
-Test::requireThatSelectAndThrowCanBeIgnored(TestData &data)
+TEST_F(RoutingTest, require_that_select_and_throw_can_be_ignored)
{
+ auto& data = *_data;
setupPolicy(data, "Custom", MyPolicyFactory::newSelectAndThrow("dst/session"));
ASSERT_TRUE(testSend(data, "?[Custom]"));
ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply.")));
}
-void
-Test::requireThatEmptyMergeCanBeIgnored(TestData &data)
+TEST_F(RoutingTest, require_that_empty_merge_can_be_ignored)
{
+ auto& data = *_data;
setupPolicy(data, "Custom", MyPolicyFactory::newEmptyMerge("dst/session"));
ASSERT_TRUE(testSend(data, "?[Custom]"));
ASSERT_TRUE(testAcknowledge(data));
ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply.")));
}
-void
-Test::requireThatMergeErrorCanBeIgnored(TestData &data)
+TEST_F(RoutingTest, require_that_merge_error_can_be_ignored)
{
+ auto& data = *_data;
setupPolicy(data, "Custom", MyPolicyFactory::newMergeError("dst/session", ErrorCode::APP_FATAL_ERROR));
ASSERT_TRUE(testSend(data, "?[Custom]"));
ASSERT_TRUE(testAcknowledge(data));
ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply.")));
}
-void
-Test::requireThatMergeExceptionCanBeIgnored(TestData &data)
+TEST_F(RoutingTest, require_that_merge_exception_can_be_ignored)
{
+ auto& data = *_data;
setupPolicy(data, "Custom", MyPolicyFactory::newMergeException("dst/session"));
ASSERT_TRUE(testSend(data, "?[Custom]"));
ASSERT_TRUE(testAcknowledge(data));
ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply.")));
}
-
-void
-Test::requireThatMergeAndThrowCanBeIgnored(TestData &data)
+
+TEST_F(RoutingTest, require_that_merge_and_throw_can_be_ignored)
{
+ auto& data = *_data;
setupPolicy(data, "Custom", MyPolicyFactory::newMergeAndThrow("dst/session"));
ASSERT_TRUE(testSend(data, "?[Custom]"));
ASSERT_TRUE(testAcknowledge(data));
ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply.")));
}
-void
-Test::requireThatAllocServiceCanBeIgnored(TestData &data)
+TEST_F(RoutingTest, require_that_alloc_service_can_be_ignored)
{
+ auto& data = *_data;
ASSERT_TRUE(testSend(data, "?dst/unknown"));
ASSERT_TRUE(testTrace(data, StringList().add("Ignoring errors in reply.")));
}
-void
-Test::requireThatDepthLimitCanBeIgnored(TestData &data)
+TEST_F(RoutingTest, require_that_depth_limit_can_be_ignored)
{
+ auto& data = *_data;
setupPolicy(data, "Custom", MyPolicyFactory::newSelectAndMerge("[Custom]"));
ASSERT_TRUE(testSend(data, "?[Custom]", 0));
ASSERT_TRUE(testTrace(data, StringList()));
}
-void
-Test::testTimeout(TestData &data)
+TEST_F(RoutingTest, test_timeout)
{
+ auto& data = *_data;
+ // Force teardown after this test case since timeouts have been changed.
+ _force_teardown = true;
data._retryPolicy->setEnabled(true);
data._retryPolicy->setBaseDelay(0.01);
data._srcSession->setTimeout(500ms);
EXPECT_TRUE(data._srcSession->send(createMessage("msg"), Route::parse("dst/unknown")).isAccepted());
Reply::UP reply = data._srcHandler.getReply(RECEPTOR_TIMEOUT);
ASSERT_TRUE(reply);
- EXPECT_EQUAL(2u, reply->getNumErrors());
- EXPECT_EQUAL((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, reply->getError(0).getCode());
- EXPECT_EQUAL((uint32_t)ErrorCode::TIMEOUT, reply->getError(1).getCode());
+ EXPECT_EQ(2u, reply->getNumErrors());
+ EXPECT_EQ((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, reply->getError(0).getCode());
+ EXPECT_EQ((uint32_t)ErrorCode::TIMEOUT, reply->getError(1).getCode());
}
+
+GTEST_MAIN_RUN_ALL_TESTS()
diff --git a/messagebus/src/tests/routingcontext/CMakeLists.txt b/messagebus/src/tests/routingcontext/CMakeLists.txt
index 96bf6dbe35e..932d0020a3e 100644
--- a/messagebus/src/tests/routingcontext/CMakeLists.txt
+++ b/messagebus/src/tests/routingcontext/CMakeLists.txt
@@ -5,5 +5,6 @@ vespa_add_executable(messagebus_routingcontext_test_app TEST
DEPENDS
messagebus_messagebus-test
messagebus
+ GTest::gtest
)
vespa_add_test(NAME messagebus_routingcontext_test_app COMMAND messagebus_routingcontext_test_app)
diff --git a/messagebus/src/tests/routingcontext/routingcontext.cpp b/messagebus/src/tests/routingcontext/routingcontext.cpp
index d81bada2bc6..c8bbc53a0df 100644
--- a/messagebus/src/tests/routingcontext/routingcontext.cpp
+++ b/messagebus/src/tests/routingcontext/routingcontext.cpp
@@ -9,7 +9,7 @@
#include <vespa/messagebus/testlib/simpleprotocol.h>
#include <vespa/messagebus/testlib/slobrok.h>
#include <vespa/messagebus/testlib/testserver.h>
-#include <vespa/vespalib/testkit/testapp.h>
+#include <vespa/vespalib/gtest/gtest.h>
#include <vespa/vespalib/util/stringfmt.h>
@@ -17,6 +17,8 @@ using namespace mbus;
using vespalib::make_string;
+namespace {
+
static const duration TIMEOUT = 120s;
class StringList : public std::vector<string> {
@@ -192,20 +194,6 @@ public:
bool start();
};
-class Test : public vespalib::TestApp {
-private:
- static Message::UP createMessage(const string &msg);
-
-public:
- int Main() override;
- void testSingleDirective(TestData &data);
- void testMoreDirectives(TestData &data);
- void testRecipientsRemain(TestData &data);
- void testConstRoute(TestData &data);
-};
-
-TEST_APPHOOK(Test);
-
TestData::TestData() :
_slobrok(),
_retryPolicy(std::make_shared<RetryTransientErrorsPolicy>()),
@@ -240,28 +228,33 @@ TestData::start()
return true;
}
-Message::UP
-Test::createMessage(const string &msg)
-{
- auto ret = std::make_unique<SimpleMessage>(msg);
- ret->getTrace().setLevel(9);
- return ret;
}
-int
-Test::Main()
-{
- TEST_INIT("routingcontext_test");
+class RoutingContextTest : public testing::Test {
+protected:
+ static std::shared_ptr<TestData> _data;
+ RoutingContextTest();
+ ~RoutingContextTest() override;
+ static void SetUpTestSuite();
+ static void TearDownTestSuite();
+};
- TestData data;
- ASSERT_TRUE(data.start());
+std::shared_ptr<TestData> RoutingContextTest::_data;
- testSingleDirective(data); TEST_FLUSH();
- testMoreDirectives(data); TEST_FLUSH();
- testRecipientsRemain(data); TEST_FLUSH();
- testConstRoute(data); TEST_FLUSH();
+RoutingContextTest::RoutingContextTest() = default;
+RoutingContextTest::~RoutingContextTest() = default;
- TEST_DONE();
+void
+RoutingContextTest::SetUpTestSuite()
+{
+ _data = std::make_shared<TestData>();
+ ASSERT_TRUE(_data->start());
+}
+
+void
+RoutingContextTest::TearDownTestSuite()
+{
+ _data.reset();
}
////////////////////////////////////////////////////////////////////////////////
@@ -270,9 +263,9 @@ Test::Main()
//
////////////////////////////////////////////////////////////////////////////////
-void
-Test::testSingleDirective(TestData &data)
+TEST_F(RoutingContextTest, test_single_directive)
{
+ auto& data = *_data;
IProtocol::SP protocol(new SimpleProtocol());
auto &simple = dynamic_cast<SimpleProtocol&>(*protocol);
simple.addPolicyFactory("Custom", SimpleProtocol::IPolicyFactory::SP(new CustomPolicyFactory(
@@ -295,9 +288,9 @@ Test::testSingleDirective(TestData &data)
}
}
-void
-Test::testMoreDirectives(TestData &data)
+TEST_F(RoutingContextTest, test_more_directives)
{
+ auto& data = *_data;
IProtocol::SP protocol(new SimpleProtocol());
auto &simple = dynamic_cast<SimpleProtocol&>(*protocol);
simple.addPolicyFactory("Custom", SimpleProtocol::IPolicyFactory::SP(new CustomPolicyFactory(
@@ -322,9 +315,9 @@ Test::testMoreDirectives(TestData &data)
}
}
-void
-Test::testRecipientsRemain(TestData &data)
+TEST_F(RoutingContextTest, test_recipients_remain)
{
+ auto& data = *_data;
auto protocol = std::make_shared<SimpleProtocol>();
auto &simple = dynamic_cast<SimpleProtocol&>(*protocol);
simple.addPolicyFactory("First", std::make_shared<CustomPolicyFactory>(true,
@@ -347,9 +340,9 @@ Test::testRecipientsRemain(TestData &data)
}
}
-void
-Test::testConstRoute(TestData &data)
+TEST_F(RoutingContextTest, test_const_route)
{
+ auto& data = *_data;
auto protocol = std::make_shared<SimpleProtocol>();
auto &simple = dynamic_cast<SimpleProtocol&>(*protocol);
simple.addPolicyFactory("DocumentRouteSelector",
@@ -371,3 +364,4 @@ Test::testConstRoute(TestData &data)
}
}
+GTEST_MAIN_RUN_ALL_TESTS()
diff --git a/messagebus/src/tests/routingspec/CMakeLists.txt b/messagebus/src/tests/routingspec/CMakeLists.txt
index 7a2ba9d8fe4..c7115c16fd9 100644
--- a/messagebus/src/tests/routingspec/CMakeLists.txt
+++ b/messagebus/src/tests/routingspec/CMakeLists.txt
@@ -5,5 +5,6 @@ vespa_add_executable(messagebus_routingspec_test_app TEST
DEPENDS
messagebus_messagebus-test
messagebus
+ GTest::gtest
)
vespa_add_test(NAME messagebus_routingspec_test_app COMMAND messagebus_routingspec_test_app)
diff --git a/messagebus/src/tests/routingspec/routingspec.cpp b/messagebus/src/tests/routingspec/routingspec.cpp
index 40f3f293de3..eec19982b8e 100644
--- a/messagebus/src/tests/routingspec/routingspec.cpp
+++ b/messagebus/src/tests/routingspec/routingspec.cpp
@@ -3,9 +3,9 @@
#include <vespa/messagebus/configagent.h>
#include <vespa/messagebus/iconfighandler.h>
#include <vespa/messagebus/routing/routingspec.h>
-#include <vespa/vespalib/testkit/testapp.h>
#include <vespa/messagebus/config-messagebus.h>
#include <vespa/config/helper/configgetter.hpp>
+#include <vespa/vespalib/gtest/gtest.h>
using namespace mbus;
@@ -31,32 +31,19 @@ public:
}
};
-class Test : public vespalib::TestApp {
-private:
- bool testRouting(const RoutingSpec &spec);
- bool testConfig(const RoutingSpec &spec);
-
-public:
- void testConstructors();
- void testConfigGeneration();
- int Main() override;
+class RoutingSpecTest : public testing::Test {
+protected:
+ RoutingSpecTest();
+ ~RoutingSpecTest() override;
+ static void test_routing_helper(const RoutingSpec &spec, bool& success);
+ static bool testRouting(const RoutingSpec &spec);
+ static bool testConfig(const RoutingSpec &spec);
};
-TEST_APPHOOK(Test);
-
-int
-Test::Main()
-{
- TEST_INIT("routingspec_test");
-
- testConstructors(); TEST_FLUSH();
- testConfigGeneration(); TEST_FLUSH();
-
- TEST_DONE();
-}
+RoutingSpecTest::RoutingSpecTest() = default;
+RoutingSpecTest::~RoutingSpecTest() = default;
-void
-Test::testConstructors()
+TEST_F(RoutingSpecTest, test_constructors)
{
{
RoutingSpec spec;
@@ -126,57 +113,64 @@ Test::testConstructors()
}
}
+void
+RoutingSpecTest::test_routing_helper(const RoutingSpec &spec, bool& success)
+{
+ ASSERT_TRUE(spec.getNumTables() == 2);
+ ASSERT_TRUE(spec.getTable(0).getProtocol() == "foo");
+ ASSERT_TRUE(spec.getTable(0).getNumHops() == 2);
+ ASSERT_TRUE(spec.getTable(0).getHop(0).getName() == "foo-h1");
+ ASSERT_TRUE(spec.getTable(0).getHop(0).getSelector() == "foo-h1-sel");
+ ASSERT_TRUE(spec.getTable(0).getHop(0).getNumRecipients() == 2);
+ ASSERT_TRUE(spec.getTable(0).getHop(0).getRecipient(0) == "foo-h1-r1");
+ ASSERT_TRUE(spec.getTable(0).getHop(0).getRecipient(1) == "foo-h1-r2");
+ ASSERT_TRUE(spec.getTable(0).getHop(1).getName() == "foo-h2");
+ ASSERT_TRUE(spec.getTable(0).getHop(1).getSelector() == "foo-h2-sel");
+ ASSERT_TRUE(spec.getTable(0).getHop(1).getNumRecipients() == 2);
+ ASSERT_TRUE(spec.getTable(0).getHop(1).getRecipient(0) == "foo-h2-r1");
+ ASSERT_TRUE(spec.getTable(0).getHop(1).getRecipient(1) == "foo-h2-r2");
+ ASSERT_TRUE(spec.getTable(0).getNumRoutes() == 2);
+ ASSERT_TRUE(spec.getTable(0).getRoute(0).getName() == "foo-r1");
+ ASSERT_TRUE(spec.getTable(0).getRoute(0).getNumHops() == 2);
+ ASSERT_TRUE(spec.getTable(0).getRoute(0).getHop(0) == "foo-h1");
+ ASSERT_TRUE(spec.getTable(0).getRoute(0).getHop(1) == "foo-h2");
+ ASSERT_TRUE(spec.getTable(0).getRoute(1).getName() == "foo-r2");
+ ASSERT_TRUE(spec.getTable(0).getRoute(1).getNumHops() == 2);
+ ASSERT_TRUE(spec.getTable(0).getRoute(1).getHop(0) == "foo-h2");
+ ASSERT_TRUE(spec.getTable(0).getRoute(1).getHop(1) == "foo-h1");
+ ASSERT_TRUE(spec.getTable(1).getProtocol() == "bar");
+ ASSERT_TRUE(spec.getTable(1).getNumHops() == 2);
+ ASSERT_TRUE(spec.getTable(1).getHop(0).getName() == "bar-h1");
+ ASSERT_TRUE(spec.getTable(1).getHop(0).getSelector() == "bar-h1-sel");
+ ASSERT_TRUE(spec.getTable(1).getHop(0).getNumRecipients() == 2);
+ ASSERT_TRUE(spec.getTable(1).getHop(0).getRecipient(0) == "bar-h1-r1");
+ ASSERT_TRUE(spec.getTable(1).getHop(0).getRecipient(1) == "bar-h1-r2");
+ ASSERT_TRUE(spec.getTable(1).getHop(1).getName() == "bar-h2");
+ ASSERT_TRUE(spec.getTable(1).getHop(1).getSelector() == "bar-h2-sel");
+ ASSERT_TRUE(spec.getTable(1).getHop(1).getNumRecipients() == 2);
+ ASSERT_TRUE(spec.getTable(1).getHop(1).getRecipient(0) == "bar-h2-r1");
+ ASSERT_TRUE(spec.getTable(1).getHop(1).getRecipient(1) == "bar-h2-r2");
+ ASSERT_TRUE(spec.getTable(1).getNumRoutes() == 2);
+ ASSERT_TRUE(spec.getTable(1).getRoute(0).getName() == "bar-r1");
+ ASSERT_TRUE(spec.getTable(1).getRoute(0).getNumHops() == 2);
+ ASSERT_TRUE(spec.getTable(1).getRoute(0).getHop(0) == "bar-h1");
+ ASSERT_TRUE(spec.getTable(1).getRoute(0).getHop(1) == "bar-h2");
+ ASSERT_TRUE(spec.getTable(1).getRoute(1).getName() == "bar-r2");
+ ASSERT_TRUE(spec.getTable(1).getRoute(1).getNumHops() == 2);
+ ASSERT_TRUE(spec.getTable(1).getRoute(1).getHop(0) == "bar-h2");
+ ASSERT_TRUE(spec.getTable(1).getRoute(1).getHop(1) == "bar-h1");
+ success = true;
+}
+
bool
-Test::testRouting(const RoutingSpec &spec)
+RoutingSpecTest::testRouting(const RoutingSpec &spec)
{
- if (!ASSERT_TRUE(spec.getNumTables() == 2)) { return false; }
- if (!EXPECT_TRUE(spec.getTable(0).getProtocol() == "foo")) { return false; }
- if (!ASSERT_TRUE(spec.getTable(0).getNumHops() == 2)) { return false; }
- if (!EXPECT_TRUE(spec.getTable(0).getHop(0).getName() == "foo-h1")) { return false; }
- if (!EXPECT_TRUE(spec.getTable(0).getHop(0).getSelector() == "foo-h1-sel")) { return false; }
- if (!ASSERT_TRUE(spec.getTable(0).getHop(0).getNumRecipients() == 2)) { return false; }
- if (!EXPECT_TRUE(spec.getTable(0).getHop(0).getRecipient(0) == "foo-h1-r1")) { return false; }
- if (!EXPECT_TRUE(spec.getTable(0).getHop(0).getRecipient(1) == "foo-h1-r2")) { return false; }
- if (!EXPECT_TRUE(spec.getTable(0).getHop(1).getName() == "foo-h2")) { return false; }
- if (!EXPECT_TRUE(spec.getTable(0).getHop(1).getSelector() == "foo-h2-sel")) { return false; }
- if (!ASSERT_TRUE(spec.getTable(0).getHop(1).getNumRecipients() == 2)) { return false; }
- if (!EXPECT_TRUE(spec.getTable(0).getHop(1).getRecipient(0) == "foo-h2-r1")) { return false; }
- if (!EXPECT_TRUE(spec.getTable(0).getHop(1).getRecipient(1) == "foo-h2-r2")) { return false; }
- if (!ASSERT_TRUE(spec.getTable(0).getNumRoutes() == 2)) { return false; }
- if (!EXPECT_TRUE(spec.getTable(0).getRoute(0).getName() == "foo-r1")) { return false; }
- if (!ASSERT_TRUE(spec.getTable(0).getRoute(0).getNumHops() == 2)) { return false; }
- if (!EXPECT_TRUE(spec.getTable(0).getRoute(0).getHop(0) == "foo-h1")) { return false; }
- if (!EXPECT_TRUE(spec.getTable(0).getRoute(0).getHop(1) == "foo-h2")) { return false; }
- if (!EXPECT_TRUE(spec.getTable(0).getRoute(1).getName() == "foo-r2")) { return false; }
- if (!ASSERT_TRUE(spec.getTable(0).getRoute(1).getNumHops() == 2)) { return false; }
- if (!EXPECT_TRUE(spec.getTable(0).getRoute(1).getHop(0) == "foo-h2")) { return false; }
- if (!EXPECT_TRUE(spec.getTable(0).getRoute(1).getHop(1) == "foo-h1")) { return false; }
- if (!EXPECT_TRUE(spec.getTable(1).getProtocol() == "bar")) { return false; }
- if (!ASSERT_TRUE(spec.getTable(1).getNumHops() == 2)) { return false; }
- if (!EXPECT_TRUE(spec.getTable(1).getHop(0).getName() == "bar-h1")) { return false; }
- if (!EXPECT_TRUE(spec.getTable(1).getHop(0).getSelector() == "bar-h1-sel")) { return false; }
- if (!ASSERT_TRUE(spec.getTable(1).getHop(0).getNumRecipients() == 2)) { return false; }
- if (!EXPECT_TRUE(spec.getTable(1).getHop(0).getRecipient(0) == "bar-h1-r1")) { return false; }
- if (!EXPECT_TRUE(spec.getTable(1).getHop(0).getRecipient(1) == "bar-h1-r2")) { return false; }
- if (!EXPECT_TRUE(spec.getTable(1).getHop(1).getName() == "bar-h2")) { return false; }
- if (!EXPECT_TRUE(spec.getTable(1).getHop(1).getSelector() == "bar-h2-sel")) { return false; }
- if (!ASSERT_TRUE(spec.getTable(1).getHop(1).getNumRecipients() == 2)) { return false; }
- if (!EXPECT_TRUE(spec.getTable(1).getHop(1).getRecipient(0) == "bar-h2-r1")) { return false; }
- if (!EXPECT_TRUE(spec.getTable(1).getHop(1).getRecipient(1) == "bar-h2-r2")) { return false; }
- if (!ASSERT_TRUE(spec.getTable(1).getNumRoutes() == 2)) { return false; }
- if (!EXPECT_TRUE(spec.getTable(1).getRoute(0).getName() == "bar-r1")) { return false; }
- if (!ASSERT_TRUE(spec.getTable(1).getRoute(0).getNumHops() == 2)) { return false; }
- if (!EXPECT_TRUE(spec.getTable(1).getRoute(0).getHop(0) == "bar-h1")) { return false; }
- if (!EXPECT_TRUE(spec.getTable(1).getRoute(0).getHop(1) == "bar-h2")) { return false; }
- if (!EXPECT_TRUE(spec.getTable(1).getRoute(1).getName() == "bar-r2")) { return false; }
- if (!ASSERT_TRUE(spec.getTable(1).getRoute(1).getNumHops() == 2)) { return false; }
- if (!EXPECT_TRUE(spec.getTable(1).getRoute(1).getHop(0) == "bar-h2")) { return false; }
- if (!EXPECT_TRUE(spec.getTable(1).getRoute(1).getHop(1) == "bar-h1")) { return false; }
- return true;
+ bool success = false;
+ test_routing_helper(spec, success);
+ return success;
}
-void
-Test::testConfigGeneration()
+TEST_F(RoutingSpecTest, test_config_generation)
{
EXPECT_TRUE(testConfig(RoutingSpec()));
EXPECT_TRUE(testConfig(RoutingSpec().addTable(RoutingTableSpec("mytable1"))));
@@ -200,50 +194,52 @@ Test::testConfigGeneration()
.addRoute(RouteSpec("myroute12").addHop("myhop1").addHop("myhop2")))
.addTable(RoutingTableSpec("mytable2"))));
- EXPECT_EQUAL("routingtable[2]\n"
- "routingtable[0].protocol \"mytable1\"\n"
- "routingtable[1].protocol \"mytable2\"\n"
- "routingtable[1].hop[3]\n"
- "routingtable[1].hop[0].name \"myhop1\"\n"
- "routingtable[1].hop[0].selector \"myselector1\"\n"
- "routingtable[1].hop[1].name \"myhop2\"\n"
- "routingtable[1].hop[1].selector \"myselector2\"\n"
- "routingtable[1].hop[1].ignoreresult true\n"
- "routingtable[1].hop[2].name \"myhop1\"\n"
- "routingtable[1].hop[2].selector \"myselector3\"\n"
- "routingtable[1].hop[2].recipient[2]\n"
- "routingtable[1].hop[2].recipient[0] \"myrecipient1\"\n"
- "routingtable[1].hop[2].recipient[1] \"myrecipient2\"\n"
- "routingtable[1].route[1]\n"
- "routingtable[1].route[0].name \"myroute1\"\n"
- "routingtable[1].route[0].hop[1]\n"
- "routingtable[1].route[0].hop[0] \"myhop1\"\n",
- RoutingSpec()
- .addTable(RoutingTableSpec("mytable1"))
- .addTable(RoutingTableSpec("mytable2")
- .addHop(HopSpec("myhop1", "myselector1"))
- .addHop(std::move(HopSpec("myhop2", "myselector2").setIgnoreResult(true)))
- .addHop(HopSpec("myhop1", "myselector3")
- .addRecipient("myrecipient1")
- .addRecipient("myrecipient2"))
- .addRoute(RouteSpec("myroute1").addHop("myhop1"))).toString());
+ EXPECT_EQ("routingtable[2]\n"
+ "routingtable[0].protocol \"mytable1\"\n"
+ "routingtable[1].protocol \"mytable2\"\n"
+ "routingtable[1].hop[3]\n"
+ "routingtable[1].hop[0].name \"myhop1\"\n"
+ "routingtable[1].hop[0].selector \"myselector1\"\n"
+ "routingtable[1].hop[1].name \"myhop2\"\n"
+ "routingtable[1].hop[1].selector \"myselector2\"\n"
+ "routingtable[1].hop[1].ignoreresult true\n"
+ "routingtable[1].hop[2].name \"myhop1\"\n"
+ "routingtable[1].hop[2].selector \"myselector3\"\n"
+ "routingtable[1].hop[2].recipient[2]\n"
+ "routingtable[1].hop[2].recipient[0] \"myrecipient1\"\n"
+ "routingtable[1].hop[2].recipient[1] \"myrecipient2\"\n"
+ "routingtable[1].route[1]\n"
+ "routingtable[1].route[0].name \"myroute1\"\n"
+ "routingtable[1].route[0].hop[1]\n"
+ "routingtable[1].route[0].hop[0] \"myhop1\"\n",
+ RoutingSpec()
+ .addTable(RoutingTableSpec("mytable1"))
+ .addTable(RoutingTableSpec("mytable2")
+ .addHop(HopSpec("myhop1", "myselector1"))
+ .addHop(std::move(HopSpec("myhop2", "myselector2").setIgnoreResult(true)))
+ .addHop(HopSpec("myhop1", "myselector3")
+ .addRecipient("myrecipient1")
+ .addRecipient("myrecipient2"))
+ .addRoute(RouteSpec("myroute1").addHop("myhop1"))).toString());
}
bool
-Test::testConfig(const RoutingSpec &spec)
+RoutingSpecTest::testConfig(const RoutingSpec &spec)
{
- if (!EXPECT_TRUE(spec == spec)) {
+ bool failure = false;
+ EXPECT_TRUE(spec == spec) << (failure = true, "");
+ if (failure) {
return false;
}
- if (!EXPECT_TRUE(spec == RoutingSpec(spec))) {
+ EXPECT_TRUE(spec == RoutingSpec(spec)) << (failure = true, "");
+ if (failure) {
return false;
}
ConfigStore store;
ConfigAgent agent(store);
agent.configure(ConfigGetter<MessagebusConfig>().getConfig("", RawSpec(spec.toString())));
- if (!EXPECT_TRUE(store.getRoutingSpec() == spec)) {
- return false;
- }
- return true;
+ EXPECT_TRUE(store.getRoutingSpec() == spec) << (failure = true, "");
+ return !failure;
}
+GTEST_MAIN_RUN_ALL_TESTS()
diff --git a/messagebus/src/tests/sourcesession/CMakeLists.txt b/messagebus/src/tests/sourcesession/CMakeLists.txt
index 067b281939a..6f8b14667ee 100644
--- a/messagebus/src/tests/sourcesession/CMakeLists.txt
+++ b/messagebus/src/tests/sourcesession/CMakeLists.txt
@@ -5,5 +5,6 @@ vespa_add_executable(messagebus_sourcesession_test_app TEST
DEPENDS
messagebus_messagebus-test
messagebus
+ GTest::gtest
)
vespa_add_test(NAME messagebus_sourcesession_test_app COMMAND messagebus_sourcesession_test_app)
diff --git a/messagebus/src/tests/sourcesession/sourcesession.cpp b/messagebus/src/tests/sourcesession/sourcesession.cpp
index 5d1a8e8ad24..d642209d816 100644
--- a/messagebus/src/tests/sourcesession/sourcesession.cpp
+++ b/messagebus/src/tests/sourcesession/sourcesession.cpp
@@ -15,7 +15,7 @@
#include <vespa/messagebus/testlib/simpleprotocol.h>
#include <vespa/messagebus/testlib/slobrok.h>
#include <vespa/messagebus/testlib/testserver.h>
-#include <vespa/vespalib/testkit/testapp.h>
+#include <vespa/vespalib/gtest/gtest.h>
#include <thread>
using namespace mbus;
@@ -64,21 +64,7 @@ bool waitQueueSize(RoutableQueue &queue, uint32_t size) {
return false;
}
-class Test : public vespalib::TestApp
-{
-public:
- void testSequencing();
- void testResendError();
- void testResendConnDown();
- void testIllegalRoute();
- void testNoServices();
- void testBlockingClose();
- void testNonBlockingClose();
- int Main() override;
-};
-
-void
-Test::testSequencing()
+TEST(SourceSessionTest, test_sequencing)
{
Slobrok slobrok;
TestServer src(Identity(""), getRouting(), slobrok);
@@ -111,8 +97,7 @@ Test::testSequencing()
ASSERT_TRUE(waitQueueSize(dstQ, 0));
}
-void
-Test::testResendError()
+TEST(SourceSessionTest, test_resend_error)
{
Slobrok slobrok;
auto retryPolicy = std::make_shared<RetryTransientErrorsPolicy>();
@@ -172,8 +157,7 @@ Test::testResendError()
}
}
-void
-Test::testResendConnDown()
+TEST(SourceSessionTest, test_resend_conn_down)
{
Slobrok slobrok;
auto retryPolicy = std::make_shared<RetryTransientErrorsPolicy>();
@@ -218,8 +202,7 @@ Test::testResendConnDown()
fprintf(stderr, "\nTRACE DUMP:\n%s\n\n", trace.c_str());
}
-void
-Test::testIllegalRoute()
+TEST(SourceSessionTest, test_illegal_route)
{
Slobrok slobrok;
TestServer src(MessageBusParams()
@@ -243,16 +226,15 @@ Test::testIllegalRoute()
Routable::UP routable = srcQ.dequeue();
ASSERT_TRUE(routable->isReply());
Reply::UP r(dynamic_cast<Reply*>(routable.release()));
- EXPECT_EQUAL(1u, r->getNumErrors());
- EXPECT_EQUAL((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, r->getError(0).getCode());
+ EXPECT_EQ(1u, r->getNumErrors());
+ EXPECT_EQ((uint32_t)ErrorCode::NO_ADDRESS_FOR_SERVICE, r->getError(0).getCode());
string trace = r->getTrace().toString();
fprintf(stderr, "\nTRACE DUMP:\n%s\n\n", trace.c_str());
}
}
}
-void
-Test::testNoServices()
+TEST(SourceSessionTest, test_no_services)
{
Slobrok slobrok;
TestServer src(MessageBusParams()
@@ -283,8 +265,7 @@ Test::testNoServices()
}
}
-void
-Test::testBlockingClose()
+TEST(SourceSessionTest, test_blocking_close)
{
Slobrok slobrok;
TestServer src(Identity(""), getRouting(), slobrok);
@@ -304,8 +285,7 @@ Test::testBlockingClose()
EXPECT_TRUE(routable->isReply());
}
-void
-Test::testNonBlockingClose()
+TEST(SourceSessionTest, test_non_blocking_close)
{
Slobrok slobrok;
TestServer src(Identity(""), getRouting(), slobrok);
@@ -317,18 +297,4 @@ Test::testNonBlockingClose()
ss->close(); // this should not hang
}
-int
-Test::Main()
-{
- TEST_INIT("sourcesession_test");
- testSequencing(); TEST_FLUSH();
- testResendError(); TEST_FLUSH();
- testResendConnDown(); TEST_FLUSH();
- testIllegalRoute(); TEST_FLUSH();
- testNoServices(); TEST_FLUSH();
- testBlockingClose(); TEST_FLUSH();
- testNonBlockingClose(); TEST_FLUSH();
- TEST_DONE();
-}
-
-TEST_APPHOOK(Test);
+GTEST_MAIN_RUN_ALL_TESTS()
diff --git a/messagebus/src/tests/throttling/CMakeLists.txt b/messagebus/src/tests/throttling/CMakeLists.txt
index 95df4c6d873..3ad0662d13b 100644
--- a/messagebus/src/tests/throttling/CMakeLists.txt
+++ b/messagebus/src/tests/throttling/CMakeLists.txt
@@ -5,5 +5,6 @@ vespa_add_executable(messagebus_throttling_test_app TEST
DEPENDS
messagebus_messagebus-test
messagebus
+ GTest::gtest
)
vespa_add_test(NAME messagebus_throttling_test_app COMMAND messagebus_throttling_test_app)
diff --git a/messagebus/src/tests/throttling/throttling.cpp b/messagebus/src/tests/throttling/throttling.cpp
index 73f4366e5d7..5b372334dcf 100644
--- a/messagebus/src/tests/throttling/throttling.cpp
+++ b/messagebus/src/tests/throttling/throttling.cpp
@@ -1,6 +1,5 @@
// Copyright Vespa.ai. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root.
-#include <vespa/vespalib/testkit/testapp.h>
#include <vespa/messagebus/destinationsession.h>
#include <vespa/messagebus/dynamicthrottlepolicy.h>
#include <vespa/messagebus/routablequeue.h>
@@ -12,6 +11,7 @@
#include <vespa/messagebus/testlib/simplemessage.h>
#include <vespa/messagebus/testlib/simplereply.h>
#include <vespa/messagebus/testlib/testserver.h>
+#include <vespa/vespalib/gtest/gtest.h>
#include <thread>
using namespace mbus;
@@ -65,46 +65,31 @@ bool waitPending(SourceSession& session, uint32_t size)
return false;
}
-////////////////////////////////////////////////////////////////////////////////
-//
-// Setup
-//
-////////////////////////////////////////////////////////////////////////////////
-
-class Test : public vespalib::TestApp {
-private:
- uint32_t getWindowSize(DynamicThrottlePolicy &policy, DynamicTimer &timer, uint32_t maxPending);
-
-protected:
- void testMaxPendingCount();
- void testMaxPendingSize();
- void testMinOne();
- void testDynamicWindowSize();
- void testIdleTimePeriod();
- void testMinWindowSize();
- void testMaxWindowSize();
-
-public:
- int Main() override;
-};
-
-int
-Test::Main()
+uint32_t
+getWindowSize(DynamicThrottlePolicy &policy, DynamicTimer &timer, uint32_t maxPending)
{
- TEST_INIT("throttling_test");
+ SimpleMessage msg("foo");
+ SimpleReply reply("bar");
+ reply.setContext(mbus::Context(uint64_t(1))); // To offset pending size bump in static policy
- testMaxPendingCount(); TEST_FLUSH();
- testMaxPendingSize(); TEST_FLUSH();
- testMinOne(); TEST_FLUSH();
- testDynamicWindowSize(); TEST_FLUSH();
- testIdleTimePeriod(); TEST_FLUSH();
- testMinWindowSize(); TEST_FLUSH();
- testMaxWindowSize(); TEST_FLUSH();
+ for (uint32_t i = 0; i < 999; ++i) {
+ uint32_t numPending = 0;
+ while (policy.canSend(msg, numPending)) {
+ policy.processMessage(msg);
+ ++numPending;
+ }
- TEST_DONE();
-}
+ uint64_t tripTime = (numPending < maxPending) ? 1000 : 1000 + (numPending - maxPending) * 1000;
+ timer._millis += tripTime;
-TEST_APPHOOK(Test);
+ for( ; numPending > 0 ; --numPending) {
+ policy.processReply(reply);
+ }
+ }
+ uint32_t ret = policy.getMaxPendingCount();
+ fprintf(stderr, "getWindowSize() = %u\n", ret);
+ return ret;
+}
////////////////////////////////////////////////////////////////////////////////
//
@@ -112,8 +97,7 @@ TEST_APPHOOK(Test);
//
////////////////////////////////////////////////////////////////////////////////
-void
-Test::testMaxPendingCount()
+TEST(ThrottlingTest, test_max_pending_count)
{
Slobrok slobrok;
TestServer src(Identity(""), getRouting(), slobrok);
@@ -165,8 +149,7 @@ Test::testMaxPendingCount()
ASSERT_TRUE(waitQueueSize(dstQ, 0));
}
-void
-Test::testMaxPendingSize()
+TEST(ThrottlingTest, test_max_pending_size)
{
ASSERT_TRUE(SimpleMessage("1234567890").getApproxSize() == 10);
ASSERT_TRUE(SimpleMessage("123456").getApproxSize() == 6);
@@ -191,8 +174,8 @@ Test::testMaxPendingSize()
DestinationSession::UP ds = dst.mb.createDestinationSession("session", true, dstQ);
ASSERT_TRUE(src.waitSlobrok("dst/session"));
- EXPECT_EQUAL(1u, SimpleMessage("1").getApproxSize());
- EXPECT_EQUAL(2u, SimpleMessage("12").getApproxSize());
+ EXPECT_EQ(1u, SimpleMessage("1").getApproxSize());
+ EXPECT_EQ(2u, SimpleMessage("12").getApproxSize());
EXPECT_TRUE(ss->send(Message::UP(new SimpleMessage("1")), "dst").isAccepted());
EXPECT_TRUE(waitQueueSize(dstQ, 1));
@@ -214,8 +197,7 @@ Test::testMaxPendingSize()
ASSERT_TRUE(waitQueueSize(srcQ, 3));
}
-void
-Test::testMinOne()
+TEST(ThrottlingTest, test_min_one)
{
ASSERT_TRUE(SimpleMessage("1234567890").getApproxSize() == 10);
ASSERT_TRUE(SimpleMessage("").getApproxSize() == 0);
@@ -248,8 +230,7 @@ Test::testMinOne()
}
-void
-Test::testDynamicWindowSize()
+TEST(ThrottlingTest, test_dynamic_window_size)
{
auto ptr = std::make_unique<DynamicTimer>();
auto* timer = ptr.get();
@@ -274,8 +255,7 @@ Test::testDynamicWindowSize()
ASSERT_TRUE(windowSize >= 90 && windowSize <= 115);
}
-void
-Test::testIdleTimePeriod()
+TEST(ThrottlingTest, test_idle_time_period)
{
auto ptr = std::make_unique<DynamicTimer>();
auto* timer = ptr.get();
@@ -295,15 +275,14 @@ Test::testIdleTimePeriod()
timer->_millis += 60001;
ASSERT_TRUE(policy.canSend(msg, 50));
- EXPECT_EQUAL(55u, policy.getMaxPendingCount());
+ EXPECT_EQ(55u, policy.getMaxPendingCount());
timer->_millis += 60001;
ASSERT_TRUE(policy.canSend(msg, 0));
- EXPECT_EQUAL(5u, policy.getMaxPendingCount());
+ EXPECT_EQ(5u, policy.getMaxPendingCount());
}
-void
-Test::testMinWindowSize()
+TEST(ThrottlingTest, test_min_window_size)
{
auto ptr = std::make_unique<DynamicTimer>();
auto* timer = ptr.get();
@@ -317,8 +296,7 @@ Test::testMinWindowSize()
ASSERT_TRUE(windowSize >= 150 && windowSize <= 210);
}
-void
-Test::testMaxWindowSize()
+TEST(ThrottlingTest, test_max_window_size)
{
auto ptr = std::make_unique<DynamicTimer>();
auto* timer = ptr.get();
@@ -337,28 +315,4 @@ Test::testMaxWindowSize()
}
-uint32_t
-Test::getWindowSize(DynamicThrottlePolicy &policy, DynamicTimer &timer, uint32_t maxPending)
-{
- SimpleMessage msg("foo");
- SimpleReply reply("bar");
- reply.setContext(mbus::Context(uint64_t(1))); // To offset pending size bump in static policy
-
- for (uint32_t i = 0; i < 999; ++i) {
- uint32_t numPending = 0;
- while (policy.canSend(msg, numPending)) {
- policy.processMessage(msg);
- ++numPending;
- }
-
- uint64_t tripTime = (numPending < maxPending) ? 1000 : 1000 + (numPending - maxPending) * 1000;
- timer._millis += tripTime;
-
- for( ; numPending > 0 ; --numPending) {
- policy.processReply(reply);
- }
- }
- uint32_t ret = policy.getMaxPendingCount();
- fprintf(stderr, "getWindowSize() = %u\n", ret);
- return ret;
-}
+GTEST_MAIN_RUN_ALL_TESTS()