Fix unstable unittest (#1102)

Properly mock wsbase
2025-11-20 11:45:53 +00:00 · 2024-01-15 12:06:14 +00:00
parent ce86572274
commit 350a45e7e2
12 changed files with 140 additions and 261 deletions
--- a/unittests/feed/BookChangesFeedTests.cpp
+++ b/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());
 }
--- a/unittests/feed/FeedTestUtil.h
+++ b/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&
-    receivedFeedMessage() const
+namespace detail {
+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());
-        [&] { ASSERT_NE(mockSession, nullptr); }();
-        mockSession->message.clear();
+        *os << "Contains json " << expected_;
+    }
+
+    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);
+}
--- a/unittests/feed/ForwardFeedTests.cpp
+++ b/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);
--- a/unittests/feed/LedgerFeedTests.cpp
+++ b/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);

--- a/unittests/feed/ProposedTransactionFeedTests.cpp
+++ b/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);
-    auto const accountIdle = GetAccountIDWithString(ACCOUNT2);
+    std::shared_ptr<web::ConnectionBase> const sessionIdle = std::make_shared<MockSession>();
+    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 =
-        R"({
-            "transaction":
-            {
-                "Account":"rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
-                "Destination":"rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"
-            }
-        })";
-
-    testFeedPtr->pub(json::parse(dummyTransaction).get_object());
+    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(dummyTransaction));
-
    // unsub account1
-    cleanReceivedFeed();
    testFeedPtr->unsub(account, sessionPtr);
    EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
-
-    testFeedPtr->pub(json::parse(dummyTransaction).get_object());
+    EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(DUMMY_TRANSACTION))).Times(1);
+    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
--- a/unittests/feed/SingleFeedBaseTests.cpp
+++ b/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);
 }
--- a/unittests/feed/SubscriptionManagerTests.cpp
+++ b/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());
-    SubscriptionManagerPtr->forwardValidation(json::parse(R"({"validation":"test"})").get_object());
+    constexpr static auto jsonManifest = R"({"manifest":"test"})";
+    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> session2 = 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>();
    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));
-
-    cleanReceivedFeed();
+    EXPECT_CALL(*sessionPtr, send(SharedStringJsonEq(dummyManifest))).Times(0);
    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(dummyManifest).get_object());
+    SubscriptionManagerPtr->forwardValidation(json::parse(dummy).get_object());
    ctx.run();

-    EXPECT_EQ(json::parse(receivedFeedMessage()), json::parse(dummyManifest));
-    cleanReceivedFeed();
+    EXPECT_CALL(*sessionPtr, send(SharedStringJsonEq(dummy))).Times(0);
    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);
--- a/unittests/feed/TrackableSignalTests.cpp
+++ b/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();
    }
 };

--- a/unittests/feed/TransactionFeedTests.cpp
+++ b/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
--- a/unittests/rpc/handlers/SubscribeTests.cpp
+++ b/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>(tagDecoratorFactory);
+        session_ = std::make_shared<MockSession>();
    }
    void
    TearDown() override
--- a/unittests/rpc/handlers/UnsubscribeTests.cpp
+++ b/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;
-        util::TagDecoratorFactory const tagDecoratorFactory{cfg};
-        session_ = std::make_shared<MockSession>(tagDecoratorFactory);
+        session_ = std::make_shared<MockSession>();
    }
    void
    TearDown() override
--- a/unittests/util/MockWsBase.h
+++ b/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;
-    void
-    send(std::shared_ptr<std::string> msg_type) override
-    {
-        message += std::string(msg_type->data());
-    }
+    MOCK_METHOD(void, send, (std::shared_ptr<std::string>), (override));
+    MOCK_METHOD(void, send, (std::string&&, boost::beast::http::status), (override));
+    util::TagDecoratorFactory tagDecoratorFactory{util::Config{}};

-    void
-    // 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, "")
+    MockSession() : web::ConnectionBase(tagDecoratorFactory, "")
    {
    }
 };