Fix unstable unittest (#1102)

Properly mock wsbase

unittests/feed/BookChangesFeedTests.cpp

@@ -18,20 +18,19 @@
 //==============================================================================
 
 #include "data/Types.h"
-#include "feed/FeedBaseTest.h"
+#include "feed/FeedTestUtil.h"
 #include "feed/impl/BookChangesFeed.h"
 #include "feed/impl/ForwardFeed.h"
 #include "util/TestObject.h"
 
 #include <boost/asio/io_context.hpp>
-#include <boost/json/parse.hpp>
+#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <ripple/protocol/STObject.h>
 
 #include <vector>
 
 using namespace feed::impl;
-namespace json = boost::json;
 
 constexpr static auto LEDGERHASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652";
 constexpr static auto ACCOUNT1 = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn";
@@ -77,15 +76,13 @@ TEST_F(FeedBookChangeTest, Pub)
                 }
             ]
         })";
-    ctx.run();
 
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(bookChangePublish));
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(bookChangePublish))).Times(1);
+    ctx.run();
 
     testFeedPtr->unsub(sessionPtr);
     EXPECT_EQ(testFeedPtr->count(), 0);
-    cleanReceivedFeed();
     testFeedPtr->pub(ledgerinfo, transactions);
     ctx.restart();
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }

unittests/feed/FeedTestUtil.h

@@ -21,22 +21,23 @@
 
 #include "util/Fixtures.h"
 #include "util/MockWsBase.h"
-#include "util/Taggable.h"
-#include "util/config/Config.h"
 #include "web/interface/ConnectionBase.h"
 
+#include <boost/json/parse.hpp>
 #include <gtest/gtest.h>
 
 #include <memory>
+#include <ostream>
 #include <string>
+#include <utility>
 
 // Base class for feed tests, providing easy way to access the received feed
 template <typename TestedFeed>
 class FeedBaseTest : public SyncAsioContextTest, public MockBackendTest {
 protected:
-    util::TagDecoratorFactory tagDecoratorFactory{util::Config{}};
     std::shared_ptr<web::ConnectionBase> sessionPtr;
     std::shared_ptr<TestedFeed> testFeedPtr;
+    MockSession* mockSessionPtr = nullptr;
 
     void
     SetUp() override
@@ -44,7 +45,8 @@ protected:
         SyncAsioContextTest::SetUp();
         MockBackendTest::SetUp();
         testFeedPtr = std::make_shared<TestedFeed>(ctx);
-        sessionPtr = std::make_shared<MockSession>(tagDecoratorFactory);
+        sessionPtr = std::make_shared<MockSession>();
+        mockSessionPtr = dynamic_cast<MockSession*>(sessionPtr.get());
     }
 
     void
@@ -55,20 +57,41 @@ protected:
         MockBackendTest::TearDown();
         SyncAsioContextTest::TearDown();
     }
+};
 
-    std::string const&
+namespace detail {
-    receivedFeedMessage() const
+class SharedStringJsonEqMatcher {
+    std::string expected_;
+
+public:
+    using is_gtest_matcher = void;
+
+    explicit SharedStringJsonEqMatcher(std::string expected) : expected_(std::move(expected))
     {
-        auto const mockSession = dynamic_cast<MockSession*>(sessionPtr.get());
+    }
-        [&] { ASSERT_NE(mockSession, nullptr); }();
+
-        return mockSession->message;
+    bool
+    MatchAndExplain(std::shared_ptr<std::string> const& arg, std::ostream* /* listener */) const
+    {
+        return boost::json::parse(*arg) == boost::json::parse(expected_);
     }
 
     void
-    cleanReceivedFeed()
+    DescribeTo(std::ostream* os) const
     {
-        auto mockSession = dynamic_cast<MockSession*>(sessionPtr.get());
+        *os << "Contains json " << expected_;
-        [&] { ASSERT_NE(mockSession, nullptr); }();
+    }
-        mockSession->message.clear();
+
+    void
+    DescribeNegationTo(std::ostream* os) const
+    {
+        *os << "Expecting json " << expected_;
     }
 };
+}  // namespace detail
+
+inline ::testing::Matcher<std::shared_ptr<std::string>>
+SharedStringJsonEq(std::string const& expected)
+{
+    return detail::SharedStringJsonEqMatcher(expected);
+}

unittests/feed/ForwardFeedTests.cpp

@@ -17,11 +17,12 @@
 */
 //==============================================================================
 
-#include "feed/FeedBaseTest.h"
+#include "feed/FeedTestUtil.h"
 #include "feed/impl/ForwardFeed.h"
 
 #include <boost/asio/io_context.hpp>
 #include <boost/json/parse.hpp>
+#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 #include <memory>
@@ -47,16 +48,14 @@ TEST_F(FeedForwardTest, Pub)
     EXPECT_EQ(testFeedPtr->count(), 1);
     auto const json = json::parse(FEED).as_object();
     testFeedPtr->pub(json);
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(FEED))).Times(1);
     ctx.run();
 
-    EXPECT_EQ(receivedFeedMessage(), FEED);
     testFeedPtr->unsub(sessionPtr);
     EXPECT_EQ(testFeedPtr->count(), 0);
-    cleanReceivedFeed();
     testFeedPtr->pub(json);
     ctx.restart();
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }
 
 TEST_F(FeedForwardTest, AutoDisconnect)
@@ -65,8 +64,8 @@ TEST_F(FeedForwardTest, AutoDisconnect)
     EXPECT_EQ(testFeedPtr->count(), 1);
     auto const json = json::parse(FEED).as_object();
     testFeedPtr->pub(json);
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(FEED))).Times(1);
     ctx.run();
