ARCHIVE/clio
1
0
Fork 0
mirror of https://github.com/XRPLF/clio.git synced 2025-12-06 17:27:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: No ALL_CAPS (#1760)

Browse Source 
Fixes #1680
This commit is contained in:
Alex Kremer
2025-01-02 11:39:31 +00:00
committed by GitHub
parent efe5d08205
commit 820b32c6d7
361 changed files with 10061 additions and 9724 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
tests/unit/feed/BookChangesFeedTests.cpp
View File

@@ -31,11 +31,15 @@
using namespace feed::impl;
constexpr static auto LEDGERHASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652";
constexpr static auto ACCOUNT1 = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn";
constexpr static auto ACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun";
constexpr static auto CURRENCY = "0158415500000000C1F76FF6ECB0BAC600000000";
constexpr static auto ISSUER = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD";
namespace {
constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652";
constexpr auto kACCOUNT1 = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn";
constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun";
constexpr auto kCURRENCY = "0158415500000000C1F76FF6ECB0BAC600000000";
constexpr auto kISSUER = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD";
} // namespace
using FeedBookChangeTest = FeedBaseTest<BookChangesFeed>;
@@ -45,17 +49,17 @@ TEST_F(FeedBookChangeTest, Pub)
testFeedPtr->sub(sessionPtr);
EXPECT_EQ(testFeedPtr->count(), 1);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 32);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 32);
auto transactions = std::vector<TransactionAndMetadata>{};
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
ripple::STObject const metaObj = CreateMetaDataForBookChange(CURRENCY, ISSUER, 22, 1, 3, 3, 1);
ripple::STObject const metaObj = createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 1, 3, 3, 1);
trans1.metadata = metaObj.getSerializer().peekData();
transactions.push_back(trans1);
constexpr static auto bookChangePublish =
static constexpr auto kBOOK_CHANGE_PUBLISH =
R"({
"type":"bookChanges",
"ledger_index":32,
@@ -76,7 +80,7 @@ TEST_F(FeedBookChangeTest, Pub)
]
})";
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(bookChangePublish))).Times(1);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kBOOK_CHANGE_PUBLISH))).Times(1);
testFeedPtr->pub(ledgerHeader, transactions);
testFeedPtr->unsub(sessionPtr);

14
tests/unit/feed/ForwardFeedTests.cpp
View File

@@ -32,7 +32,11 @@ using namespace feed::impl;
namespace json = boost::json;
using namespace util::prometheus;
constexpr static auto FEED = R"({"test":"test"})";
namespace {
constexpr auto kFEED = R"({"test":"test"})";
} // namespace
class NamedForwardFeedTest : public ForwardFeed {
public:
@@ -49,8 +53,8 @@ TEST_F(FeedForwardTest, Pub)
testFeedPtr->sub(sessionPtr);
EXPECT_EQ(testFeedPtr->count(), 1);
auto const json = json::parse(FEED).as_object();
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(FEED))).Times(1);
auto const json = json::parse(kFEED).as_object();
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kFEED))).Times(1);
testFeedPtr->pub(json);
testFeedPtr->unsub(sessionPtr);
@@ -65,8 +69,8 @@ TEST_F(FeedForwardTest, AutoDisconnect)
testFeedPtr->sub(sessionPtr);
EXPECT_EQ(testFeedPtr->count(), 1);
auto const json = json::parse(FEED).as_object();
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(FEED)));
auto const json = json::parse(kFEED).as_object();
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kFEED)));
testFeedPtr->pub(json);
slot(sessionPtr.get());

46
tests/unit/feed/LedgerFeedTests.cpp
View File