-    EXPECT_EQ(receivedFeedMessage(), FEED);
     sessionPtr.reset();
     EXPECT_EQ(testFeedPtr->count(), 0);
     testFeedPtr->pub(json);

unittests/feed/LedgerFeedTests.cpp

@@ -17,9 +17,8 @@
 */
 //==============================================================================
 
-#include "feed/FeedBaseTest.h"
+#include "feed/FeedTestUtil.h"
 #include "feed/impl/LedgerFeed.h"
-#include "util/Fixtures.h"
 #include "util/TestObject.h"
 
 #include <boost/asio/io_context.hpp>
@@ -29,12 +28,11 @@
 #include <gtest/gtest.h>
 #include <ripple/protocol/Fees.h>
 
-#include <memory>
-
 constexpr static auto LEDGERHASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652";
 
 using namespace feed::impl;
 namespace json = boost::json;
+using namespace testing;
 
 using FeedLedgerTest = FeedBaseTest<LedgerFeed>;
 
@@ -68,11 +66,6 @@ TEST_F(FeedLedgerTest, SubPub)
     ctx.run();
     EXPECT_EQ(testFeedPtr->count(), 1);
 
-    // test publish
-    auto const ledgerinfo2 = CreateLedgerInfo(LEDGERHASH, 31);
-    auto fee2 = ripple::Fees();
-    fee2.reserve = 10;
-    testFeedPtr->pub(ledgerinfo2, fee2, "10-31", 8);
     constexpr static auto ledgerPub =
         R"({
             "type":"ledgerClosed",
@@ -85,20 +78,23 @@ TEST_F(FeedLedgerTest, SubPub)
             "validated_ledgers":"10-31",
             "txn_count":8
         })";
-    ctx.restart();
-    ctx.run();
-
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(ledgerPub));
-
-    // test unsub
-    cleanReceivedFeed();
-    testFeedPtr->unsub(sessionPtr);
-    EXPECT_EQ(testFeedPtr->count(), 0);
 
+    // test publish
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(ledgerPub))).Times(1);
+    auto const ledgerinfo2 = CreateLedgerInfo(LEDGERHASH, 31);
+    auto fee2 = ripple::Fees();
+    fee2.reserve = 10;
+    testFeedPtr->pub(ledgerinfo2, fee2, "10-31", 8);
+    ctx.restart();
+    ctx.run();
+
+    // test unsub, after unsub the send should not be called
+    testFeedPtr->unsub(sessionPtr);
+    EXPECT_EQ(testFeedPtr->count(), 0);
+    EXPECT_CALL(*mockSessionPtr, send(_)).Times(0);
     testFeedPtr->pub(ledgerinfo2, fee2, "10-31", 8);
     ctx.restart();
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }
 
 TEST_F(FeedLedgerTest, AutoDisconnect)
@@ -126,8 +122,8 @@ TEST_F(FeedLedgerTest, AutoDisconnect)
     });
     ctx.run();
     EXPECT_EQ(testFeedPtr->count(), 1);
+    EXPECT_CALL(*mockSessionPtr, send(_)).Times(0);
 
-    // destroy the session
     sessionPtr.reset();
     EXPECT_EQ(testFeedPtr->count(), 0);
 

unittests/feed/ProposedTransactionFeedTests.cpp

@@ -17,20 +17,17 @@
 */
 //==============================================================================
 
-#include "feed/FeedBaseTest.h"
+#include "feed/FeedTestUtil.h"
 #include "feed/impl/ProposedTransactionFeed.h"
 #include "util/Fixtures.h"
 #include "util/MockPrometheus.h"
 #include "util/MockWsBase.h"
-#include "util/Taggable.h"
 #include "util/TestObject.h"
-#include "util/config/Config.h"
 #include "util/prometheus/Gauge.h"
 #include "web/interface/ConnectionBase.h"
 
 #include <boost/asio/io_context.hpp>
 #include <boost/json/parse.hpp>
-#include <boost/json/serialize.hpp>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
@@ -38,13 +35,14 @@
 
 constexpr static auto ACCOUNT1 = "rh1HPuRVsYYvThxG2Bs1MfjmrVC73S16Fb";
 constexpr static auto ACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun";
+constexpr static auto ACCOUNT3 = "r92yNeoiCdwULRbjh6cUBEbD71iHcqe1hE";
 constexpr static auto DUMMY_TRANSACTION =
     R"({
         "transaction":
         {
             "Account":"rh1HPuRVsYYvThxG2Bs1MfjmrVC73S16Fb",
             "Amount":"40000000",
-            "Destination":"rDgGprMjMWkJRnJ8M5RXq3SXYD8zuQncPc",
+            "Destination":"rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun",
             "Fee":"20",
             "Flags":2147483648,
             "Sequence":13767283,
@@ -66,19 +64,16 @@ TEST_F(FeedProposedTransactionTest, ProposedTransaction)
     testFeedPtr->sub(sessionPtr);
     EXPECT_EQ(testFeedPtr->transactionSubcount(), 1);
 
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(DUMMY_TRANSACTION))).Times(1);
     testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
     ctx.run();
 
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(DUMMY_TRANSACTION));
-
-    cleanReceivedFeed();
     testFeedPtr->unsub(sessionPtr);
     EXPECT_EQ(testFeedPtr->transactionSubcount(), 0);
 
     testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
     ctx.restart();
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }
 
 TEST_F(FeedProposedTransactionTest, AccountProposedTransaction)
@@ -87,29 +82,23 @@ TEST_F(FeedProposedTransactionTest, AccountProposedTransaction)
     testFeedPtr->sub(account, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
 
-    std::shared_ptr<web::ConnectionBase> const sessionIdle = std::make_shared<MockSession>(tagDecoratorFactory);
+    std::shared_ptr<web::ConnectionBase> const sessionIdle = std::make_shared<MockSession>();
-    auto const accountIdle = GetAccountIDWithString(ACCOUNT2);
+    auto const accountIdle = GetAccountIDWithString(ACCOUNT3);
     testFeedPtr->sub(accountIdle, sessionIdle);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 2);
 
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(DUMMY_TRANSACTION))).Times(1);
+
     testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
     ctx.run();
 
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(DUMMY_TRANSACTION));
-
-    auto const rawIdle = dynamic_cast<MockSession*>(sessionIdle.get());
-    ASSERT_NE(rawIdle, nullptr);
-    EXPECT_TRUE(rawIdle->message.empty());
-
     // unsub
-    cleanReceivedFeed();
     testFeedPtr->unsub(account, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
 
     testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
     ctx.restart();
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }
 
 TEST_F(FeedProposedTransactionTest, SubStreamAndAccount)
@@ -119,37 +108,27 @@ TEST_F(FeedProposedTransactionTest, SubStreamAndAccount)
     testFeedPtr->sub(sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
     EXPECT_EQ(testFeedPtr->transactionSubcount(), 1);
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(DUMMY_TRANSACTION))).Times(2);
 
     testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
     ctx.run();
 
-    EXPECT_EQ(receivedFeedMessage().size(), json::serialize(json::parse(DUMMY_TRANSACTION)).size() * 2);
-
-    cleanReceivedFeed();
-    testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
-    ctx.restart();
-    ctx.run();
-    EXPECT_EQ(receivedFeedMessage().size(), json::serialize(json::parse(DUMMY_TRANSACTION)).size() * 2);
-
     // unsub
-    cleanReceivedFeed();
     testFeedPtr->unsub(account, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(DUMMY_TRANSACTION))).Times(1);
 
     testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
     ctx.restart();
     ctx.run();
-    EXPECT_EQ(receivedFeedMessage().size(), json::serialize(json::parse(DUMMY_TRANSACTION)).size());
 
     // unsub transaction
-    cleanReceivedFeed();
     testFeedPtr->unsub(sessionPtr);
     EXPECT_EQ(testFeedPtr->transactionSubcount(), 0);
 
     testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
     ctx.restart();
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }
 
 TEST_F(FeedProposedTransactionTest, AccountProposedTransactionDuplicate)
@@ -161,39 +140,25 @@ TEST_F(FeedProposedTransactionTest, AccountProposedTransactionDuplicate)
     testFeedPtr->sub(account2, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 2);
 
-    constexpr static auto dummyTransaction =
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(DUMMY_TRANSACTION))).Times(1);
-        R"({
+    testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
-            "transaction":
-            {
-                "Account":"rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
-                "Destination":"rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"
-            }
-        })";
-
-    testFeedPtr->pub(json::parse(dummyTransaction).get_object());
     ctx.run();
 
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(dummyTransaction));
-
     // unsub account1
-    cleanReceivedFeed();
     testFeedPtr->unsub(account, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
-
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(DUMMY_TRANSACTION))).Times(1);
-    testFeedPtr->pub(json::parse(dummyTransaction).get_object());
+    testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
     ctx.restart();
     ctx.run();
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(dummyTransaction));
 
     // unsub account2
-    cleanReceivedFeed();
     testFeedPtr->unsub(account2, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
 
-    testFeedPtr->pub(json::parse(dummyTransaction).get_object());
+    testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
     ctx.restart();
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }
 
 TEST_F(FeedProposedTransactionTest, Count)