@@ -29,7 +29,9 @@
#include <gtest/gtest.h>
#include <xrpl/protocol/Fees.h>
constexpr static auto LEDGERHASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652";
namespace {
constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652";
} // namespace
using namespace feed::impl;
namespace json = boost::json;
@@ -39,17 +41,17 @@ using FeedLedgerTest = FeedBaseTest<LedgerFeed>;
TEST_F(FeedLedgerTest, SubPub)
{
backend->setRange(10, 30);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 30);
EXPECT_CALL(*backend, fetchLedgerBySequence).WillOnce(testing::Return(ledgerHeader));
backend_->setRange(10, 30);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30);
EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(testing::Return(ledgerHeader));
auto const feeBlob = CreateLegacyFeeSettingBlob(1, 2, 3, 4, 0);
EXPECT_CALL(*backend, doFetchLedgerObject).WillOnce(testing::Return(feeBlob));
auto const feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0);
EXPECT_CALL(*backend_, doFetchLedgerObject).WillOnce(testing::Return(feeBlob));
// check the function response
// Information about the ledgers on hand and current fee schedule. This
// includes the same fields as a ledger stream message, except that it omits
// the type and txn_count fields
constexpr static auto LedgerResponse =
static constexpr auto kLEDGER_RESPONSE =
R"({
"validated_ledgers":"10-30",
"ledger_index":30,
@@ -62,14 +64,14 @@ TEST_F(FeedLedgerTest, SubPub)
boost::asio::io_context ioContext;
boost::asio::spawn(ioContext, [this](boost::asio::yield_context yield) {
EXPECT_CALL(*mockSessionPtr, onDisconnect);
auto res = testFeedPtr->sub(yield, backend, sessionPtr);
auto res = testFeedPtr->sub(yield, backend_, sessionPtr);
// check the response
EXPECT_EQ(res, json::parse(LedgerResponse));
EXPECT_EQ(res, json::parse(kLEDGER_RESPONSE));
});
ioContext.run();
EXPECT_EQ(testFeedPtr->count(), 1);
constexpr static auto ledgerPub =
static constexpr auto kLEDGER_PUB =
R"({
"type":"ledgerClosed",
"ledger_index":31,
@@ -83,8 +85,8 @@ TEST_F(FeedLedgerTest, SubPub)
})";
// test publish
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(ledgerPub))).Times(1);
auto const ledgerHeader2 = CreateLedgerHeader(LEDGERHASH, 31);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kLEDGER_PUB))).Times(1);
auto const ledgerHeader2 = createLedgerHeader(kLEDGER_HASH, 31);
auto fee2 = ripple::Fees();
fee2.reserve = 10;
testFeedPtr->pub(ledgerHeader2, fee2, "10-31", 8);
@@ -98,13 +100,13 @@ TEST_F(FeedLedgerTest, SubPub)
TEST_F(FeedLedgerTest, AutoDisconnect)
{
backend->setRange(10, 30);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 30);
EXPECT_CALL(*backend, fetchLedgerBySequence).WillOnce(testing::Return(ledgerHeader));
backend_->setRange(10, 30);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30);
EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(testing::Return(ledgerHeader));
auto const feeBlob = CreateLegacyFeeSettingBlob(1, 2, 3, 4, 0);
EXPECT_CALL(*backend, doFetchLedgerObject).WillOnce(testing::Return(feeBlob));
constexpr static auto LedgerResponse =
auto const feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0);
EXPECT_CALL(*backend_, doFetchLedgerObject).WillOnce(testing::Return(feeBlob));
static constexpr auto kLEDGER_RESPONSE =
R"({
"validated_ledgers":"10-30",
"ledger_index":30,
@@ -118,10 +120,10 @@ TEST_F(FeedLedgerTest, AutoDisconnect)
web::SubscriptionContextInterface::OnDisconnectSlot slot;
EXPECT_CALL(*mockSessionPtr, onDisconnect).WillOnce(testing::SaveArg<0>(&slot));
boost::asio::spawn(ctx, [this](boost::asio::yield_context yield) {
auto res = testFeedPtr->sub(yield, backend, sessionPtr);
boost::asio::spawn(ctx_, [this](boost::asio::yield_context yield) {
auto res = testFeedPtr->sub(yield, backend_, sessionPtr);
// check the response
EXPECT_EQ(res, json::parse(LedgerResponse));
EXPECT_EQ(res, json::parse(kLEDGER_RESPONSE));
});
EXPECT_EQ(testFeedPtr->count(), 1);
EXPECT_CALL(*mockSessionPtr, send(_)).Times(0);
@@ -132,7 +134,7 @@ TEST_F(FeedLedgerTest, AutoDisconnect)
EXPECT_EQ(testFeedPtr->count(), 0);
auto const ledgerHeader2 = CreateLedgerHeader(LEDGERHASH, 31);
auto const ledgerHeader2 = createLedgerHeader(kLEDGER_HASH, 31);
auto fee2 = ripple::Fees();
fee2.reserve = 10;
// no error

96
tests/unit/feed/ProposedTransactionFeedTests.cpp
View File

@@ -34,10 +34,12 @@
#include <memory>
#include <vector>
constexpr static auto ACCOUNT1 = "rh1HPuRVsYYvThxG2Bs1MfjmrVC73S16Fb";
constexpr static auto ACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun";
constexpr static auto ACCOUNT3 = "r92yNeoiCdwULRbjh6cUBEbD71iHcqe1hE";
constexpr static auto DUMMY_TRANSACTION =
namespace {
constexpr auto kACCOUNT1 = "rh1HPuRVsYYvThxG2Bs1MfjmrVC73S16Fb";
constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun";
constexpr auto kACCOUNT3 = "r92yNeoiCdwULRbjh6cUBEbD71iHcqe1hE";
constexpr auto kDUMMY_TRANSACTION =
R"({
"transaction":
{
@@ -54,6 +56,8 @@ constexpr static auto DUMMY_TRANSACTION =
}
})";
} // namespace
using namespace feed::impl;
namespace json = boost::json;
using namespace util::prometheus;
@@ -66,44 +70,44 @@ TEST_F(FeedProposedTransactionTest, ProposedTransaction)
testFeedPtr->sub(sessionPtr);
EXPECT_EQ(testFeedPtr->transactionSubcount(), 1);
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(DUMMY_TRANSACTION)));
testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION)));
testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object());
testFeedPtr->unsub(sessionPtr);
EXPECT_EQ(testFeedPtr->transactionSubcount(), 0);
testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object());
}
TEST_F(FeedProposedTransactionTest, AccountProposedTransaction)
{
auto const account = GetAccountIDWithString(ACCOUNT1);
auto const account = getAccountIdWithString(kACCOUNT1);
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(account, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
web::SubscriptionContextPtr const sessionIdle = std::make_shared<MockSession>();
auto const accountIdle = GetAccountIDWithString(ACCOUNT3);
auto const accountIdle = getAccountIdWithString(kACCOUNT3);
EXPECT_CALL(*dynamic_cast<MockSession*>(sessionIdle.get()), onDisconnect);
testFeedPtr->sub(accountIdle, sessionIdle);
EXPECT_EQ(testFeedPtr->accountSubCount(), 2);
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(DUMMY_TRANSACTION)));
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION)));
testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object());
// unsub
testFeedPtr->unsub(account, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object());
}
TEST_F(FeedProposedTransactionTest, SubStreamAndAccount)
{
auto const account = GetAccountIDWithString(ACCOUNT1);
auto const account = getAccountIdWithString(kACCOUNT1);
EXPECT_CALL(*mockSessionPtr, onDisconnect).Times(2);
testFeedPtr->sub(account, sessionPtr);
@@ -111,48 +115,48 @@ TEST_F(FeedProposedTransactionTest, SubStreamAndAccount)
EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
EXPECT_EQ(testFeedPtr->transactionSubcount(), 1);
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(DUMMY_TRANSACTION))).Times(2);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION))).Times(2);
testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object());
// unsub
testFeedPtr->unsub(account, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(DUMMY_TRANSACTION)));
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION)));
testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object());
// unsub transaction
testFeedPtr->unsub(sessionPtr);
EXPECT_EQ(testFeedPtr->transactionSubcount(), 0);
testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object());
}
TEST_F(FeedProposedTransactionTest, AccountProposedTransactionDuplicate)
{
auto const account = GetAccountIDWithString(ACCOUNT1);
auto const account2 = GetAccountIDWithString(ACCOUNT2);
auto const account = getAccountIdWithString(kACCOUNT1);
auto const account2 = getAccountIdWithString(kACCOUNT2);
EXPECT_CALL(*mockSessionPtr, onDisconnect).Times(2);
testFeedPtr->sub(account, sessionPtr);
testFeedPtr->sub(account2, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 2);
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(DUMMY_TRANSACTION)));
testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION)));
testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object());
// unsub account1
testFeedPtr->unsub(account, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(DUMMY_TRANSACTION)));
testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kDUMMY_TRANSACTION)));
testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object());
// unsub account2
testFeedPtr->unsub(account2, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
testFeedPtr->pub(json::parse(DUMMY_TRANSACTION).get_object());
testFeedPtr->pub(json::parse(kDUMMY_TRANSACTION).get_object());
}
TEST_F(FeedProposedTransactionTest, Count)
@@ -163,7 +167,7 @@ TEST_F(FeedProposedTransactionTest, Count)
testFeedPtr->sub(sessionPtr);
EXPECT_EQ(testFeedPtr->transactionSubcount(), 1);
auto const account1 = GetAccountIDWithString(ACCOUNT1);
auto const account1 = getAccountIdWithString(kACCOUNT1);
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(account1, sessionPtr);
@@ -177,7 +181,7 @@ TEST_F(FeedProposedTransactionTest, Count)
testFeedPtr->sub(sessionPtr2);
EXPECT_EQ(testFeedPtr->transactionSubcount(), 2);
auto const account2 = GetAccountIDWithString(ACCOUNT2);
auto const account2 = getAccountIdWithString(kACCOUNT2);
EXPECT_CALL(*dynamic_cast<MockSession*>(sessionPtr2.get()), onDisconnect);
testFeedPtr->sub(account2, sessionPtr2);
@@ -214,7 +218,7 @@ TEST_F(FeedProposedTransactionTest, AutoDisconnect)
testFeedPtr->sub(sessionPtr);
EXPECT_EQ(testFeedPtr->transactionSubcount(), 1);
auto const account1 = GetAccountIDWithString(ACCOUNT1);
auto const account1 = getAccountIdWithString(kACCOUNT1);
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(account1, sessionPtr);
@@ -233,7 +237,7 @@ TEST_F(FeedProposedTransactionTest, AutoDisconnect)
testFeedPtr->sub(sessionPtr2);
EXPECT_EQ(testFeedPtr->transactionSubcount(), 2);
auto const account2 = GetAccountIDWithString(ACCOUNT2);
auto const account2 = getAccountIdWithString(kACCOUNT2);
EXPECT_CALL(*mockSessionPtr2, onDisconnect);
testFeedPtr->sub(account2, sessionPtr2);
@@ -256,9 +260,9 @@ TEST_F(FeedProposedTransactionTest, AutoDisconnect)
struct ProposedTransactionFeedMockPrometheusTest : WithMockPrometheus, SyncExecutionCtxFixture {
protected:
web::SubscriptionContextPtr sessionPtr = std::make_shared<MockSession>();
std::shared_ptr<ProposedTransactionFeed> testFeedPtr = std::make_shared<ProposedTransactionFeed>(ctx);
MockSession* mockSessionPtr = dynamic_cast<MockSession*>(sessionPtr.get());
web::SubscriptionContextPtr sessionPtr_ = std::make_shared<MockSession>();
std::shared_ptr<ProposedTransactionFeed> testFeedPtr_ = std::make_shared<ProposedTransactionFeed>(ctx_);
MockSession* mockSessionPtr_ = dynamic_cast<MockSession*>(sessionPtr_.get());
};
TEST_F(ProposedTransactionFeedMockPrometheusTest, subUnsub)
@@ -271,14 +275,14 @@ TEST_F(ProposedTransactionFeedMockPrometheusTest, subUnsub)
EXPECT_CALL(counterAccount, add(1));
EXPECT_CALL(counterAccount, add(-1));
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(sessionPtr);
testFeedPtr->unsub(sessionPtr);
EXPECT_CALL(*mockSessionPtr_, onDisconnect);
testFeedPtr_->sub(sessionPtr_);
testFeedPtr_->unsub(sessionPtr_);
auto const account = GetAccountIDWithString(ACCOUNT1);
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(account, sessionPtr);
testFeedPtr->unsub(account, sessionPtr);
auto const account = getAccountIdWithString(kACCOUNT1);
EXPECT_CALL(*mockSessionPtr_, onDisconnect);
testFeedPtr_->sub(account, sessionPtr_);
testFeedPtr_->unsub(account, sessionPtr_);
}
TEST_F(ProposedTransactionFeedMockPrometheusTest, AutoDisconnect)
@@ -293,17 +297,17 @@ TEST_F(ProposedTransactionFeedMockPrometheusTest, AutoDisconnect)
EXPECT_CALL(counterAccount, add(1));
EXPECT_CALL(counterAccount, add(-1));
EXPECT_CALL(*mockSessionPtr, onDisconnect).WillOnce([&sessionOnDisconnectSlots](auto slot) {
EXPECT_CALL(*mockSessionPtr_, onDisconnect).WillOnce([&sessionOnDisconnectSlots](auto slot) {
sessionOnDisconnectSlots.push_back(slot);
});
testFeedPtr->sub(sessionPtr);
testFeedPtr_->sub(sessionPtr_);
auto const account = GetAccountIDWithString(ACCOUNT1);
EXPECT_CALL(*mockSessionPtr, onDisconnect).WillOnce([&sessionOnDisconnectSlots](auto slot) {
auto const account = getAccountIdWithString(kACCOUNT1);
EXPECT_CALL(*mockSessionPtr_, onDisconnect).WillOnce([&sessionOnDisconnectSlots](auto slot) {
sessionOnDisconnectSlots.push_back(slot);
});
testFeedPtr->sub(account, sessionPtr);
testFeedPtr_->sub(account, sessionPtr_);
std::ranges::for_each(sessionOnDisconnectSlots, [this](auto& slot) { slot(sessionPtr.get()); });
sessionPtr.reset();
std::ranges::for_each(sessionOnDisconnectSlots, [this](auto& slot) { slot(sessionPtr_.get()); });
sessionPtr_.reset();
}

34
tests/unit/feed/SingleFeedBaseTests.cpp
View File

@@ -31,16 +31,18 @@
#include <memory>
constexpr static auto FEED = R"({"test":"test"})";
namespace {
constexpr auto kFEED = R"({"test":"test"})";
} // namespace
using namespace feed::impl;
using namespace util::prometheus;
struct FeedBaseMockPrometheusTest : WithMockPrometheus, SyncExecutionCtxFixture {
protected:
web::SubscriptionContextPtr sessionPtr = std::make_shared<MockSession>();
std::shared_ptr<SingleFeedBase> testFeedPtr = std::make_shared<SingleFeedBase>(ctx, "testFeed");
MockSession* mockSessionPtr = dynamic_cast<MockSession*>(sessionPtr.get());
web::SubscriptionContextPtr sessionPtr_ = std::make_shared<MockSession>();
std::shared_ptr<SingleFeedBase> testFeedPtr_ = std::make_shared<SingleFeedBase>(ctx_, "testFeed");
MockSession* mockSessionPtr_ = dynamic_cast<MockSession*>(sessionPtr_.get());
};
TEST_F(FeedBaseMockPrometheusTest, subUnsub)
@@ -49,9 +51,9 @@ TEST_F(FeedBaseMockPrometheusTest, subUnsub)
EXPECT_CALL(counter, add(1));
EXPECT_CALL(counter, add(-1));
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(sessionPtr);
testFeedPtr->unsub(sessionPtr);
EXPECT_CALL(*mockSessionPtr_, onDisconnect);
testFeedPtr_->sub(sessionPtr_);
testFeedPtr_->unsub(sessionPtr_);
}
TEST_F(FeedBaseMockPrometheusTest, AutoUnsub)
@@ -61,10 +63,10 @@ TEST_F(FeedBaseMockPrometheusTest, AutoUnsub)
EXPECT_CALL(counter, add(-1));
web::SubscriptionContextInterface::OnDisconnectSlot slot;
EXPECT_CALL(*mockSessionPtr, onDisconnect).WillOnce(testing::SaveArg<0>(&slot));
testFeedPtr->sub(sessionPtr);
slot(sessionPtr.get());
sessionPtr.reset();
EXPECT_CALL(*mockSessionPtr_, onDisconnect).WillOnce(testing::SaveArg<0>(&slot));
testFeedPtr_->sub(sessionPtr_);
slot(sessionPtr_.get());
sessionPtr_.reset();
}
class NamedSingleFeedTest : public SingleFeedBase {
@@ -79,24 +81,24 @@ using SingleFeedBaseTest = FeedBaseTest<NamedSingleFeedTest>;
TEST_F(SingleFeedBaseTest, Test)
{
EXPECT_CALL(*mockSessionPtr, onDisconnect);
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(FEED)));
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kFEED)));
testFeedPtr->sub(sessionPtr);
EXPECT_EQ(testFeedPtr->count(), 1);
testFeedPtr->pub(FEED);
testFeedPtr->pub(kFEED);
testFeedPtr->unsub(sessionPtr);
EXPECT_EQ(testFeedPtr->count(), 0);
testFeedPtr->pub(FEED);
testFeedPtr->pub(kFEED);
}
TEST_F(SingleFeedBaseTest, TestAutoDisconnect)
{
web::SubscriptionContextInterface::OnDisconnectSlot slot;
EXPECT_CALL(*mockSessionPtr, onDisconnect).WillOnce(testing::SaveArg<0>(&slot));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(FEED)));
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kFEED)));
testFeedPtr->sub(sessionPtr);
EXPECT_EQ(testFeedPtr->count(), 1);
testFeedPtr->pub(FEED);
testFeedPtr->pub(kFEED);
slot(sessionPtr.get());
sessionPtr.reset();