@@ -209,7 +174,7 @@ TEST_F(FeedProposedTransactionTest, Count)
     testFeedPtr->sub(account1, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
 
-    auto const sessionPtr2 = std::make_shared<MockSession>(tagDecoratorFactory);
+    auto const sessionPtr2 = std::make_shared<MockSession>();
     testFeedPtr->sub(sessionPtr2);
     EXPECT_EQ(testFeedPtr->transactionSubcount(), 2);
 
@@ -247,7 +212,7 @@ TEST_F(FeedProposedTransactionTest, AutoDisconnect)
     testFeedPtr->sub(account1, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
 
-    auto sessionPtr2 = std::make_shared<MockSession>(tagDecoratorFactory);
+    auto sessionPtr2 = std::make_shared<MockSession>();
     testFeedPtr->sub(sessionPtr2);
     EXPECT_EQ(testFeedPtr->transactionSubcount(), 2);
 
@@ -268,7 +233,6 @@ TEST_F(FeedProposedTransactionTest, AutoDisconnect)
 
 struct ProposedTransactionFeedMockPrometheusTest : WithMockPrometheus, SyncAsioContextTest {
 protected:
-    util::TagDecoratorFactory tagDecoratorFactory{util::Config{}};
     std::shared_ptr<web::ConnectionBase> sessionPtr;
     std::shared_ptr<ProposedTransactionFeed> testFeedPtr;
 
@@ -277,7 +241,7 @@ protected:
     {
         SyncAsioContextTest::SetUp();
         testFeedPtr = std::make_shared<ProposedTransactionFeed>(ctx);
-        sessionPtr = std::make_shared<MockSession>(tagDecoratorFactory);
+        sessionPtr = std::make_shared<MockSession>();
     }
     void
     TearDown() override

unittests/feed/SingleFeedBaseTests.cpp

@@ -17,13 +17,11 @@
 */
 //==============================================================================
 
-#include "feed/FeedBaseTest.h"
+#include "feed/FeedTestUtil.h"
 #include "feed/impl/SingleFeedBase.h"
 #include "util/Fixtures.h"
 #include "util/MockPrometheus.h"
 #include "util/MockWsBase.h"
-#include "util/Taggable.h"
-#include "util/config/Config.h"
 #include "util/prometheus/Gauge.h"
 #include "web/interface/ConnectionBase.h"
 
@@ -40,16 +38,17 @@ using namespace util::prometheus;
 
 struct FeedBaseMockPrometheusTest : WithMockPrometheus, SyncAsioContextTest {
 protected:
-    util::TagDecoratorFactory tagDecoratorFactory{util::Config{}};
     std::shared_ptr<web::ConnectionBase> sessionPtr;
     std::shared_ptr<SingleFeedBase> testFeedPtr;
+    MockSession* mockSessionPtr = nullptr;
 
     void
     SetUp() override
     {
         SyncAsioContextTest::SetUp();
         testFeedPtr = std::make_shared<SingleFeedBase>(ctx, "testFeed");
-        sessionPtr = std::make_shared<MockSession>(tagDecoratorFactory);
+        sessionPtr = std::make_shared<MockSession>();
+        mockSessionPtr = dynamic_cast<MockSession*>(sessionPtr.get());
     }
     void
     TearDown() override
@@ -91,29 +90,27 @@ using SingleFeedBaseTest = FeedBaseTest<NamedSingleFeedTest>;
 
 TEST_F(SingleFeedBaseTest, Test)
 {
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(FEED))).Times(1);
     testFeedPtr->sub(sessionPtr);
     EXPECT_EQ(testFeedPtr->count(), 1);
     testFeedPtr->pub(FEED);
     ctx.run();
 
-    EXPECT_EQ(receivedFeedMessage(), FEED);
     testFeedPtr->unsub(sessionPtr);
     EXPECT_EQ(testFeedPtr->count(), 0);
-    cleanReceivedFeed();
     testFeedPtr->pub(FEED);
     ctx.restart();
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }
 
 TEST_F(SingleFeedBaseTest, TestAutoDisconnect)
 {
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(FEED))).Times(1);
     testFeedPtr->sub(sessionPtr);
     EXPECT_EQ(testFeedPtr->count(), 1);
     testFeedPtr->pub(FEED);
     ctx.run();
 
-    EXPECT_EQ(receivedFeedMessage(), FEED);
     sessionPtr.reset();
     EXPECT_EQ(testFeedPtr->count(), 0);
 }

unittests/feed/SubscriptionManagerTests.cpp

@@ -18,12 +18,11 @@
 //==============================================================================
 
 #include "data/Types.h"
+#include "feed/FeedTestUtil.h"
 #include "feed/SubscriptionManager.h"
 #include "util/Fixtures.h"
 #include "util/MockWsBase.h"
-#include "util/Taggable.h"
 #include "util/TestObject.h"
-#include "util/config/Config.h"
 #include "web/interface/ConnectionBase.h"
 
 #include <boost/asio/executor_work_guard.hpp>
@@ -31,7 +30,6 @@
 #include <boost/asio/spawn.hpp>
 #include <boost/json/object.hpp>
 #include <boost/json/parse.hpp>
-#include <boost/json/serialize.hpp>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <ripple/protocol/Book.h>
@@ -56,10 +54,9 @@ using namespace feed::impl;
 
 class SubscriptionManagerTest : public MockBackendTest, public SyncAsioContextTest {
 protected:
-    util::Config cfg;
     std::shared_ptr<SubscriptionManager> SubscriptionManagerPtr;
-    util::TagDecoratorFactory tagDecoratorFactory{cfg};
     std::shared_ptr<web::ConnectionBase> session;
+    MockSession* sessionPtr = nullptr;
 
     void
     SetUp() override
@@ -67,7 +64,8 @@ protected:
         MockBackendTest::SetUp();
         SyncAsioContextTest::SetUp();
         SubscriptionManagerPtr = std::make_shared<SubscriptionManager>(ctx, backend);
-        session = std::make_shared<MockSession>(tagDecoratorFactory);
+        session = std::make_shared<MockSession>();
+        sessionPtr = dynamic_cast<MockSession*>(session.get());
     }
 
     void
@@ -78,22 +76,6 @@ protected:
         SyncAsioContextTest::TearDown();
         MockBackendTest::TearDown();
     }
-
-    std::string const&
-    receivedFeedMessage() const
-    {
-        auto const mockSession = dynamic_cast<MockSession*>(session.get());
-        [&] { ASSERT_NE(mockSession, nullptr); }();
-        return mockSession->message;
-    }
-
-    void
-    cleanReceivedFeed()
-    {
-        auto mockSession = dynamic_cast<MockSession*>(session.get());
-        [&] { ASSERT_NE(mockSession, nullptr); }();
-        mockSession->message.clear();
-    }
 };
 
 // TODO enable when fixed :/
@@ -106,8 +88,14 @@ TEST_F(SubscriptionManagerTest, MultipleThreadCtx)
     SubscriptionManagerPtr->subManifest(session);
     SubscriptionManagerPtr->subValidation(session);
 