356
tests/unit/feed/SubscriptionManagerTests.cpp
View File

@@ -44,11 +44,15 @@
#include <memory>
#include <vector>
constexpr static auto ACCOUNT1 = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn";
constexpr static auto ACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun";
constexpr static auto CURRENCY = "0158415500000000C1F76FF6ECB0BAC600000000";
constexpr static auto ISSUER = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD";
constexpr static auto LEDGERHASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652";
namespace {
constexpr auto kACCOUNT1 = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn";
constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun";
constexpr auto kCURRENCY = "0158415500000000C1F76FF6ECB0BAC600000000";
constexpr auto kISSUER = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD";
constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652";
} // namespace
namespace json = boost::json;
using namespace feed;
@@ -59,13 +63,13 @@ class SubscriptionManagerBaseTest : public util::prometheus::WithPrometheus, pub
protected:
SubscriptionManagerBaseTest()
{
ASSERT(sessionPtr != nullptr, "dynamic_cast failed");
ASSERT(sessionPtr_ != nullptr, "dynamic_cast failed");
}
std::shared_ptr<SubscriptionManager> subscriptionManagerPtr =
std::make_shared<SubscriptionManager>(Execution(2), backend);
web::SubscriptionContextPtr session = std::make_shared<MockSession>();
MockSession* sessionPtr = dynamic_cast<MockSession*>(session.get());
std::shared_ptr<SubscriptionManager> subscriptionManagerPtr_ =
std::make_shared<SubscriptionManager>(Execution(2), backend_);
web::SubscriptionContextPtr session_ = std::make_shared<MockSession>();
MockSession* sessionPtr_ = dynamic_cast<MockSession*>(session_.get());
};
using SubscriptionManagerTest = SubscriptionManagerBaseTest<util::async::SyncExecutionContext>;
@@ -74,37 +78,37 @@ using SubscriptionManagerAsyncTest = SubscriptionManagerBaseTest<util::async::Po
TEST_F(SubscriptionManagerAsyncTest, MultipleThreadCtx)
{
EXPECT_CALL(*sessionPtr, onDisconnect);
subscriptionManagerPtr->subManifest(session);
EXPECT_CALL(*sessionPtr, onDisconnect);
subscriptionManagerPtr->subValidation(session);
EXPECT_CALL(*sessionPtr_, onDisconnect);
subscriptionManagerPtr_->subManifest(session_);
EXPECT_CALL(*sessionPtr_, onDisconnect);
subscriptionManagerPtr_->subValidation(session_);
constexpr static auto jsonManifest = R"({"manifest":"test"})";
constexpr static auto jsonValidation = R"({"validation":"test"})";
static constexpr auto kJSON_MANIFEST = R"({"manifest":"test"})";
static constexpr auto kJSON_VALIDATION = R"({"validation":"test"})";
EXPECT_CALL(*sessionPtr, send(testing::_)).Times(testing::AtMost(2));
EXPECT_CALL(*sessionPtr_, send(testing::_)).Times(testing::AtMost(2));
subscriptionManagerPtr->forwardManifest(json::parse(jsonManifest).get_object());
subscriptionManagerPtr->forwardValidation(json::parse(jsonValidation).get_object());
subscriptionManagerPtr_->forwardManifest(json::parse(kJSON_MANIFEST).get_object());
subscriptionManagerPtr_->forwardValidation(json::parse(kJSON_VALIDATION).get_object());
}
TEST_F(SubscriptionManagerAsyncTest, MultipleThreadCtxSessionDieEarly)
{
EXPECT_CALL(*sessionPtr, onDisconnect);
subscriptionManagerPtr->subManifest(session);
EXPECT_CALL(*sessionPtr, onDisconnect);
subscriptionManagerPtr->subValidation(session);
EXPECT_CALL(*sessionPtr_, onDisconnect);
subscriptionManagerPtr_->subManifest(session_);
EXPECT_CALL(*sessionPtr_, onDisconnect);
subscriptionManagerPtr_->subValidation(session_);
EXPECT_CALL(*sessionPtr, send(testing::_)).Times(0);
session.reset();
EXPECT_CALL(*sessionPtr_, send(testing::_)).Times(0);
session_.reset();
subscriptionManagerPtr->forwardManifest(json::parse(R"({"manifest":"test"})").get_object());
subscriptionManagerPtr->forwardValidation(json::parse(R"({"validation":"test"})").get_object());
subscriptionManagerPtr_->forwardManifest(json::parse(R"({"manifest":"test"})").get_object());
subscriptionManagerPtr_->forwardValidation(json::parse(R"({"validation":"test"})").get_object());
}
TEST_F(SubscriptionManagerTest, ReportCurrentSubscriber)
{
constexpr static auto ReportReturn =
static constexpr auto kREPORT_RETURN =
R"({
"ledger":0,
"transactions":2,
@@ -128,45 +132,45 @@ TEST_F(SubscriptionManagerTest, ReportCurrentSubscriber)
EXPECT_CALL(*mockSession1, onDisconnect).Times(5);
EXPECT_CALL(*mockSession2, onDisconnect).Times(4);
subscriptionManagerPtr->subBookChanges(session1);
subscriptionManagerPtr->subBookChanges(session2);
subscriptionManagerPtr->subManifest(session1);
subscriptionManagerPtr->subManifest(session2);
subscriptionManagerPtr->subProposedTransactions(session1);
subscriptionManagerPtr->subProposedTransactions(session2);
subscriptionManagerPtr->subTransactions(session1);
subscriptionManagerPtr_->subBookChanges(session1);
subscriptionManagerPtr_->subBookChanges(session2);
subscriptionManagerPtr_->subManifest(session1);
subscriptionManagerPtr_->subManifest(session2);
subscriptionManagerPtr_->subProposedTransactions(session1);
subscriptionManagerPtr_->subProposedTransactions(session2);
subscriptionManagerPtr_->subTransactions(session1);
// session2->apiSubVersion = 2;
EXPECT_CALL(*mockSession1, onDisconnect).Times(5);
EXPECT_CALL(*mockSession2, onDisconnect).Times(6);
subscriptionManagerPtr->subTransactions(session2);
subscriptionManagerPtr->subValidation(session1);
subscriptionManagerPtr->subValidation(session2);
auto const account = GetAccountIDWithString(ACCOUNT1);
subscriptionManagerPtr->subAccount(account, session1);
subscriptionManagerPtr->subAccount(account, session2);
subscriptionManagerPtr->subProposedAccount(account, session1);
subscriptionManagerPtr->subProposedAccount(account, session2);
auto const issue1 = GetIssue(CURRENCY, ISSUER);
subscriptionManagerPtr_->subTransactions(session2);
subscriptionManagerPtr_->subValidation(session1);
subscriptionManagerPtr_->subValidation(session2);
auto const account = getAccountIdWithString(kACCOUNT1);
subscriptionManagerPtr_->subAccount(account, session1);
subscriptionManagerPtr_->subAccount(account, session2);
subscriptionManagerPtr_->subProposedAccount(account, session1);
subscriptionManagerPtr_->subProposedAccount(account, session2);
auto const issue1 = getIssue(kCURRENCY, kISSUER);
ripple::Book const book{ripple::xrpIssue(), issue1};
subscriptionManagerPtr->subBook(book, session1);
subscriptionManagerPtr->subBook(book, session2);
EXPECT_EQ(subscriptionManagerPtr->report(), json::parse(ReportReturn));
subscriptionManagerPtr_->subBook(book, session1);
subscriptionManagerPtr_->subBook(book, session2);
EXPECT_EQ(subscriptionManagerPtr_->report(), json::parse(kREPORT_RETURN));
// count down when unsub manually
subscriptionManagerPtr->unsubBookChanges(session1);
subscriptionManagerPtr->unsubManifest(session1);
subscriptionManagerPtr->unsubProposedTransactions(session1);
subscriptionManagerPtr->unsubTransactions(session1);
subscriptionManagerPtr->unsubValidation(session1);
subscriptionManagerPtr->unsubAccount(account, session1);
subscriptionManagerPtr->unsubProposedAccount(account, session1);
subscriptionManagerPtr->unsubBook(book, session1);
subscriptionManagerPtr_->unsubBookChanges(session1);
subscriptionManagerPtr_->unsubManifest(session1);
subscriptionManagerPtr_->unsubProposedTransactions(session1);
subscriptionManagerPtr_->unsubTransactions(session1);
subscriptionManagerPtr_->unsubValidation(session1);
subscriptionManagerPtr_->unsubAccount(account, session1);
subscriptionManagerPtr_->unsubProposedAccount(account, session1);
subscriptionManagerPtr_->unsubBook(book, session1);
// try to unsub an account which is not subscribed
auto const account2 = GetAccountIDWithString(ACCOUNT2);
subscriptionManagerPtr->unsubAccount(account2, session1);
subscriptionManagerPtr->unsubProposedAccount(account2, session1);
auto const account2 = getAccountIdWithString(kACCOUNT2);
subscriptionManagerPtr_->unsubAccount(account2, session1);
subscriptionManagerPtr_->unsubProposedAccount(account2, session1);
auto checkResult = [](json::object reportReturn, int result) {
EXPECT_EQ(reportReturn["book_changes"], result);
EXPECT_EQ(reportReturn["validations"], result);
@@ -177,56 +181,56 @@ TEST_F(SubscriptionManagerTest, ReportCurrentSubscriber)
EXPECT_EQ(reportReturn["account"], result);
EXPECT_EQ(reportReturn["books"], result);
};
checkResult(subscriptionManagerPtr->report(), 1);
checkResult(subscriptionManagerPtr_->report(), 1);
// count down when session disconnect
std::ranges::for_each(session2OnDisconnectSlots, [&session2](auto& slot) { slot(session2.get()); });
session2.reset();
checkResult(subscriptionManagerPtr->report(), 0);
checkResult(subscriptionManagerPtr_->report(), 0);
}
TEST_F(SubscriptionManagerTest, ManifestTest)
{
constexpr static auto dummyManifest = R"({"manifest":"test"})";
EXPECT_CALL(*sessionPtr, onDisconnect);
EXPECT_CALL(*sessionPtr, send(SharedStringJsonEq(dummyManifest)));
subscriptionManagerPtr->subManifest(session);
subscriptionManagerPtr->forwardManifest(json::parse(dummyManifest).get_object());
static constexpr auto kDUMMY_MANIFEST = R"({"manifest":"test"})";
EXPECT_CALL(*sessionPtr_, onDisconnect);
EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDUMMY_MANIFEST)));
subscriptionManagerPtr_->subManifest(session_);
subscriptionManagerPtr_->forwardManifest(json::parse(kDUMMY_MANIFEST).get_object());
EXPECT_CALL(*sessionPtr, send(SharedStringJsonEq(dummyManifest))).Times(0);
subscriptionManagerPtr->unsubManifest(session);
subscriptionManagerPtr->forwardManifest(json::parse(dummyManifest).get_object());
EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDUMMY_MANIFEST))).Times(0);
subscriptionManagerPtr_->unsubManifest(session_);
subscriptionManagerPtr_->forwardManifest(json::parse(kDUMMY_MANIFEST).get_object());
}
TEST_F(SubscriptionManagerTest, ValidationTest)
{
constexpr static auto dummy = R"({"validation":"test"})";
EXPECT_CALL(*sessionPtr, onDisconnect);
EXPECT_CALL(*sessionPtr, send(SharedStringJsonEq(dummy)));
subscriptionManagerPtr->subValidation(session);
subscriptionManagerPtr->forwardValidation(json::parse(dummy).get_object());
static constexpr auto kDUMMY = R"({"validation":"test"})";
EXPECT_CALL(*sessionPtr_, onDisconnect);
EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDUMMY)));
subscriptionManagerPtr_->subValidation(session_);
subscriptionManagerPtr_->forwardValidation(json::parse(kDUMMY).get_object());
EXPECT_CALL(*sessionPtr, send(SharedStringJsonEq(dummy))).Times(0);
subscriptionManagerPtr->unsubValidation(session);
subscriptionManagerPtr->forwardValidation(json::parse(dummy).get_object());
EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDUMMY))).Times(0);
subscriptionManagerPtr_->unsubValidation(session_);
subscriptionManagerPtr_->forwardValidation(json::parse(kDUMMY).get_object());
}
TEST_F(SubscriptionManagerTest, BookChangesTest)
{
EXPECT_CALL(*sessionPtr, onDisconnect);
subscriptionManagerPtr->subBookChanges(session);
EXPECT_EQ(subscriptionManagerPtr->report()["book_changes"], 1);
EXPECT_CALL(*sessionPtr_, onDisconnect);
subscriptionManagerPtr_->subBookChanges(session_);
EXPECT_EQ(subscriptionManagerPtr_->report()["book_changes"], 1);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 32);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 32);
auto transactions = std::vector<TransactionAndMetadata>{};
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
ripple::STObject const metaObj = CreateMetaDataForBookChange(CURRENCY, ISSUER, 22, 1, 3, 3, 1);
ripple::STObject const metaObj = createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 1, 3, 3, 1);
trans1.metadata = metaObj.getSerializer().peekData();
transactions.push_back(trans1);
constexpr static auto bookChangePublish =
static constexpr auto kBOOK_CHANGE_PUBLISH =
R"({
"type":"bookChanges",
"ledger_index":32,
@@ -246,27 +250,27 @@ TEST_F(SubscriptionManagerTest, BookChangesTest)
}
]
})";
EXPECT_CALL(*sessionPtr, send(SharedStringJsonEq(bookChangePublish)));
EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kBOOK_CHANGE_PUBLISH)));
subscriptionManagerPtr->pubBookChanges(ledgerHeader, transactions);
subscriptionManagerPtr_->pubBookChanges(ledgerHeader, transactions);
subscriptionManagerPtr->unsubBookChanges(session);
EXPECT_EQ(subscriptionManagerPtr->report()["book_changes"], 0);
subscriptionManagerPtr_->unsubBookChanges(session_);
EXPECT_EQ(subscriptionManagerPtr_->report()["book_changes"], 0);
}
TEST_F(SubscriptionManagerTest, LedgerTest)
{
backend->setRange(10, 30);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 30);
EXPECT_CALL(*backend, fetchLedgerBySequence).WillOnce(testing::Return(ledgerHeader));
backend_->setRange(10, 30);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 30);
EXPECT_CALL(*backend_, fetchLedgerBySequence).WillOnce(testing::Return(ledgerHeader));
auto const feeBlob = CreateLegacyFeeSettingBlob(1, 2, 3, 4, 0);
EXPECT_CALL(*backend, doFetchLedgerObject).WillOnce(testing::Return(feeBlob));
auto const feeBlob = createLegacyFeeSettingBlob(1, 2, 3, 4, 0);
EXPECT_CALL(*backend_, doFetchLedgerObject).WillOnce(testing::Return(feeBlob));
// check the function response
// Information about the ledgers on hand and current fee schedule. This
// includes the same fields as a ledger stream message, except that it omits
// the type and txn_count fields
constexpr static auto LedgerResponse =
static constexpr auto kLEDGER_RESPONSE =
R"({
"validated_ledgers":"10-30",
"ledger_index":30,
@@ -278,19 +282,19 @@ TEST_F(SubscriptionManagerTest, LedgerTest)
})";
boost::asio::io_context ctx;
boost::asio::spawn(ctx, [this](boost::asio::yield_context yield) {
EXPECT_CALL(*sessionPtr, onDisconnect);
auto const res = subscriptionManagerPtr->subLedger(yield, session);
EXPECT_CALL(*sessionPtr_, onDisconnect);
auto const res = subscriptionManagerPtr_->subLedger(yield, session_);
// check the response
EXPECT_EQ(res, json::parse(LedgerResponse));
EXPECT_EQ(res, json::parse(kLEDGER_RESPONSE));
});
ctx.run();
EXPECT_EQ(subscriptionManagerPtr->report()["ledger"], 1);
EXPECT_EQ(subscriptionManagerPtr_->report()["ledger"], 1);
// test publish
auto const ledgerHeader2 = CreateLedgerHeader(LEDGERHASH, 31);
auto const ledgerHeader2 = createLedgerHeader(kLEDGER_HASH, 31);
auto fee2 = ripple::Fees();
fee2.reserve = 10;
constexpr static auto ledgerPub =
static constexpr auto kLEDGER_PUB =
R"({
"type":"ledgerClosed",
"ledger_index":31,
@@ -302,36 +306,36 @@ TEST_F(SubscriptionManagerTest, LedgerTest)
"validated_ledgers":"10-31",
"txn_count":8
})";
EXPECT_CALL(*sessionPtr, send(SharedStringJsonEq(ledgerPub)));
subscriptionManagerPtr->pubLedger(ledgerHeader2, fee2, "10-31", 8);
EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kLEDGER_PUB)));
subscriptionManagerPtr_->pubLedger(ledgerHeader2, fee2, "10-31", 8);
// test unsub
subscriptionManagerPtr->unsubLedger(session);
EXPECT_EQ(subscriptionManagerPtr->report()["ledger"], 0);
subscriptionManagerPtr_->unsubLedger(session_);
EXPECT_EQ(subscriptionManagerPtr_->report()["ledger"], 0);
}
TEST_F(SubscriptionManagerTest, TransactionTest)
{
auto const issue1 = GetIssue(CURRENCY, ISSUER);
auto const account = GetAccountIDWithString(ISSUER);
auto const issue1 = getIssue(kCURRENCY, kISSUER);
auto const account = getAccountIdWithString(kISSUER);
ripple::Book const book{ripple::xrpIssue(), issue1};
EXPECT_CALL(*sessionPtr, onDisconnect).Times(3);
subscriptionManagerPtr->subBook(book, session);
subscriptionManagerPtr->subTransactions(session);
subscriptionManagerPtr->subAccount(account, session);
EXPECT_EQ(subscriptionManagerPtr->report()["account"], 1);
EXPECT_EQ(subscriptionManagerPtr->report()["transactions"], 1);
EXPECT_EQ(subscriptionManagerPtr->report()["books"], 1);
EXPECT_CALL(*sessionPtr_, onDisconnect).Times(3);
subscriptionManagerPtr_->subBook(book, session_);
subscriptionManagerPtr_->subTransactions(session_);
subscriptionManagerPtr_->subAccount(account, session_);
EXPECT_EQ(subscriptionManagerPtr_->report()["account"], 1);
EXPECT_EQ(subscriptionManagerPtr_->report()["transactions"], 1);
EXPECT_EQ(subscriptionManagerPtr_->report()["books"], 1);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
auto obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
auto obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
auto const metaObj = CreateMetaDataForBookChange(CURRENCY, ISSUER, 22, 3, 1, 1, 3);
auto const metaObj = createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 3, 1, 1, 3);
trans1.metadata = metaObj.getSerializer().peekData();
constexpr static auto OrderbookPublish =
static constexpr auto kORDERBOOK_PUBLISH =
R"({
"transaction":
{
@@ -391,28 +395,28 @@ TEST_F(SubscriptionManagerTest, TransactionTest)
"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);
EXPECT_CALL(*sessionPtr, apiSubversion).Times(3).WillRepeatedly(testing::Return(1));
subscriptionManagerPtr->pubTransaction(trans1, ledgerHeader);
EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kORDERBOOK_PUBLISH))).Times(3);
EXPECT_CALL(*sessionPtr_, apiSubversion).Times(3).WillRepeatedly(testing::Return(1));
subscriptionManagerPtr_->pubTransaction(trans1, ledgerHeader);
subscriptionManagerPtr->unsubBook(book, session);
subscriptionManagerPtr->unsubTransactions(session);
subscriptionManagerPtr->unsubAccount(account, session);
EXPECT_EQ(subscriptionManagerPtr->report()["account"], 0);
EXPECT_EQ(subscriptionManagerPtr->report()["transactions"], 0);
EXPECT_EQ(subscriptionManagerPtr->report()["books"], 0);
subscriptionManagerPtr_->unsubBook(book, session_);
subscriptionManagerPtr_->unsubTransactions(session_);
subscriptionManagerPtr_->unsubAccount(account, session_);
EXPECT_EQ(subscriptionManagerPtr_->report()["account"], 0);
EXPECT_EQ(subscriptionManagerPtr_->report()["transactions"], 0);
EXPECT_EQ(subscriptionManagerPtr_->report()["books"], 0);
}
TEST_F(SubscriptionManagerTest, ProposedTransactionTest)
{
auto const account = GetAccountIDWithString(ACCOUNT1);
EXPECT_CALL(*sessionPtr, onDisconnect).Times(4);
subscriptionManagerPtr->subProposedAccount(account, session);
subscriptionManagerPtr->subProposedTransactions(session);
EXPECT_EQ(subscriptionManagerPtr->report()["accounts_proposed"], 1);
EXPECT_EQ(subscriptionManagerPtr->report()["transactions_proposed"], 1);
auto const account = getAccountIdWithString(kACCOUNT1);
EXPECT_CALL(*sessionPtr_, onDisconnect).Times(4);
subscriptionManagerPtr_->subProposedAccount(account, session_);
subscriptionManagerPtr_->subProposedTransactions(session_);
EXPECT_EQ(subscriptionManagerPtr_->report()["accounts_proposed"], 1);
EXPECT_EQ(subscriptionManagerPtr_->report()["transactions_proposed"], 1);
constexpr static auto dummyTransaction =
static constexpr auto kDUMMY_TRANSACTION =
R"({
"transaction":
{
@@ -420,7 +424,7 @@ TEST_F(SubscriptionManagerTest, ProposedTransactionTest)
"Destination":"rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"
}
})";
constexpr static auto OrderbookPublish =
static constexpr auto kORDERBOOK_PUBLISH =
R"({
"transaction":
{
@@ -480,80 +484,80 @@ TEST_F(SubscriptionManagerTest, ProposedTransactionTest)
"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(dummyTransaction))).Times(2);
EXPECT_CALL(*sessionPtr, send(SharedStringJsonEq(OrderbookPublish))).Times(2);
subscriptionManagerPtr->forwardProposedTransaction(json::parse(dummyTransaction).get_object());
EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kDUMMY_TRANSACTION))).Times(2);
EXPECT_CALL(*sessionPtr_, send(sharedStringJsonEq(kORDERBOOK_PUBLISH))).Times(2);
subscriptionManagerPtr_->forwardProposedTransaction(json::parse(kDUMMY_TRANSACTION).get_object());
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
auto obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
auto obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
auto const metaObj = CreateMetaDataForBookChange(CURRENCY, ACCOUNT1, 22, 3, 1, 1, 3);
auto const metaObj = createMetaDataForBookChange(kCURRENCY, kACCOUNT1, 22, 3, 1, 1, 3);
trans1.metadata = metaObj.getSerializer().peekData();
EXPECT_CALL(*sessionPtr, apiSubversion).Times(2).WillRepeatedly(testing::Return(1));
subscriptionManagerPtr->pubTransaction(trans1, ledgerHeader);
EXPECT_CALL(*sessionPtr_, apiSubversion).Times(2).WillRepeatedly(testing::Return(1));
subscriptionManagerPtr_->pubTransaction(trans1, ledgerHeader);
// unsub account1
subscriptionManagerPtr->unsubProposedAccount(account, session);
EXPECT_EQ(subscriptionManagerPtr->report()["accounts_proposed"], 0);
subscriptionManagerPtr->unsubProposedTransactions(session);
EXPECT_EQ(subscriptionManagerPtr->report()["transactions_proposed"], 0);
subscriptionManagerPtr_->unsubProposedAccount(account, session_);
EXPECT_EQ(subscriptionManagerPtr_->report()["accounts_proposed"], 0);
subscriptionManagerPtr_->unsubProposedTransactions(session_);
EXPECT_EQ(subscriptionManagerPtr_->report()["transactions_proposed"], 0);
}
TEST_F(SubscriptionManagerTest, DuplicateResponseSubTxAndProposedTx)
{
EXPECT_CALL(*sessionPtr, onDisconnect).Times(3);
subscriptionManagerPtr->subProposedTransactions(session);
subscriptionManagerPtr->subTransactions(session);
EXPECT_EQ(subscriptionManagerPtr->report()["transactions"], 1);
EXPECT_EQ(subscriptionManagerPtr->report()["transactions_proposed"], 1);
EXPECT_CALL(*sessionPtr_, onDisconnect).Times(3);
subscriptionManagerPtr_->subProposedTransactions(session_);
subscriptionManagerPtr_->subTransactions(session_);
EXPECT_EQ(subscriptionManagerPtr_->report()["transactions"], 1);
EXPECT_EQ(subscriptionManagerPtr_->report()["transactions_proposed"], 1);
EXPECT_CALL(*sessionPtr, send(testing::_)).Times(2);
EXPECT_CALL(*sessionPtr_, send(testing::_)).Times(2);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
auto obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
auto obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
auto const metaObj = CreateMetaDataForBookChange(CURRENCY, ACCOUNT1, 22, 3, 1, 1, 3);
auto const metaObj = createMetaDataForBookChange(kCURRENCY, kACCOUNT1, 22, 3, 1, 1, 3);
trans1.metadata = metaObj.getSerializer().peekData();
EXPECT_CALL(*sessionPtr, apiSubversion).Times(2).WillRepeatedly(testing::Return(1));
subscriptionManagerPtr->pubTransaction(trans1, ledgerHeader);
EXPECT_CALL(*sessionPtr_, apiSubversion).Times(2).WillRepeatedly(testing::Return(1));
subscriptionManagerPtr_->pubTransaction(trans1, ledgerHeader);
subscriptionManagerPtr->unsubTransactions(session);
EXPECT_EQ(subscriptionManagerPtr->report()["transactions"], 0);
subscriptionManagerPtr->unsubProposedTransactions(session);
EXPECT_EQ(subscriptionManagerPtr->report()["transactions_proposed"], 0);
subscriptionManagerPtr_->unsubTransactions(session_);
EXPECT_EQ(subscriptionManagerPtr_->report()["transactions"], 0);
subscriptionManagerPtr_->unsubProposedTransactions(session_);
EXPECT_EQ(subscriptionManagerPtr_->report()["transactions_proposed"], 0);
}
TEST_F(SubscriptionManagerTest, NoDuplicateResponseSubAccountAndProposedAccount)
{
auto const account = GetAccountIDWithString(ACCOUNT1);
EXPECT_CALL(*sessionPtr, onDisconnect).Times(3);
subscriptionManagerPtr->subProposedAccount(account, session);
subscriptionManagerPtr->subAccount(account, session);
EXPECT_EQ(subscriptionManagerPtr->report()["accounts_proposed"], 1);
EXPECT_EQ(subscriptionManagerPtr->report()["account"], 1);
auto const account = getAccountIdWithString(kACCOUNT1);
EXPECT_CALL(*sessionPtr_, onDisconnect).Times(3);
subscriptionManagerPtr_->subProposedAccount(account, session_);
subscriptionManagerPtr_->subAccount(account, session_);
EXPECT_EQ(subscriptionManagerPtr_->report()["accounts_proposed"], 1);
EXPECT_EQ(subscriptionManagerPtr_->report()["account"], 1);
EXPECT_CALL(*sessionPtr, send(testing::_));
EXPECT_CALL(*sessionPtr_, send(testing::_));
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
auto obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
auto obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
auto const metaObj = CreateMetaDataForBookChange(CURRENCY, ACCOUNT1, 22, 3, 1, 1, 3);
auto const metaObj = createMetaDataForBookChange(kCURRENCY, kACCOUNT1, 22, 3, 1, 1, 3);
trans1.metadata = metaObj.getSerializer().peekData();
EXPECT_CALL(*sessionPtr, apiSubversion).WillRepeatedly(testing::Return(1));
subscriptionManagerPtr->pubTransaction(trans1, ledgerHeader);
EXPECT_CALL(*sessionPtr_, apiSubversion).WillRepeatedly(testing::Return(1));
subscriptionManagerPtr_->pubTransaction(trans1, ledgerHeader);
// unsub account1
subscriptionManagerPtr->unsubProposedAccount(account, session);
EXPECT_EQ(subscriptionManagerPtr->report()["accounts_proposed"], 0);
subscriptionManagerPtr->unsubAccount(account, session);
EXPECT_EQ(subscriptionManagerPtr->report()["account"], 0);
subscriptionManagerPtr_->unsubProposedAccount(account, session_);
EXPECT_EQ(subscriptionManagerPtr_->report()["accounts_proposed"], 0);
subscriptionManagerPtr_->unsubAccount(account, session_);
EXPECT_EQ(subscriptionManagerPtr_->report()["account"], 0);
}

385
tests/unit/feed/TransactionFeedTests.cpp
View File

@@ -43,14 +43,16 @@
#include <memory>
#include <vector>
constexpr static auto ACCOUNT1 = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn";
constexpr static auto ACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun";
constexpr static auto LEDGERHASH = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC";
constexpr static auto CURRENCY = "0158415500000000C1F76FF6ECB0BAC600000000";
constexpr static auto ISSUER = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD";
constexpr static auto TXNID = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321";
namespace {
constexpr static auto TRAN_V1 =
constexpr auto kACCOUNT1 = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn";
constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun";
constexpr auto kLEDGER_HASH = "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC";
constexpr auto kCURRENCY = "0158415500000000C1F76FF6ECB0BAC600000000";
constexpr auto kISSUER = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD";
constexpr auto kTXN_ID = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321";
constexpr auto kTRAN_V1 =
R"({
"transaction":
{
@@ -107,7 +109,7 @@ constexpr static auto TRAN_V1 =
"engine_result_message":"The transaction was applied. Only final in a validated ledger."
})";
constexpr static auto TRAN_V2 =
constexpr auto kTRAN_V2 =
R"({
"tx_json":
{
@@ -159,6 +161,8 @@ constexpr static auto TRAN_V2 =
"engine_result_message":"The transaction was applied. Only final in a validated ledger."
})";
} // namespace
using namespace feed::impl;
using namespace util::prometheus;
@@ -170,19 +174,19 @@ TEST_F(FeedTransactionTest, SubTransactionV1)
testFeedPtr->sub(sessionPtr);
EXPECT_EQ(testFeedPtr->transactionSubCount(), 1);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData();
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V1)));
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1)));
testFeedPtr->pub(trans1, ledgerHeader, backend_);
testFeedPtr->unsub(sessionPtr);
testFeedPtr->pub(trans1, ledgerHeader, backend);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
EXPECT_EQ(testFeedPtr->transactionSubCount(), 0);
}
@@ -192,19 +196,19 @@ TEST_F(FeedTransactionTest, SubTransactionForProposedTx)
testFeedPtr->subProposed(sessionPtr);
EXPECT_EQ(testFeedPtr->transactionSubCount(), 0);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData();
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V1)));
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1)));
testFeedPtr->pub(trans1, ledgerHeader, backend_);
testFeedPtr->unsubProposed(sessionPtr);
testFeedPtr->pub(trans1, ledgerHeader, backend);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
}
TEST_F(FeedTransactionTest, SubTransactionV2)
@@ -213,146 +217,146 @@ TEST_F(FeedTransactionTest, SubTransactionV2)
testFeedPtr->sub(sessionPtr);
EXPECT_EQ(testFeedPtr->transactionSubCount(), 1);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData();
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V2)));
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2)));
testFeedPtr->pub(trans1, ledgerHeader, backend_);
testFeedPtr->unsub(sessionPtr);
EXPECT_EQ(testFeedPtr->transactionSubCount(), 0);
testFeedPtr->pub(trans1, ledgerHeader, backend);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
}
TEST_F(FeedTransactionTest, SubAccountV1)
{
auto const account = GetAccountIDWithString(ACCOUNT1);
auto const account = getAccountIdWithString(kACCOUNT1);
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(account, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData();
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V1)));
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1)));
testFeedPtr->pub(trans1, ledgerHeader, backend_);
testFeedPtr->unsub(account, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
testFeedPtr->pub(trans1, ledgerHeader, backend);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
}
TEST_F(FeedTransactionTest, SubForProposedAccount)
{
auto const account = GetAccountIDWithString(ACCOUNT1);
auto const account = getAccountIdWithString(kACCOUNT1);
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->subProposed(account, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData();
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V1)));
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1)));
testFeedPtr->pub(trans1, ledgerHeader, backend_);
testFeedPtr->unsubProposed(account, sessionPtr);
testFeedPtr->pub(trans1, ledgerHeader, backend);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
}
TEST_F(FeedTransactionTest, SubAccountV2)
{
auto const account = GetAccountIDWithString(ACCOUNT1);
auto const account = getAccountIdWithString(kACCOUNT1);
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(account, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData();
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V2)));
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2)));
testFeedPtr->pub(trans1, ledgerHeader, backend_);
testFeedPtr->unsub(account, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
testFeedPtr->pub(trans1, ledgerHeader, backend);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
}
TEST_F(FeedTransactionTest, SubBothTransactionAndAccount)
{
auto const account = GetAccountIDWithString(ACCOUNT1);
auto const account = getAccountIdWithString(kACCOUNT1);
EXPECT_CALL(*mockSessionPtr, onDisconnect).Times(2);
testFeedPtr->sub(account, sessionPtr);
testFeedPtr->sub(sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
EXPECT_EQ(testFeedPtr->transactionSubCount(), 1);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData();
EXPECT_CALL(*mockSessionPtr, apiSubversion).Times(2).WillRepeatedly(testing::Return(2));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V2))).Times(2);
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2))).Times(2);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
testFeedPtr->unsub(account, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
testFeedPtr->unsub(sessionPtr);
EXPECT_EQ(testFeedPtr->transactionSubCount(), 0);
testFeedPtr->pub(trans1, ledgerHeader, backend);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
}
TEST_F(FeedTransactionTest, SubBookV1)
{
auto const issue1 = GetIssue(CURRENCY, ISSUER);
auto const issue1 = getIssue(kCURRENCY, kISSUER);
ripple::Book const book{ripple::xrpIssue(), issue1};
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(book, sessionPtr);
EXPECT_EQ(testFeedPtr->bookSubCount(), 1);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
auto obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
auto obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
auto metaObj = CreateMetaDataForBookChange(CURRENCY, ISSUER, 22, 3, 1, 1, 3);
auto metaObj = createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 3, 1, 1, 3);
trans1.metadata = metaObj.getSerializer().peekData();
constexpr static auto OrderbookPublish =
static constexpr auto kORDERBOOK_PUBLISH =
R"({
"transaction":
{
@@ -413,14 +417,14 @@ TEST_F(FeedTransactionTest, SubBookV1)
})";
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(OrderbookPublish))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kORDERBOOK_PUBLISH))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
// trigger by offer cancel meta data
metaObj = CreateMetaDataForCancelOffer(CURRENCY, ISSUER, 22, 3, 1);
metaObj = createMetaDataForCancelOffer(kCURRENCY, kISSUER, 22, 3, 1);
trans1.metadata = metaObj.getSerializer().peekData();
constexpr static auto OrderbookCancelPublish =
static constexpr auto kORDERBOOK_CANCEL_PUBLISH =
R"({
"transaction":{
"Account":"rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
@@ -469,11 +473,11 @@ TEST_F(FeedTransactionTest, SubBookV1)
})";
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(OrderbookCancelPublish))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kORDERBOOK_CANCEL_PUBLISH))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
// trigger by offer create meta data
constexpr static auto OrderbookCreatePublish =
static constexpr auto kORDERBOOK_CREATE_PUBLISH =
R"({
"transaction":
{
@@ -522,38 +526,38 @@ TEST_F(FeedTransactionTest, SubBookV1)
"close_time_iso": "2000-01-01T00:00:00Z",
"engine_result_message":"The transaction was applied. Only final in a validated ledger."
})";
metaObj = CreateMetaDataForCreateOffer(CURRENCY, ISSUER, 22, 3, 1);
metaObj = createMetaDataForCreateOffer(kCURRENCY, kISSUER, 22, 3, 1);
trans1.metadata = metaObj.getSerializer().peekData();
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(OrderbookCreatePublish))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kORDERBOOK_CREATE_PUBLISH))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
testFeedPtr->unsub(book, sessionPtr);
EXPECT_EQ(testFeedPtr->bookSubCount(), 0);
testFeedPtr->pub(trans1, ledgerHeader, backend);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
}
TEST_F(FeedTransactionTest, SubBookV2)
{
auto const issue1 = GetIssue(CURRENCY, ISSUER);
auto const issue1 = getIssue(kCURRENCY, kISSUER);
ripple::Book const book{ripple::xrpIssue(), issue1};
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(book, sessionPtr);
EXPECT_EQ(testFeedPtr->bookSubCount(), 1);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
auto obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
auto obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
auto const metaObj = CreateMetaDataForBookChange(CURRENCY, ISSUER, 22, 3, 1, 1, 3);
auto const metaObj = createMetaDataForBookChange(kCURRENCY, kISSUER, 22, 3, 1, 1, 3);
trans1.metadata = metaObj.getSerializer().peekData();
constexpr static auto OrderbookPublish =
static constexpr auto kORDERBOOK_PUBLISH =
R"({
"tx_json":
{
@@ -614,87 +618,87 @@ TEST_F(FeedTransactionTest, SubBookV2)
})";
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(OrderbookPublish))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kORDERBOOK_PUBLISH))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
testFeedPtr->unsub(book, sessionPtr);
EXPECT_EQ(testFeedPtr->bookSubCount(), 0);
testFeedPtr->pub(trans1, ledgerHeader, backend);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
}
TEST_F(FeedTransactionTest, TransactionContainsBothAccountsSubed)
{
auto const account = GetAccountIDWithString(ACCOUNT1);
auto const account = getAccountIdWithString(kACCOUNT1);
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(account, sessionPtr);
auto const account2 = GetAccountIDWithString(ACCOUNT2);
auto const account2 = getAccountIdWithString(kACCOUNT2);
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(account2, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 2);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData();
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V2))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
testFeedPtr->unsub(account, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V2))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
testFeedPtr->unsub(account2, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
testFeedPtr->pub(trans1, ledgerHeader, backend);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
}
TEST_F(FeedTransactionTest, SubAccountRepeatWithDifferentVersion)
{
auto const account = GetAccountIDWithString(ACCOUNT1);
auto const account = getAccountIdWithString(kACCOUNT1);
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(account, sessionPtr);
auto const account2 = GetAccountIDWithString(ACCOUNT2);
auto const account2 = getAccountIdWithString(kACCOUNT2);
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(account2, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 2);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData();
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V2))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
testFeedPtr->unsub(account, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V2))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
testFeedPtr->unsub(account2, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
testFeedPtr->pub(trans1, ledgerHeader, backend);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
}
TEST_F(FeedTransactionTest, SubTransactionRepeatWithDifferentVersion)
@@ -707,21 +711,21 @@ TEST_F(FeedTransactionTest, SubTransactionRepeatWithDifferentVersion)
testFeedPtr->sub(sessionPtr);
EXPECT_EQ(testFeedPtr->transactionSubCount(), 1);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData();
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(2));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V2))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V2))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
testFeedPtr->unsub(sessionPtr);
EXPECT_EQ(testFeedPtr->transactionSubCount(), 0);
testFeedPtr->pub(trans1, ledgerHeader, backend);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
}
TEST_F(FeedTransactionTest, SubRepeat)
@@ -746,8 +750,8 @@ TEST_F(FeedTransactionTest, SubRepeat)
testFeedPtr->unsub(sessionPtr);
EXPECT_EQ(testFeedPtr->transactionSubCount(), 0);
auto const account = GetAccountIDWithString(ACCOUNT1);
auto const account2 = GetAccountIDWithString(ACCOUNT2);
auto const account = getAccountIdWithString(kACCOUNT1);
auto const account2 = getAccountIdWithString(kACCOUNT2);
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(account, sessionPtr);
@@ -767,7 +771,7 @@ TEST_F(FeedTransactionTest, SubRepeat)
testFeedPtr->unsub(account, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
auto const issue1 = GetIssue(CURRENCY, ISSUER);
auto const issue1 = getIssue(kCURRENCY, kISSUER);
ripple::Book const book{ripple::xrpIssue(), issue1};
EXPECT_CALL(*mockSessionPtr, onDisconnect);
@@ -791,9 +795,9 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFund)
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(sessionPtr);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreateCreateOfferTransactionObject(ACCOUNT1, 1, 32, CURRENCY, ISSUER, 1, 3);
ripple::STObject const obj = createCreateOfferTransactionObject(kACCOUNT1, 1, 32, kCURRENCY, kISSUER, 1, 3);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
ripple::STArray const metaArray{0};
@@ -807,22 +811,22 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFund)
line.setFieldU16(ripple::sfLedgerEntryType, ripple::ltRIPPLE_STATE);
line.setFieldAmount(ripple::sfLowLimit, ripple::STAmount(10, false));
line.setFieldAmount(ripple::sfHighLimit, ripple::STAmount(100, false));
line.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{TXNID});
line.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{kTXN_ID});
line.setFieldU32(ripple::sfPreviousTxnLgrSeq, 3);
line.setFieldU32(ripple::sfFlags, 0);
auto const issue2 = GetIssue(CURRENCY, ISSUER);
auto const issue2 = getIssue(kCURRENCY, kISSUER);
line.setFieldAmount(ripple::sfBalance, ripple::STAmount(issue2, 100));
EXPECT_CALL(*backend, doFetchLedgerObject).Times(3);
auto const issueAccount = GetAccountIDWithString(ISSUER);
EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3);
auto const issueAccount = getAccountIdWithString(kISSUER);
auto const kk = ripple::keylet::account(issueAccount).key;
ON_CALL(*backend, doFetchLedgerObject(testing::_, testing::_, testing::_))
ON_CALL(*backend_, doFetchLedgerObject(testing::_, testing::_, testing::_))
.WillByDefault(testing::Return(line.getSerializer().peekData()));
ripple::STObject const accountRoot = CreateAccountRootObject(ISSUER, 0, 1, 10, 2, TXNID, 3);
ON_CALL(*backend, doFetchLedgerObject(kk, testing::_, testing::_))
ripple::STObject const accountRoot = createAccountRootObject(kISSUER, 0, 1, 10, 2, kTXN_ID, 3);
ON_CALL(*backend_, doFetchLedgerObject(kk, testing::_, testing::_))
.WillByDefault(testing::Return(accountRoot.getSerializer().peekData()));
constexpr static auto TransactionForOwnerFund =
static constexpr auto kTRANSACTION_FOR_OWNER_FUND =
R"({
"transaction":
{
@@ -860,11 +864,11 @@ TEST_F(FeedTransactionTest, PubTransactionWithOwnerFund)
})";
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TransactionForOwnerFund))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRANSACTION_FOR_OWNER_FUND))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
}
constexpr static auto TRAN_FROZEN =
static constexpr auto kTRAN_FROZEN =
R"({
"transaction":
{
@@ -905,9 +909,9 @@ TEST_F(FeedTransactionTest, PubTransactionOfferCreationFrozenLine)
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(sessionPtr);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreateCreateOfferTransactionObject(ACCOUNT1, 1, 32, CURRENCY, ISSUER, 1, 3);
ripple::STObject const obj = createCreateOfferTransactionObject(kACCOUNT1, 1, 32, kCURRENCY, kISSUER, 1, 3);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
ripple::STArray const metaArray{0};
@@ -921,23 +925,23 @@ TEST_F(FeedTransactionTest, PubTransactionOfferCreationFrozenLine)
line.setFieldU16(ripple::sfLedgerEntryType, ripple::ltRIPPLE_STATE);
line.setFieldAmount(ripple::sfLowLimit, ripple::STAmount(10, false));
line.setFieldAmount(ripple::sfHighLimit, ripple::STAmount(100, false));
line.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{TXNID});
line.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{kTXN_ID});
line.setFieldU32(ripple::sfPreviousTxnLgrSeq, 3);
line.setFieldU32(ripple::sfFlags, ripple::lsfHighFreeze);
line.setFieldAmount(ripple::sfBalance, ripple::STAmount(GetIssue(CURRENCY, ISSUER), 100));
line.setFieldAmount(ripple::sfBalance, ripple::STAmount(getIssue(kCURRENCY, kISSUER), 100));
EXPECT_CALL(*backend, doFetchLedgerObject).Times(3);
auto const issueAccount = GetAccountIDWithString(ISSUER);
EXPECT_CALL(*backend_, doFetchLedgerObject).Times(3);
auto const issueAccount = getAccountIdWithString(kISSUER);
auto const kk = ripple::keylet::account(issueAccount).key;
ON_CALL(*backend, doFetchLedgerObject(testing::_, testing::_, testing::_))
ON_CALL(*backend_, doFetchLedgerObject(testing::_, testing::_, testing::_))
.WillByDefault(testing::Return(line.getSerializer().peekData()));
ripple::STObject const accountRoot = CreateAccountRootObject(ISSUER, 0, 1, 10, 2, TXNID, 3);
ON_CALL(*backend, doFetchLedgerObject(kk, testing::_, testing::_))
ripple::STObject const accountRoot = createAccountRootObject(kISSUER, 0, 1, 10, 2, kTXN_ID, 3);
ON_CALL(*backend_, doFetchLedgerObject(kk, testing::_, testing::_))
.WillByDefault(testing::Return(accountRoot.getSerializer().peekData()));
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_FROZEN))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_FROZEN))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
}
TEST_F(FeedTransactionTest, SubTransactionOfferCreationGlobalFrozen)
@@ -945,9 +949,9 @@ TEST_F(FeedTransactionTest, SubTransactionOfferCreationGlobalFrozen)
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(sessionPtr);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreateCreateOfferTransactionObject(ACCOUNT1, 1, 32, CURRENCY, ISSUER, 1, 3);
ripple::STObject const obj = createCreateOfferTransactionObject(kACCOUNT1, 1, 32, kCURRENCY, kISSUER, 1, 3);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
ripple::STArray const metaArray{0};
@@ -961,28 +965,29 @@ TEST_F(FeedTransactionTest, SubTransactionOfferCreationGlobalFrozen)
line.setFieldU16(ripple::sfLedgerEntryType, ripple::ltRIPPLE_STATE);
line.setFieldAmount(ripple::sfLowLimit, ripple::STAmount(10, false));
line.setFieldAmount(ripple::sfHighLimit, ripple::STAmount(100, false));
line.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{TXNID});
line.setFieldH256(ripple::sfPreviousTxnID, ripple::uint256{kTXN_ID});
line.setFieldU32(ripple::sfPreviousTxnLgrSeq, 3);
line.setFieldU32(ripple::sfFlags, ripple::lsfHighFreeze);
auto const issueAccount = GetAccountIDWithString(ISSUER);
line.setFieldAmount(ripple::sfBalance, ripple::STAmount(GetIssue(CURRENCY, ISSUER), 100));
auto const issueAccount = getAccountIdWithString(kISSUER);
line.setFieldAmount(ripple::sfBalance, ripple::STAmount(getIssue(kCURRENCY, kISSUER), 100));
EXPECT_CALL(*backend, doFetchLedgerObject).Times(2);
EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2);
auto const kk = ripple::keylet::account(issueAccount).key;
ON_CALL(*backend, doFetchLedgerObject(testing::_, testing::_, testing::_))
ON_CALL(*backend_, doFetchLedgerObject(testing::_, testing::_, testing::_))
.WillByDefault(testing::Return(line.getSerializer().peekData()));
ripple::STObject const accountRoot = CreateAccountRootObject(ISSUER, ripple::lsfGlobalFreeze, 1, 10, 2, TXNID, 3);
ON_CALL(*backend, doFetchLedgerObject(kk, testing::_, testing::_))
ripple::STObject const accountRoot =
createAccountRootObject(kISSUER, ripple::lsfGlobalFreeze, 1, 10, 2, kTXN_ID, 3);
ON_CALL(*backend_, doFetchLedgerObject(kk, testing::_, testing::_))
.WillByDefault(testing::Return(accountRoot.getSerializer().peekData()));
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_FROZEN))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_FROZEN))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
}
TEST_F(FeedTransactionTest, SubBothProposedAndValidatedAccount)
{
auto const account = GetAccountIDWithString(ACCOUNT1);
auto const account = getAccountIdWithString(kACCOUNT1);
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(account, sessionPtr);
@@ -991,22 +996,22 @@ TEST_F(FeedTransactionTest, SubBothProposedAndValidatedAccount)
testFeedPtr->subProposed(account, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 1);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData();
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V1))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
testFeedPtr->unsub(account, sessionPtr);
testFeedPtr->unsubProposed(account, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
testFeedPtr->pub(trans1, ledgerHeader, backend);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
}
TEST_F(FeedTransactionTest, SubBothProposedAndValidated)
@@ -1018,20 +1023,20 @@ TEST_F(FeedTransactionTest, SubBothProposedAndValidated)
testFeedPtr->subProposed(sessionPtr);
EXPECT_EQ(testFeedPtr->transactionSubCount(), 1);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData();
EXPECT_CALL(*mockSessionPtr, apiSubversion).Times(2).WillRepeatedly(testing::Return(1));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V1))).Times(2);
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1))).Times(2);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
testFeedPtr->unsub(sessionPtr);
testFeedPtr->unsubProposed(sessionPtr);
testFeedPtr->pub(trans1, ledgerHeader, backend);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
}
TEST_F(FeedTransactionTest, SubProposedDisconnect)
@@ -1040,49 +1045,49 @@ TEST_F(FeedTransactionTest, SubProposedDisconnect)
testFeedPtr->subProposed(sessionPtr);
EXPECT_EQ(testFeedPtr->transactionSubCount(), 0);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData();
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V1))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
sessionPtr.reset();
testFeedPtr->pub(trans1, ledgerHeader, backend);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
}
TEST_F(FeedTransactionTest, SubProposedAccountDisconnect)
{
auto const account = GetAccountIDWithString(ACCOUNT1);
auto const account = getAccountIdWithString(kACCOUNT1);
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->subProposed(account, sessionPtr);
EXPECT_EQ(testFeedPtr->accountSubCount(), 0);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 33);
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 33);
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreatePaymentTransactionObject(ACCOUNT1, ACCOUNT2, 1, 1, 32);
ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT1, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = 32;
trans1.metadata = CreatePaymentTransactionMetaObject(ACCOUNT1, ACCOUNT2, 110, 30, 22).getSerializer().peekData();
trans1.metadata = createPaymentTransactionMetaObject(kACCOUNT1, kACCOUNT2, 110, 30, 22).getSerializer().peekData();
EXPECT_CALL(*mockSessionPtr, apiSubversion).WillOnce(testing::Return(1));
EXPECT_CALL(*mockSessionPtr, send(SharedStringJsonEq(TRAN_V1))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend);
EXPECT_CALL(*mockSessionPtr, send(sharedStringJsonEq(kTRAN_V1))).Times(1);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
sessionPtr.reset();
testFeedPtr->pub(trans1, ledgerHeader, backend);
testFeedPtr->pub(trans1, ledgerHeader, backend_);
}
struct TransactionFeedMockPrometheusTest : WithMockPrometheus, SyncExecutionCtxFixture {
protected:
web::SubscriptionContextPtr sessionPtr = std::make_shared<MockSession>();
std::shared_ptr<TransactionFeed> testFeedPtr = std::make_shared<TransactionFeed>(ctx);
MockSession* mockSessionPtr = dynamic_cast<MockSession*>(sessionPtr.get());
web::SubscriptionContextPtr sessionPtr_ = std::make_shared<MockSession>();
std::shared_ptr<TransactionFeed> testFeedPtr_ = std::make_shared<TransactionFeed>(ctx_);
MockSession* mockSessionPtr_ = dynamic_cast<MockSession*>(sessionPtr_.get());
};
TEST_F(TransactionFeedMockPrometheusTest, subUnsub)
@@ -1098,20 +1103,20 @@ TEST_F(TransactionFeedMockPrometheusTest, subUnsub)
EXPECT_CALL(counterBook, add(1));
EXPECT_CALL(counterBook, add(-1));
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(sessionPtr);
testFeedPtr->unsub(sessionPtr);
EXPECT_CALL(*mockSessionPtr_, onDisconnect);
testFeedPtr_->sub(sessionPtr_);
testFeedPtr_->unsub(sessionPtr_);
auto const account = GetAccountIDWithString(ACCOUNT1);
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(account, sessionPtr);
testFeedPtr->unsub(account, sessionPtr);
auto const account = getAccountIdWithString(kACCOUNT1);
EXPECT_CALL(*mockSessionPtr_, onDisconnect);
testFeedPtr_->sub(account, sessionPtr_);
testFeedPtr_->unsub(account, sessionPtr_);
auto const issue1 = GetIssue(CURRENCY, ISSUER);
auto const issue1 = getIssue(kCURRENCY, kISSUER);
ripple::Book const book{ripple::xrpIssue(), issue1};
EXPECT_CALL(*mockSessionPtr, onDisconnect);
testFeedPtr->sub(book, sessionPtr);
testFeedPtr->unsub(book, sessionPtr);
EXPECT_CALL(*mockSessionPtr_, onDisconnect);
testFeedPtr_->sub(book, sessionPtr_);
testFeedPtr_->unsub(book, sessionPtr_);
}
TEST_F(TransactionFeedMockPrometheusTest, AutoDisconnect)
@@ -1129,21 +1134,21 @@ TEST_F(TransactionFeedMockPrometheusTest, AutoDisconnect)
std::vector<web::SubscriptionContextInterface::OnDisconnectSlot> onDisconnectSlots;
EXPECT_CALL(*mockSessionPtr, onDisconnect).Times(3).WillRepeatedly([&onDisconnectSlots](auto const& slot) {
EXPECT_CALL(*mockSessionPtr_, onDisconnect).Times(3).WillRepeatedly([&onDisconnectSlots](auto const& slot) {
onDisconnectSlots.push_back(slot);
});
testFeedPtr->sub(sessionPtr);
testFeedPtr_->sub(sessionPtr_);
auto const account = GetAccountIDWithString(ACCOUNT1);
testFeedPtr->sub(account, sessionPtr);
auto const account = getAccountIdWithString(kACCOUNT1);
testFeedPtr_->sub(account, sessionPtr_);
auto const issue1 = GetIssue(CURRENCY, ISSUER);
auto const issue1 = getIssue(kCURRENCY, kISSUER);
ripple::Book const book{ripple::xrpIssue(), issue1};
testFeedPtr->sub(book, sessionPtr);
testFeedPtr_->sub(book, sessionPtr_);
// Emulate onDisconnect signal is called
for (auto const& slot : onDisconnectSlots)
slot(sessionPtr.get());
slot(sessionPtr_.get());
sessionPtr.reset();
sessionPtr_.reset();
}