-    SubscriptionManagerPtr->forwardManifest(json::parse(R"({"manifest":"test"})").get_object());
+    constexpr static auto jsonManifest = R"({"manifest":"test"})";
-    SubscriptionManagerPtr->forwardValidation(json::parse(R"({"validation":"test"})").get_object());
+    constexpr static auto jsonValidation = R"({"validation":"test"})";
+
+    EXPECT_CALL(*sessionPtr, send(SharedStringJsonEq(jsonManifest))).Times(1);
+    EXPECT_CALL(*sessionPtr, send(SharedStringJsonEq(jsonValidation))).Times(1);
+
+    SubscriptionManagerPtr->forwardManifest(json::parse(jsonManifest).get_object());
+    SubscriptionManagerPtr->forwardValidation(json::parse(jsonValidation).get_object());
 
     for (int i = 0; i < 2; ++i)
         workers.emplace_back([this]() { ctx.run(); });
@@ -116,12 +104,6 @@ TEST_F(SubscriptionManagerTest, MultipleThreadCtx)
     for (auto& worker : workers)
         worker.join();
 
-    EXPECT_TRUE(
-        receivedFeedMessage() == R"({"manifest":"test"}{"validation":"test"})" ||
-        receivedFeedMessage() == R"({"validation":"test"}{"manifest":"test"})"
-    ) << "receivedFeedMessage() = "
-      << receivedFeedMessage();
-
     session.reset();
     SubscriptionManagerPtr.reset();
 }
@@ -166,8 +148,8 @@ TEST_F(SubscriptionManagerTest, ReportCurrentSubscriber)
             "books":2,
             "book_changes":2
         })";
-    std::shared_ptr<web::ConnectionBase> const session1 = std::make_shared<MockSession>(tagDecoratorFactory);
+    std::shared_ptr<web::ConnectionBase> const session1 = std::make_shared<MockSession>();
-    std::shared_ptr<web::ConnectionBase> session2 = std::make_shared<MockSession>(tagDecoratorFactory);
+    std::shared_ptr<web::ConnectionBase> session2 = std::make_shared<MockSession>();
     SubscriptionManagerPtr->subBookChanges(session1);
     SubscriptionManagerPtr->subBookChanges(session2);
     SubscriptionManagerPtr->subManifest(session1);
@@ -222,34 +204,31 @@ TEST_F(SubscriptionManagerTest, ReportCurrentSubscriber)
 
 TEST_F(SubscriptionManagerTest, ManifestTest)
 {
-    SubscriptionManagerPtr->subManifest(session);
     constexpr static auto dummyManifest = R"({"manifest":"test"})";
+    EXPECT_CALL(*sessionPtr, send(SharedStringJsonEq(dummyManifest))).Times(1);
+    SubscriptionManagerPtr->subManifest(session);
     SubscriptionManagerPtr->forwardManifest(json::parse(dummyManifest).get_object());
     ctx.run();
 
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(dummyManifest));
+    EXPECT_CALL(*sessionPtr, send(SharedStringJsonEq(dummyManifest))).Times(0);
-
-    cleanReceivedFeed();
     SubscriptionManagerPtr->unsubManifest(session);
     SubscriptionManagerPtr->forwardManifest(json::parse(dummyManifest).get_object());
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }
 
 TEST_F(SubscriptionManagerTest, ValidationTest)
 {
+    constexpr static auto dummy = R"({"validation":"test"})";
+    EXPECT_CALL(*sessionPtr, send(SharedStringJsonEq(dummy))).Times(1);
     SubscriptionManagerPtr->subValidation(session);
-    constexpr static auto dummyManifest = R"({"validation":"test"})";
+    SubscriptionManagerPtr->forwardValidation(json::parse(dummy).get_object());
-    SubscriptionManagerPtr->forwardValidation(json::parse(dummyManifest).get_object());
     ctx.run();
 
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(dummyManifest));
+    EXPECT_CALL(*sessionPtr, send(SharedStringJsonEq(dummy))).Times(0);
-    cleanReceivedFeed();
     SubscriptionManagerPtr->unsubValidation(session);
-    SubscriptionManagerPtr->forwardValidation(json::parse(dummyManifest).get_object());
+    SubscriptionManagerPtr->forwardValidation(json::parse(dummy).get_object());
     ctx.restart();
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }
 
 TEST_F(SubscriptionManagerTest, BookChangesTest)
@@ -288,10 +267,9 @@ TEST_F(SubscriptionManagerTest, BookChangesTest)
                 }
             ]
         })";
+    EXPECT_CALL(*sessionPtr, send(SharedStringJsonEq(bookChangePublish))).Times(1);
     ctx.run();
 
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(bookChangePublish));
-
     SubscriptionManagerPtr->unsubBookChanges(session);
     EXPECT_EQ(SubscriptionManagerPtr->report()["book_changes"], 0);
 }
@@ -343,11 +321,10 @@ TEST_F(SubscriptionManagerTest, LedgerTest)
             "validated_ledgers":"10-31",
             "txn_count":8
         })";
+    EXPECT_CALL(*sessionPtr, send(SharedStringJsonEq(ledgerPub))).Times(1);
     ctx.restart();
     ctx.run();
 
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(ledgerPub));
-
     // test unsub
     SubscriptionManagerPtr->unsubLedger(session);
     EXPECT_EQ(SubscriptionManagerPtr->report()["ledger"], 0);
@@ -429,17 +406,15 @@ TEST_F(SubscriptionManagerTest, TransactionTest)
             "validated":true,
             "status":"closed",
             "ledger_index":33,
-            "ledger_hash":"1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC",
+            "ledger_hash":"4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652",
             "engine_result_code":0,
             "engine_result":"tesSUCCESS",
             "close_time_iso": "2000-01-01T00:00:00Z",
             "engine_result_message":"The transaction was applied. Only final in a validated ledger."
         })";
-
+    EXPECT_CALL(*sessionPtr, send(SharedStringJsonEq(OrderbookPublish))).Times(3);
     ctx.run();
 
-    EXPECT_EQ(receivedFeedMessage().size(), json::serialize(json::parse(OrderbookPublish)).size() * 3);
-
     SubscriptionManagerPtr->unsubBook(book, session);
     SubscriptionManagerPtr->unsubTransactions(session);
     SubscriptionManagerPtr->unsubAccount(account, session);
@@ -464,14 +439,11 @@ TEST_F(SubscriptionManagerTest, ProposedTransactionTest)
                 "Destination":"rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"
             }
         })";
-
+    EXPECT_CALL(*sessionPtr, send(SharedStringJsonEq(dummyTransaction))).Times(2);
     SubscriptionManagerPtr->forwardProposedTransaction(json::parse(dummyTransaction).get_object());
     ctx.run();
 
-    EXPECT_EQ(receivedFeedMessage().size(), json::serialize(json::parse(dummyTransaction)).size() * 2);
-
     // unsub account1
-    cleanReceivedFeed();
     SubscriptionManagerPtr->unsubProposedAccount(account, session);
     EXPECT_EQ(SubscriptionManagerPtr->report()["accounts_proposed"], 0);
     SubscriptionManagerPtr->unsubProposedTransactions(session);

unittests/feed/TrackableSignalTests.cpp

@@ -20,8 +20,6 @@
 #include "feed/impl/TrackableSignal.h"
 #include "feed/impl/TrackableSignalMap.h"
 #include "util/MockWsBase.h"
-#include "util/Taggable.h"
-#include "util/config/Config.h"
 #include "web/interface/ConnectionBase.h"
 
 #include <gtest/gtest.h>
@@ -33,19 +31,17 @@ using namespace testing;
 
 struct FeedTrackableSignalTests : Test {
 protected:
-    util::TagDecoratorFactory tagDecoratorFactory{util::Config{}};
     std::shared_ptr<web::ConnectionBase> sessionPtr;
 
     void
     SetUp() override
     {
-        sessionPtr = std::make_shared<MockSession>(tagDecoratorFactory);
+        sessionPtr = std::make_shared<MockSession>();
     }
 
     void
     TearDown() override
     {
-        sessionPtr.reset();
     }
 };
 

unittests/feed/TransactionFeedTests.cpp

@@ -18,20 +18,16 @@
 //==============================================================================
 
 #include "data/Types.h"
-#include "feed/FeedBaseTest.h"
+#include "feed/FeedTestUtil.h"
 #include "feed/impl/TransactionFeed.h"
 #include "util/Fixtures.h"
 #include "util/MockPrometheus.h"
 #include "util/MockWsBase.h"
-#include "util/Taggable.h"
 #include "util/TestObject.h"
-#include "util/config/Config.h"
 #include "util/prometheus/Gauge.h"
 #include "web/interface/ConnectionBase.h"
 
 #include <boost/asio/io_context.hpp>
-#include <boost/json/parse.hpp>
-#include <boost/json/serialize.hpp>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <ripple/basics/base_uint.h>
@@ -164,7 +160,6 @@ constexpr static auto TRAN_V2 =
 
 using namespace feed::impl;
 using namespace util::prometheus;
-namespace json = boost::json;
 
 using FeedTransactionTest = FeedBaseTest<TransactionFeed>;
 
@@ -181,18 +176,15 @@ TEST_F(FeedTransactionTest, SubTransactionV1)
     trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
     testFeedPtr->pub(trans1, ledgerinfo, backend);
 
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V1))).Times(1);
     ctx.run();
 
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(TRAN_V1));
-
     testFeedPtr->unsub(sessionPtr);
     EXPECT_EQ(testFeedPtr->transactionSubCount(), 0);
 
-    cleanReceivedFeed();
     testFeedPtr->pub(trans1, ledgerinfo, backend);
     ctx.restart();
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }
 
 TEST_F(FeedTransactionTest, SubTransactionV2)
@@ -207,19 +199,16 @@ TEST_F(FeedTransactionTest, SubTransactionV2)
     trans1.ledgerSequence = 32;
     trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
     testFeedPtr->pub(trans1, ledgerinfo, backend);
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V2))).Times(1);
 
     ctx.run();
 
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(TRAN_V2));
-
     testFeedPtr->unsub(sessionPtr);
     EXPECT_EQ(testFeedPtr->transactionSubCount(), 0);
 
-    cleanReceivedFeed();
     testFeedPtr->pub(trans1, ledgerinfo, backend);
     ctx.restart();
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }
 
 TEST_F(FeedTransactionTest, SubAccountV1)
@@ -235,20 +224,16 @@ TEST_F(FeedTransactionTest, SubAccountV1)
     trans1.transaction = obj.getSerializer().peekData();
     trans1.ledgerSequence = 32;
     trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
-
     testFeedPtr->pub(trans1, ledgerinfo, backend);
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V1))).Times(1);
     ctx.run();
 
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(TRAN_V1));
-
     testFeedPtr->unsub(account, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
 
-    cleanReceivedFeed();
     testFeedPtr->pub(trans1, ledgerinfo, backend);
     ctx.restart();
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }
 
 TEST_F(FeedTransactionTest, SubAccountV2)
@@ -266,18 +251,15 @@ TEST_F(FeedTransactionTest, SubAccountV2)
     trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
 
     testFeedPtr->pub(trans1, ledgerinfo, backend);
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V2))).Times(1);
     ctx.run();
 
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(TRAN_V2));
-
     testFeedPtr->unsub(account, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
 
-    cleanReceivedFeed();
     testFeedPtr->pub(trans1, ledgerinfo, backend);
     ctx.restart();
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }
 
 TEST_F(FeedTransactionTest, SubBothTransactionAndAccount)
@@ -297,26 +279,18 @@ TEST_F(FeedTransactionTest, SubBothTransactionAndAccount)
     trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
 
     testFeedPtr->pub(trans1, ledgerinfo, backend);
-    ctx.run();
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V2))).Times(2);
 
-    EXPECT_EQ(receivedFeedMessage().size(), json::serialize(json::parse(TRAN_V2)).size() * 2);
-
-    cleanReceivedFeed();
-    testFeedPtr->pub(trans1, ledgerinfo, backend);
-    ctx.restart();
     ctx.run();
-    EXPECT_EQ(receivedFeedMessage().size(), json::serialize(json::parse(TRAN_V2)).size() * 2);
 
     testFeedPtr->unsub(account, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
     testFeedPtr->unsub(sessionPtr);
     EXPECT_EQ(testFeedPtr->transactionSubCount(), 0);
 
-    cleanReceivedFeed();
     testFeedPtr->pub(trans1, ledgerinfo, backend);
     ctx.restart();
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }
 
 TEST_F(FeedTransactionTest, SubBookV1)
@@ -396,12 +370,9 @@ TEST_F(FeedTransactionTest, SubBookV1)
             "engine_result_message":"The transaction was applied. Only final in a validated ledger."
         })";
 
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(OrderbookPublish))).Times(1);
     ctx.run();
 
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(OrderbookPublish));
-
-    cleanReceivedFeed();
-
     // trigger by offer cancel meta data
     metaObj = CreateMetaDataForCancelOffer(CURRENCY, ISSUER, 22, 3, 1);
     trans1.metadata = metaObj.getSerializer().peekData();
@@ -455,8 +426,8 @@ TEST_F(FeedTransactionTest, SubBookV1)
             "engine_result_message":"The transaction was applied. Only final in a validated ledger."
         })";
     ctx.restart();
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(OrderbookCancelPublish))).Times(1);
     ctx.run();
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(OrderbookCancelPublish));
 
     // trigger by offer create meta data
     constexpr static auto OrderbookCreatePublish =
@@ -511,19 +482,16 @@ TEST_F(FeedTransactionTest, SubBookV1)
     metaObj = CreateMetaDataForCreateOffer(CURRENCY, ISSUER, 22, 3, 1);
     trans1.metadata = metaObj.getSerializer().peekData();
     testFeedPtr->pub(trans1, ledgerinfo, backend);
-    cleanReceivedFeed();
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(OrderbookCreatePublish))).Times(1);
     ctx.restart();
     ctx.run();
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(OrderbookCreatePublish));
 
     testFeedPtr->unsub(book, sessionPtr);
     EXPECT_EQ(testFeedPtr->bookSubCount(), 0);
 
-    cleanReceivedFeed();
     testFeedPtr->pub(trans1, ledgerinfo, backend);
     ctx.restart();
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }
 
 TEST_F(FeedTransactionTest, SubBookV2)
@@ -603,18 +571,15 @@ TEST_F(FeedTransactionTest, SubBookV2)
             "engine_result_message":"The transaction was applied. Only final in a validated ledger."
         })";
 
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(OrderbookPublish))).Times(1);
     ctx.run();
 
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(OrderbookPublish));
-
     testFeedPtr->unsub(book, sessionPtr);
     EXPECT_EQ(testFeedPtr->bookSubCount(), 0);
 
-    cleanReceivedFeed();
     testFeedPtr->pub(trans1, ledgerinfo, backend);
     ctx.restart();
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }
 
 TEST_F(FeedTransactionTest, TransactionContainsBothAccountsSubed)
@@ -634,27 +599,22 @@ TEST_F(FeedTransactionTest, TransactionContainsBothAccountsSubed)
     trans1.ledgerSequence = 32;
     trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
     testFeedPtr->pub(trans1, ledgerinfo, backend);
-
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V2))).Times(1);
     ctx.run();
 
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(TRAN_V2));
-
     testFeedPtr->unsub(account, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
 
-    cleanReceivedFeed();
     testFeedPtr->pub(trans1, ledgerinfo, backend);
     ctx.restart();
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V2))).Times(1);
     ctx.run();
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(TRAN_V2));
 
-    cleanReceivedFeed();
     testFeedPtr->unsub(account2, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
     testFeedPtr->pub(trans1, ledgerinfo, backend);
     ctx.restart();
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }
 
 TEST_F(FeedTransactionTest, SubAccountRepeatWithDifferentVersion)
@@ -674,27 +634,23 @@ TEST_F(FeedTransactionTest, SubAccountRepeatWithDifferentVersion)
     trans1.ledgerSequence = 32;
     trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
     testFeedPtr->pub(trans1, ledgerinfo, backend);
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V2))).Times(1);
     ctx.run();
 
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(TRAN_V2));
-
     testFeedPtr->unsub(account, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
 
-    cleanReceivedFeed();
     testFeedPtr->pub(trans1, ledgerinfo, backend);
     ctx.restart();
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V2))).Times(1);
     ctx.run();
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(TRAN_V2));
 
     testFeedPtr->unsub(account2, sessionPtr);
     EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
 
-    cleanReceivedFeed();
     testFeedPtr->pub(trans1, ledgerinfo, backend);
     ctx.restart();
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }
 
 TEST_F(FeedTransactionTest, SubTransactionRepeatWithDifferentVersion)
@@ -713,24 +669,20 @@ TEST_F(FeedTransactionTest, SubTransactionRepeatWithDifferentVersion)
     trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
 
     testFeedPtr->pub(trans1, ledgerinfo, backend);
-
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V1))).Times(1);
     ctx.run();
 
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(TRAN_V1));
-
     testFeedPtr->unsub(sessionPtr);
     EXPECT_EQ(testFeedPtr->transactionSubCount(), 0);
-    cleanReceivedFeed();
 
     testFeedPtr->pub(trans1, ledgerinfo, backend);
     ctx.restart();
     ctx.run();
-    EXPECT_TRUE(receivedFeedMessage().empty());
 }
 
 TEST_F(FeedTransactionTest, SubRepeat)
 {
-    auto const session2 = std::make_shared<MockSession>(tagDecoratorFactory);
+    auto const session2 = std::make_shared<MockSession>();
 
     testFeedPtr->sub(sessionPtr, 1);
     testFeedPtr->sub(session2, 1);
@@ -852,8 +804,8 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFund)
             "engine_result_message":"The transaction was applied. Only final in a validated ledger."
         })";
 
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TransactionForOwnerFund))).Times(1);
     ctx.run();
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(TransactionForOwnerFund));
 }
 
 constexpr static auto TRAN_FROZEN =
@@ -926,9 +878,8 @@ TEST_F(FeedTransactionTest, PubTransactionOfferCreationFrozenLine)
     ON_CALL(*backend, doFetchLedgerObject(kk, testing::_, testing::_))
         .WillByDefault(testing::Return(accountRoot.getSerializer().peekData()));
     testFeedPtr->pub(trans1, ledgerinfo, backend);
-
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_FROZEN))).Times(1);
     ctx.run();
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(TRAN_FROZEN));
 }
 
 TEST_F(FeedTransactionTest, SubTransactionOfferCreationGlobalFrozen)
@@ -966,13 +917,12 @@ TEST_F(FeedTransactionTest, SubTransactionOfferCreationGlobalFrozen)
         .WillByDefault(testing::Return(accountRoot.getSerializer().peekData()));
     testFeedPtr->pub(trans1, ledgerinfo, backend);
 
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_FROZEN))).Times(1);
     ctx.run();
-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(TRAN_FROZEN));
 }
 
 struct TransactionFeedMockPrometheusTest : WithMockPrometheus, SyncAsioContextTest {
 protected:
-    util::TagDecoratorFactory tagDecoratorFactory{util::Config{}};
     std::shared_ptr<web::ConnectionBase> sessionPtr;
     std::shared_ptr<TransactionFeed> testFeedPtr;
 
@@ -981,7 +931,7 @@ protected:
     {
         SyncAsioContextTest::SetUp();
         testFeedPtr = std::make_shared<TransactionFeed>(ctx);
-        sessionPtr = std::make_shared<MockSession>(tagDecoratorFactory);
+        sessionPtr = std::make_shared<MockSession>();
     }
     void
     TearDown() override

unittests/rpc/handlers/SubscribeTests.cpp

@@ -27,9 +27,7 @@
 #include "util/Fixtures.h"
 #include "util/MockPrometheus.h"
 #include "util/MockWsBase.h"
-#include "util/Taggable.h"
 #include "util/TestObject.h"
-#include "util/config/Config.h"
 #include "web/interface/ConnectionBase.h"
 
 #include <boost/json/parse.hpp>
@@ -72,8 +70,7 @@ protected:
         HandlerBaseTest::SetUp();
 
         subManager_ = std::make_shared<feed::SubscriptionManager>(ctx, backend);
-        util::TagDecoratorFactory const tagDecoratorFactory{util::Config{}};
+        session_ = std::make_shared<MockSession>();
-        session_ = std::make_shared<MockSession>(tagDecoratorFactory);
     }
     void
     TearDown() override

unittests/rpc/handlers/UnsubscribeTests.cpp

@@ -25,8 +25,6 @@
 #include "util/Fixtures.h"
 #include "util/MockSubscriptionManager.h"
 #include "util/MockWsBase.h"
-#include "util/Taggable.h"
-#include "util/config/Config.h"
 #include "web/interface/ConnectionBase.h"
 
 #include <boost/json/parse.hpp>
@@ -56,9 +54,7 @@ protected:
     {
         HandlerBaseTest::SetUp();
         MockSubscriptionManagerTest::SetUp();
-        util::Config const cfg;
+        session_ = std::make_shared<MockSession>();
-        util::TagDecoratorFactory const tagDecoratorFactory{cfg};
-        session_ = std::make_shared<MockSession>(tagDecoratorFactory);
     }
     void
     TearDown() override

unittests/util/MockWsBase.h

@@ -20,29 +20,21 @@
 #pragma once
 
 #include "util/Taggable.h"
+#include "util/config/Config.h"
 #include "web/interface/ConnectionBase.h"
 
 #include <boost/beast/http/status.hpp>
+#include <gmock/gmock.h>
 
 #include <memory>
 #include <string>
 
 struct MockSession : public web::ConnectionBase {
-    std::string message;
+    MOCK_METHOD(void, send, (std::shared_ptr<std::string>), (override));
-    void
+    MOCK_METHOD(void, send, (std::string&&, boost::beast::http::status), (override));
-    send(std::shared_ptr<std::string> msg_type) override
+    util::TagDecoratorFactory tagDecoratorFactory{util::Config{}};
-    {
-        message += std::string(msg_type->data());
-    }
 
-    void
+    MockSession() : web::ConnectionBase(tagDecoratorFactory, "")
-    // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
-    send(std::string&& msg, boost::beast::http::status = boost::beast::http::status::ok) override
-    {
-        message += msg;
-    }
-
-    MockSession(util::TagDecoratorFactory const& factory) : web::ConnectionBase(factory, "")
     {
     }
 };